How To Create Industry Standard .NET Core CRUD API Quickly

• Right-click the Logics folder.
• Select Add > Class.
• Name the class ProductRepository.
• Select "Add".
• Replace with the below code.

  using RS2.Core;
  using Microsoft.EntityFrameworkCore;
  
  namespace BusinessLogic {
      public interface IProductRepository : IRepositoryBase<Product, long> {}
      
      public class ProductRepository : RepositoryBase<Product, long>, IProductRepository {
          public ProductRepository(IUnitOfWork unitOfWork) : base(unitOfWork) {}
  
          protected override IQueryable<Product> GetAllAsyncQuery(bool excludeDeleted = true) {
              return Entity.Include(e => e.Category).Where(p => !excludeDeleted || p.IsActive);
          }
      }
  }
  

Creating API

Now, let's create a Web API project and create the ASPI for both Category and Product entities. Add a new project with the below steps.

• Right-click the solution.
• Select Add > New Project.
• Select Web > ASP.NET Core Web Applications.
• Name the project as API, and select OK.
• Now, select the API template and press OK.
• Right-click solution.
• Select "Manage NuGet Packages for Solution".
• Choose the Installed tab and select RS2.Core.
• Mark Api project at the right side window and click install.
• Accept the license for installation to complete.
  

Adding a Business Logic project reference to the API project

To use business entities and logic in the API project, we are adding the BusinessLogic project reference to the API project using the below steps.

• Right-click on the dependencies of the API project
• Select "Add Reference".
• Select the Projects tab on the left side.
• Mark the BusinessLogic from the list and press OK.

Now, create the API controllers for Category and Product by the below-given steps.

Category Controller

• Right-click the Controllers folder.
• Select Add > Controller, and select the API Controller - Empty template.
• In the "Add New Item" dialog, name the class CategoriesController, and select Add.

Let's call the CRUD operations from business logic. The below code will explain how to call business logic from our API for the Category entity.

using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using RS2.Core;
using BusinessLogic;

namespace Api.Controllers
{
    [Produces("application/json")]
    [Route("api/[controller]")]
    [ApiController]
    public class CategoriesController : ControllerBase
    {
        private ICategoryRepository _categoryRepository;
        private IUnitOfWork _unitOfWork;

        public CategoriesController(ICategoryRepository categoryRepository, IUnitOfWork unitOfWork)
        {
            _categoryRepository = categoryRepository;
            _unitOfWork = unitOfWork;
        }

        // GET: api/Categories
        [HttpGet]
        public async Task<IEnumerable<Category>> Get()
        {
            return await _categoryRepository.GetAllAsync();
        }

        // GET: api/Categories/5
        [HttpGet("{id}")]
        public async Task<Category> Get(int id)
        {
            return await _categoryRepository.GetAsync(id);
        }

        // POST: api/Categories 
        [HttpPost]
        public async Task Post([FromBody] Category category)
        {
            await _categoryRepository.SaveAsync(category);
            // Commit the changes.
            await _unitOfWork.CommitAsync();
        }

        // DELETE: api/ApiWithActions/5
        [HttpDelete("{id}")]
        public async Task Delete(int id)
        {
            await _categoryRepository.SoftDelete(id); // Set Deleted flag.
            //await _categoryRepository.HardDelete(id); // Delete from DB
            // Commit the changes.
            await _unitOfWork.CommitAsync();
        }
    }
}

Products Controller

• Right-click the Controllers folder.
• Select Add > Controller, and select the API Controller - Empty template.
• In the "Add New Item" dialog, name the class asProductsController, and select Add.

The below code will explain how to call the API methods from business logic for the product entity.

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using RS2.Core;
using BusinessLogic;

namespace Api.Controllers
{
    [Produces("application/json")]
    [Route("api/[controller]")]
    [ApiController]
    public class ProductsController : ControllerBase
    {
        private IProductRepository _productRepository;
        private IUnitOfWork _unitOfWork;

        public ProductsController(IProductRepository productRepository, IUnitOfWork unitOfWork)
        {
            _productRepository = productRepository;
            _unitOfWork = unitOfWork;
        }

        // GET: api/Products
        [HttpGet]
        public async Task<IEnumerable<Product>> Get()
        {
            return await _productRepository.GetAllAsync();
        }

        // GET: api/Products/5
        [HttpGet("{id}")]
        public async Task<Product> Get(int id)
        {
            return await _productRepository.GetAsync(id);
        }

        // POST: api/Products
        [HttpPost]
        public async Task Post([FromBody] Product product)
        {
            await _productRepository.SaveAsync(product);
            // Commit the changes.
            await _unitOfWork.CommitAsync();
        }

        // DELETE: api/ApiWithActions/5
        [HttpDelete("{id}")]
        public async Task Delete(int id)
        {
            await _productRepository.SoftDelete(id); // Set Deleted flag.
            //await _productRepository.HardDelete(id); // Delete from DB
            // Commit the changes.
            await _unitOfWork.CommitAsync();
        }
    }
}

Register the dependencies

Now, we need to register the dependencies, i.e., in the above controller code, we are just injecting the appropriate interface and calling the methods. So, we are configuring the dependency to that interface saying this interface contains the object for this class. For example, if we use IProductRepository, that should hold the object of the ProductRepository class. These dependencies we are injecting at StartUp.cs. The below code will explain how to configure a dependency in StartUp.cs.

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
    services.AddDbContext<ShoppingContext>(options => options.UseSqlServer(Configuration.GetConnectionString("ShoppingConnection")));
    services.AddScoped<DbContext, ShoppingContext>();
    services.AddScoped<IUnitOfWork, UnitOfWork>();
    services.AddScoped<ICategoryRepository, CategoryRepository>();
    services.AddScoped<IProductRepository, ProductRepository>();
}

We are done with the ApI creation. Below is an example of calling the API. Make sure you have configured the connection string properly in the appsettings.json file.

• https://localhost:8080/api/products/2
• https://localhost:8080/api/categories