.NET Core Web API CRUD with Entity Framework | DotNetSchool

Complete Examples, Step by Step: Implementing CRUD with ASP.NET Web API and Entity Framework for Beginners

Prerequisites:

1. Visual Studio 2019 or later.
2. Basic knowledge of C#.
3. .NET Framework or .NET Core SDK.
4. Basic knowledge of SQL Server (or another database you prefer).

Step 1: Create a New ASP.NET Web API Project

1. Open Visual Studio and select Create a new project.
2. Choose ASP.NET Core Web Application and click Next.
3. Provide your project with a name, location, and solution name, then click Create.
4. In the next dialog, select the API template. Ensure the framework version is set to .NET 6.0 (Long Term Support) or the latest version, then click Create.

Step 2: Set Up the Database Context with Entity Framework Core

1. Install Entity Framework Core NuGet Package:

   • Right-click on your project in the Solution Explorer and choose Manage NuGet Packages.
   • Go to the Browse tab and search for the following packages:
     • Microsoft.EntityFrameworkCore.SqlServer
     • Microsoft.EntityFrameworkCore.Tools
   • Install them by clicking Install.

2. Create a Model Class:

   • Right-click on the Models folder and choose Add > New Item.

   • Select Class and name it Employee.cs.

   • Implement the Employee class:

     namespace WebApiCRUD.Models
     {
         public class Employee
         {
             public int Id { get; set; }
             public string Name { get; set; }
             public string Email { get; set; }
             public string Department { get; set; }
         }
     }
     

3. Create a Database Context Class:

   • Right-click on the Models folder and choose Add > New Item.

   • Select Class and name it AppDbContext.cs.

   • Implement the AppDbContext class:

     using Microsoft.EntityFrameworkCore;
     
     namespace WebApiCRUD.Models
     {
         public class AppDbContext : DbContext
         {
             public AppDbContext(DbContextOptions<AppDbContext> options) 
                 : base(options)
             {
             }
     
             public DbSet<Employee> Employees { get; set; }
         }
     }
     

4. Configure the Connection String in appsettings.json:

   {
     "ConnectionStrings": {
       "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=WebApiCRUD;Trusted_Connection=True;MultipleActiveResultSets=true"
     },
     "Logging": {
       "LogLevel": {
         "Default": "Information",
         "Microsoft.AspNetCore": "Warning"
       }
     },
     "AllowedHosts": "*"
   }
   

5. Configure Services in Program.cs:

   using Microsoft.EntityFrameworkCore;
   using WebApiCRUD.Models;
   
   var builder = WebApplication.CreateBuilder(args);
   
   // Add services to the container.
   builder.Services.AddControllers();
   
   builder.Services.AddDbContext<AppDbContext>(options =>
       options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
   
   var app = builder.Build();
   
   // Configure the HTTP request pipeline.
   if (app.Environment.IsDevelopment())
   {
       app.UseDeveloperExceptionPage();
   }
   
   app.UseHttpsRedirection();
   
   app.UseAuthorization();
   
   app.MapControllers();
   
   app.Run();
   

6. Run the Migrations to Create the Database and Tables:

   • Open the Package Manager Console in Visual Studio.

   • Execute the following commands:

     Add-Migration InitialCreate
     Update-Database
     

   This will create the database and a Employees table based on your model.

Step 3: Create the Controller to Handle CRUD Operations

1. Add a New Controller:

   • Right-click on the Controllers folder and choose Add > Controller.
   • Select API Controller with read/write actions and click Add.
   • Name your controller EmployeesController.

2. Implement the CRUD Operations:

   using Microsoft.AspNetCore.Mvc;
   using Microsoft.EntityFrameworkCore;
   using System.Collections.Generic;
   using System.Linq;
   using System.Threading.Tasks;
   using WebApiCRUD.Models;
   
   namespace WebApiCRUD.Controllers
   {
       [Route("api/[controller]")]
       [ApiController]
       public class EmployeesController : ControllerBase
       {
           private readonly AppDbContext _context;
   
           public EmployeesController(AppDbContext context)
           {
               _context = context;
           }
   
           // GET: api/Employees
           [HttpGet]
           public async Task<ActionResult<IEnumerable<Employee>>> GetEmployees()
           {
               return await _context.Employees.ToListAsync();
           }
   
           // GET: api/Employees/5
           [HttpGet("{id}")]
           public async Task<ActionResult<Employee>> GetEmployee(int id)
           {
               var employee = await _context.Employees.FindAsync(id);
   
               if (employee == null)
               {
                   return NotFound();
               }
   
               return employee;
           }
   
           // PUT: api/Employees/5
           [HttpPut("{id}")]
           public async Task<IActionResult> PutEmployee(int id, Employee employee)
           {
               if (id != employee.Id)
               {
                   return BadRequest();
               }
   
               _context.Entry(employee).State = EntityState.Modified;
   
               try
               {
                   await _context.SaveChangesAsync();
               }
               catch (DbUpdateConcurrencyException)
               {
                   if (!EmployeeExists(id))
                   {
                       return NotFound();
                   }
                   else
                   {
                       throw;
                   }
               }
   
               return NoContent();
           }
   
           // POST: api/Employees
           [HttpPost]
           public async Task<ActionResult<Employee>> PostEmployee(Employee employee)
           {
               _context.Employees.Add(employee);
               await _context.SaveChangesAsync();
   
               return CreatedAtAction("GetEmployee", new { id = employee.Id }, employee);
           }
   
           // DELETE: api/Employees/5
           [HttpDelete("{id}")]
           public async Task<IActionResult> DeleteEmployee(int id)
           {
               var employee = await _context.Employees.FindAsync(id);
               if (employee == null)
               {
                   return NotFound();
               }
   
               _context.Employees.Remove(employee);
               await _context.SaveChangesAsync();
   
               return NoContent();
           }
   
           private bool EmployeeExists(int id)
           {
               return _context.Employees.Any(e => e.Id == id);
           }
       }
   }
   

Step 4: Test the API

1. Run the Project:

   • Press F5 or click the Run button in Visual Studio.

2. Test with a Web Browser or a Tool like Postman:

   • Open a web browser or Postman.

   • Navigate to GET https://localhost:<port>/api/Employees to retrieve the list of employees.

   • Use POST https://localhost:<port>/api/Employees to add a new employee with a JSON body:

     {
       "name": "John Doe",
       "email": "john@example.com",
       "department": "IT"
     }
     

   • Similarly, you can test PUT and DELETE methods to update and delete employees.

Conclusion