Create ASP.NET Core Web API With Entity Framework Code First Approach

using ASPNetCoreWebAPiDemo.Models;
using ASPNetCoreWebAPiDemo.ViewModels;
using System.Collections.Generic;

namespace ASPNetCoreWebAPiDemo.Services
{
    public interface IEmployeeService
    {
        /// <summary>
        /// get list of all employees
        /// </summary>
        /// <returns></returns>
        List<Employees> GetEmployeesList();

        /// <summary>
        /// get employee details by employee id
        /// </summary>
        /// <param name="empId"></param>
        /// <returns></returns>
        Employees GetEmployeeDetailsById(int empId);

        /// <summary>
        ///  add edit employee
        /// </summary>
        /// <param name="employeeModel"></param>
        /// <returns></returns>
        ResponseModel SaveEmployee(Employees employeeModel);


        /// <summary>
        /// delete employees
        /// </summary>
        /// <param name="employeeId"></param>
        /// <returns></returns>
        ResponseModel DeleteEmployee(int employeeId);
    }
}

Step 2

Create a new class and implement the interface in this class.

Step 3

Now open your startup file and add the below line of code in ConfigurationService Method to add the dependency for our class and interface. This means when we call any method from this interface it will automatically call a method from the class.

services.AddScoped<IEmployeeService, EmployeeService>();

Constructor in Service

We are going to use DbContext in our service class for this we add dependency in the constructor as you can see in below code.

private EmpContext _context;
public EmployeeService(EmpContext context) {
    _context = context;
}

Get All Employees Method

/// <summary>
/// get list of all employees
/// </summary>
/// <returns></returns>
public List < Employees > GetEmployeesList() {
    List < Employees > empList;
    try {
        empList = _context.Set < Employees > ().ToList();
    } catch (Exception) {
        throw;
    }
    return empList;
}

In the above code, you can see that we are returning a list of employees from this method. To retrieve data from the database, we use the toList() method of DbContext.

Get Employee Details By Id Method

/// <summary>
/// get employee details by employee id
/// </summary>
/// <param name="empId"></param>
/// <returns></returns>
public Employees GetEmployeeDetailsById(int empId) {
    Employees emp;
    try {
        emp = _context.Find < Employees > (empId);
    } catch (Exception) {
        throw;
    }
    return emp;
}

In the above code, you can see that this method takes one parameter, ID. We get an employee object from the database which employee ID matches our parameter id.

Save Employee Method

/// <summary>
///  add edit employee
/// </summary>
/// <param name="employeeModel"></param>
/// <returns></returns>
public ResponseModel SaveEmployee(Employees employeeModel) {
    ResponseModel model = new ResponseModel();
    try {
        Employees _temp = GetEmployeeDetailsById(employeeModel.EmployeeId);
        if (_temp != null) {
            _temp.Designation = employeeModel.Designation;
            _temp.EmployeeFirstName = employeeModel.EmployeeFirstName;
            _temp.EmployeeLastName = employeeModel.EmployeeLastName;
            _temp.Salary = employeeModel.Salary;
            _context.Update < Employees > (_temp);
            model.Messsage = "Employee Update Successfully";
        } else {
            _context.Add < Employees > (employeeModel);
            model.Messsage = "Employee Inserted Successfully";
        }
        _context.SaveChanges();
        model.IsSuccess = true;
    } catch (Exception ex) {
        model.IsSuccess = false;
        model.Messsage = "Error : " + ex.Message;
    }
    return model;
}

As you have seen in the above code, we take the employee model as a parameter. Then we called our get details by id method to get details of an employee by id and store In temp variable.

Here if employee Id is coming with a model which means we have to update the employee and if the employee id is null or zero then we have added a new employee.

If we got data in the temp variable then we assign new data from our parameter model and update employee context and with that, we also assign messages to our response model.

And if we got the temp variable is null, then we insert the parameter model as in context and pass the message in the response model.

In last, we called the save changes method of context to save all changes like insert update and set Is Success property of response model to true. If any error occurs, then we update is success to false and pass error message in message property.

