In this blog post, we will create an ASP.NET Core Web API from scratch step by step.
We will follow RESTful principles and create CRUD operations and create an ASP.NET Core Web API in .NET Core version 3.1.
During the implementation, we install and use Entity Framework Core to connect to our SQL Server database and perform CRUD operations.
Create ASP.NET Core WEB API Template Using Visual Studio 2019
We will open Visual Studio 2019 in which we will create our ASP.NET Core web API.
1. Click On Create A New Project
First, we will open Visual Studio 2019 and click on "Create a new project"
Give a name to your ASP.NET Core project and solution and also give it a path where you want to save your solution.
4. Select ASP.NET Core Version
From this window, please select the ASP.NET Core version that is installed in your system. In this example, we will use ASP.NET Core 3.1.
Click on the "Create" button to create the template project.
Create New Controller For ASP.NET Core Web API
It's now time to create a new API controller for our application. This new controller will be the API endpoint for our ASP.NET Core Web API.
We will right-click on the controller folder to add a new controller to our solution.
Give it a valid name.
We are creating a new controller for our Employees endpoint. So, we will give the name of the controller as "EmployeesController".
In this controller, we will add Action methods to perform CRUD operations like GET, POST, PUT and DELETE.
Create Repository Interface and Repository Implementation - Repository Pattern In ASP.NET Core
We will now create a new folder in our solution.
We will name this folder "EmployeeData".
In this folder, we will create a new interface called "IEmployeeInterface"
using RestApiTutorial.Models; using System; using System.Collections.Generic; namespace RestApiTutorial.EmployeeData { public interface IEmployeeData { Employee AddEmployee(Employee employee); List
Install Entity Framework Core To Our ASP.NET Core API (EF Core)
Let's install Entity Framework core to our application.
"Right-Click" on dependencies and click on "Manage Nuget Packages".
Microsoft.EntityFrameworkCore.SqlServer
The second package we will install is Microsoft.EntityFrameworkCore.Tools
Create DbContext Using EntityFrameworkCore And Run Migrations
1. Create EmployeeContext Folder and EmployeeDbContext
Create a new EmployeeContext folder in your solution.
Then create a new class in this folder called EmployeeDbContext. This inherits from DbContext.
using Microsoft.EntityFrameworkCore; using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; namespace RestApiTutorial.Models { public class EmployeeDbContext: DbContext { public EmployeeDbContext(DbContextOptions
2. Create Employee Model And EF Core Data Annotations
using System; using System.ComponentModel.DataAnnotations; using System.ComponentModel.DataAnnotations.Schema; namespace RestApiTutorial.Models { public class Employee { [Key] public Guid Id { get; set; } [Required] [MaxLength(50, ErrorMessage = "Name cannot be longer than 50 characters long")] public string Name { get; set; } } }
3. Add Connection String To AppSettings.json
{ "Logging": { "LogLevel": { "Default": "Information", "Microsoft": "Warning", "Microsoft.Hosting.Lifetime": "Information" } }, "AllowedHosts": "*", "ConnectionStrings": { "EmployeeDbConnection": "server=.;database=EmployeeDB;Trusted_Connection=true" } }
4. Inject DbContext Into Services Using Dependency Injection
Now, we will use dependency injection and inject the EmployeeDbContext into our application services in the startup.cs file.
We will use the connection string that we created in the appsettings.json file and use it inside our startup.cs class to inject the EmployeeDbContext in our API services.
Open Startup.cs and add the below code.
services.AddScoped
5. Run Entity Framework Core Migrations (Ef Core Migrations)
Now, we will run EF Core migrations and create the new database inside our database.
To run migrations, go to Tools > Nuget Package Manager > Package Manager Console
Once the Package Manager Console is open, run the following commands one by one:
1. add-migrations "Initial Migration"
The wordings inside the quote could be anything that you like. Because this is the first migration, we will name it "Initial Migration"
2. update-database
Once the add-migrations command is over, run the update-database command and this command will create the database for you.
You can go ahead to SQL Server and check the progress. You should now have a new database in the server.
Create Repository Implementation For IEmployeeRepository
Now, it's time to create the repository implementation for IEmployeeRepository.
We will call this SqlEmployeeRepository.
Create a new class inside the same folder where we had the IEmployeeRepository.
As the repository implementation implements the IEmployeeRepository, we will create implementations for all the methods in the SqlEmployeeRepository.
We will use EF Core and the injected DbContext to connect and talk to our database.
The code for the SqlEmployeeDbContext will look like below:
using RestApiTutorial.Models; using System; using System.Collections.Generic; using System.Linq; namespace RestApiTutorial.EmployeeData { public class SqlEmployeeData : IEmployeeData { private EmployeeDbContext _employeeContext; public SqlEmployeeData(EmployeeDbContext employeeContext) { _employeeContext = employeeContext; } public Employee AddEmployee(Employee employee) { employee.Id = Guid.NewGuid(); _employeeContext.Employees.Add(employee); _employeeContext.SaveChanges(); return employee; } public void DeleteEmployee(Employee employee) { _employeeContext.Employees.Remove(employee); _employeeContext.SaveChanges(); } public Employee EditEmployee(Employee employee) { var currentEmployee = _employeeContext.Employees.Find(employee.Id); currentEmployee.Name = employee.Name; _employeeContext.Update(currentEmployee); _employeeContext.SaveChanges(); return currentEmployee; } public Employee GetEmployee(Guid id) { var employee = _employeeContext.Employees.Find(id); if(employee != null) { return employee; } return null; } public List
Use DbContext Inside Controller And Perform CRUD Operations
Now that we have created our new database and created a repository that performs CRUD operations, it's now time to inject this repository inside the controller.
The controller will have ActionMethods that implement CRUD operations.
The code for the controller will look like below:
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Routing; using RestApiTutorial.EmployeeData; using RestApiTutorial.Models; using System; namespace RestApiTutorial.Controllers { [ApiController] public class EmployeesController : ControllerBase { private IEmployeeData _employeeData; public EmployeesController(IEmployeeData employeeData) { _employeeData = employeeData; } [HttpGet] [Route("api/[controller]")] public IActionResult GetEmployees() { return Ok(_employeeData.GetEmployees()); } [HttpGet] [Route("api/[controller]/{id}")] public IActionResult GetEmployee(Guid id) { var employee = _employeeData.GetEmployee(id); if (employee != null) { return Ok(employee); } return NotFound($"Employee with Id {id} was not found."); } [HttpPost] [Route("api/[controller]")] public IActionResult AddEmployee(Employee employee) { var createdEmployee = _employeeData.AddEmployee(employee); return Created( String.Format(HttpContext.Request.Scheme + "://" + HttpContext.Request.Host + HttpContext.Request.Path + "/" + employee.Id), employee); } [HttpDelete] [Route("api/[controller]/{id}")] public IActionResult DeleteEmployee(Guid id) { var employee = _employeeData.GetEmployee(id); if (employee != null) { _employeeData.DeleteEmployee(employee); return Ok(); } return NotFound($"Employee with Id {id} was not found."); } [HttpPatch] [Route("api/[controller]/{id}")] public IActionResult EditEmployee(Guid id, Employee employee) { var currentEmployee = _employeeData.GetEmployee(id); if(currentEmployee != null) { employee.Id = id; _employeeData.EditEmployee(employee); return Ok(); } return NotFound($"Employee with Id {employee.Id} was not found."); } } }
Run ASP.NET Core Web API and Test Using Postman
Our Asp.net core web API is built and ready to be consumed.
We will use Postman to test our API.
We will call the API endpoints that we created and verify the results.