Delete Employee Method

/// <summary>
/// delete employees
/// </summary>
/// <param name="employeeId"></param>
/// <returns></returns>
public ResponseModel DeleteEmployee(int employeeId) {
    ResponseModel model = new ResponseModel();
    try {
        Employees _temp = GetEmployeeDetailsById(employeeId);
        if (_temp != null) {
            _context.Remove < Employees > (_temp);
            _context.SaveChanges();
            model.IsSuccess = true;
            model.Messsage = "Employee Deleted Successfully";
        } else {
            model.IsSuccess = false;
            model.Messsage = "Employee Not Found";
        }
    } catch (Exception ex) {
        model.IsSuccess = false;
        model.Messsage = "Error : " + ex.Message;
    }
    return model;
}

In the delete method, we take employee id as a parameter. And call service method get detail by id forget employee details.

If an employee is found then we remove this employee by calling remove method of context, else we return the model with Employee not found message

Implement Service in Controller

Now our service is ready, so now we implement it in our controller.

Step 1

Add new controller by Right-click in Controllers folder then click in Add then Controller.

Step 2

Now select API from the filter and select API Controller – Empty and click on Add button.

Step 3

Now give an appropriate name and click on Add button.

Constructor Of Controller

In the Constructor of our controller, we implement dependency injection for our service.

IEmployeeService _employeeService;
public EmployeeController(IEmployeeService service) {
    _employeeService = service;
}

For this controller, we are using routing with action methods. For example, if the user called Employee with Get method then it will call Get List Of All Employee Method and if the user called Employee/{id} with Get then it will call Get Employee Details By Id Method and If user called Employee with POST method then it will call Save Employee Method and same as if the user called Employee with Delete method then it will call Delete Employee Method

Get List Of All Employee Method

/// <summary>
/// get all employess
/// </summary>
/// <returns></returns>
[HttpGet]
[Route("[action]")]
public IActionResult GetAllEmployees() {
    try {
        var employees = _employeeService.GetEmployeesList();
        if (employees == null) return NotFound();
        return Ok(employees);
    } catch (Exception) {
        return BadRequest();
    }
}

in the above method, we call a method from our service and assign it to the variable. If the variable is not null then we return ok status with this variable, else we return not found.

Get Employee Details By Id Method

/// <summary>
/// get employee details by id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpGet]
[Route("[action]/id")]
public IActionResult GetEmployeesById(int id) {
    try {
        var employees = _employeeService.GetEmployeeDetailsById(id);
        if (employees == null) return NotFound();
        return Ok(employees);
    } catch (Exception) {
        return BadRequest();
    }
}

Save Employee Method

/// <summary>
/// save employee
/// </summary>
/// <param name="employeeModel"></param>
/// <returns></returns>
[HttpPost]
[Route("[action]")]
public IActionResult SaveEmployees(Employees employeeModel) {
    try {
        var model = _employeeService.SaveEmployee(employeeModel);
        return Ok(model);
    } catch (Exception) {
        return BadRequest();
    }
}

Delete Employee Method

/// <summary>
/// delete employee  
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpDelete]
[Route("[action]")]
public IActionResult DeleteEmployee(int id) {
    try {
        var model = _employeeService.DeleteEmployee(id);
        return Ok(model);
    } catch (Exception) {
        return BadRequest();
    }
}

Test API Using Swagger

While creating this project we added open AI support so when to run this project it will open the swagger page as seen below image. From here we can test our API.

Add New Employee

Expand Save Employee Method and click on the try it now button. Now JSON fields are editable, to add data in the model as seen in below first image and click on execute. In the second image, you can see that data is updated in our table also.

Update Existing Employee

In this request, we are passing the same model as we pass in the previous request but in the model, we pass id also.

Get Employee Details By Id

Get List of Employees

Delete Employee

If Employee Not Exist

Conclusion

In this article, we create a simple Employee API with Entity Framework Core. In future articles, I implement authentication and also connect this API to Angular. So if you find this article helpful, kindly share it with your friends.