Forem: Andrés Díaz

How to migrate your WebAPI to MediatRV12.

Andrés Díaz — Sun, 05 Mar 2023 16:11:39 +0000

In a previous post, we explain how to build a web API with CQRS and MediatR.How to Build a Clean WebAPI Net 6.

Why migrate to MediatR V12

MediatR v12 is the latest version of MediatR, and it comes with several new features and improvements. If you're currently using an older version of MediatR and want to upgrade to v12, here's how to do it:

Step 1: Update the Nuget packages.

We first need to remove the current MediatR Nugets and add the latest version since the newest version is all-in, assuming we are using MediatR with dependency injection.

*MediatR
*MediatR.Extensions.Microsoft.DependencyInjection

we can use this command from PowerShell or terminal using dotnet cli to remove the current nugets:

dotnet remove package MediatR
dotnet remove package MediatR.Extensions.Microsoft.DependencyInjection

Then the current nugets are removed, and the next step is to add the latest version.

dotnet add package MediatR --version 12.0.0

Step 2 : Update the mediator registration

The way of registration has changed; we have to call the builder.Services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly())); in the Program.cs file instead of builder.Services.AddMediatR(Assembly.GetExecutingAssembly());.

Step 3 : Update your handlers

The last step is to change the void requests returning Unit to only a return.In this case, the class handler is updated like this:

Previous code


public sealed class EditExistingCustomerHandler : IRequestHandler<EditExistingCustomerCommand, Unit>
{
...

   public async Task<Unit> Handle(EditExistingCustomerCommand 
   request, CancellationToken cancellationToken)
   {
        var customerToUpdate =  _mapper.Map<Customer> 
                                 (request.customerToUpdate);
        await 
            _customerRepository.UpdateAsync(customerToUpdate);
        return Unit.Value;;
   }
}

MediatR version V12 code


public sealed class EditExistingCustomerHandler : IRequestHandler<EditExistingCustomerCommand>
{
...

     public async Task Handle(EditExistingCustomerCommand 
     request, CancellationToken cancellationToken)
    {
          var customerToUpdate =  _mapper.Map<Customer> 
                                 (request.customerToUpdate);
        await 
            _customerRepository.UpdateAsync(customerToUpdate);
        return;
    }
}

Important Note : if you method is not async, the return is
return Task.CompletedTask.

We can get more details about How to migrate to this version here

Recaps

On this topic, we learned that Upgrading to MediatR v12 is a straightforward process that requires updating your NuGet packages, mediator registration, handlers, requests, and responses. By following these steps, you can take advantage of the new features and improvements in v12 and keep your application up-to-date with the latest technologies.
If you enjoyed this article, please subscribe and follow me.

How to Build a Web API ASP.NET Core 6 (Part 3)

Andrés Díaz — Thu, 16 Feb 2023 15:23:25 +0000

In the previous post, we discussed how to build a web API applying useful patterns like CQRS and Mediator Pattern using this package MediatR.

At this time, we are ending this serie with Fluent Validations and Middlewares.

Before starting with visual studio, we explain what kind of problems resolve Fluent Validations and Middlewares.

What is FluentValidations

It is a popular Net Library used for building strict validation rules fluently. Allow easily configure rules using lambda expression and furthermore unlike the data annotations provided in .net allow decoupling the data validations and logic from your models reducing the complexity to create rules.

Why to use Fluent Validations

In this case we want to use to define rules for validate our commands using validators and throws our validations using pipelines behaviors.

Middlewares

The middleware controls how our application responds to http requests , and allows us to change the behavior when our application throws errors.

Get more details here.

Why to use Middlewares

In this case we have to use middlewares to handle validation exceptions a take the control of responses when the failures occurred.

Step 1
We are building our validators for the commands models.

Before to start Apply those packages:

*FluentValidation
*FluentValidation.DependencyInjectionExtensions

The next step is to start defining the validator for the command models.

In this case we have this command model:

*CreateNewCustomerCommand

Create a folder Validators and Create the class CreateNewCustomerCommandValidator for the command CreateNewCustomerCommand like this.

CreateNewCustomerCommandValidator

using FluentValidation;
using WebApiCustomers.Commands;

namespace WebApiCustomers.Validators;

public class CreateNewCustomerCommandValidator : AbstractValidator<CreateNewCustomerCommand>
{
    public CreateNewCustomerCommandValidator()
    {
        RuleFor(x => x.customerToCreate.FirstName)
            .NotEmpty().WithMessage("{PropertyName} no puede estar en blanco");
        RuleFor(x => x.customerToCreate.LastName).NotEmpty();
        RuleFor(x => x.customerToCreate.EmailAddress).NotEmpty();          
    }
}

In this case for the field FirstName we are adding a custom message in spanish.

Step 2
The next step is to create our pipeline behavior to get all validation failures and throw a validation exception.

using AutoMapper.Configuration;
using FluentValidation;
using MediatR;

namespace WebApiCustomers.PipelineBehavoirs;

public class ValidationBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    private IEnumerable<IValidator<TRequest>> _validators;

    public ValidationBehavior(IEnumerable<IValidator<TRequest>> validators)
    {
        _validators = validators;
    }
    public  Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
    {
        var context = new ValidationContext<TRequest>(request);

        var failures = _validators.Select(v => v.Validate(context))
                                    .SelectMany(e => e.Errors)
                                    .Where(x => x != null)
                                    .ToList();


        if(failures.Any())
        {
            throw new ValidationException(failures);
        }

        return  next();

    }     
}

Step 3

The next step is to create our middleware for catch all exceptions and format the validation exceptions using the interface IMiddleware.

using FluentValidation;
using FluentValidation.Results;
using Microsoft.AspNetCore.Diagnostics;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ApplicationModels;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Net;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;


namespace WebApiCustomers.Middlewares
{
    internal sealed class ExceptionFluentValidationMiddleware : IMiddleware
    {

        public async Task InvokeAsync(HttpContext context, RequestDelegate next)
        {
            try
            {
                await next(context);
            }
            catch (Exception ex)
            {
                await HandleException(context, ex);
            }   
        }

        private static async Task HandleException(HttpContext context, Exception? exception)
        {
            string jsonContent = String.Empty;

            if (!(exception is ValidationException validationException))
            {

                jsonContent = JsonSerializer.Serialize(new { 
                    Errors = new { Detail = "Internal error"}
                });

                context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;

            }
            else
            {
                var errors = validationException.Errors.Select(err => new
                {
                   ErrorMessage =  err.ErrorMessage,
                   PropertyName  = err.PropertyName.Split(".")[1].ToString()
                });

                jsonContent = JsonSerializer.Serialize(errors);
                context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
            }

            context.Response.ContentType = "application/json";
            await context.Response.WriteAsync(jsonContent, encoding: Encoding.UTF8);

        }
    }
}

Step 4

And the last step we are implementing in the program class our middleware like this.

app.UseMiddleware<ExceptionFluentValidationMiddleware>();

Recaps

On these topics , we are implementing the validation on elegant way for our command models with one of the best validation library Fluent Validations.

On the other hand we learned how to use middleware to handle response for handle global exceptions.

In the end, with learned about these topics:

*Fluent Validations with Pipeline Behaviors
*Middlewares on Net 6

If you enjoyed this article, please subscribe and follow this series about building clean web API Net Core 6.

How to Build a Web API ASP.NET Core 6 (Part 2)

Andrés Díaz — Fri, 21 Oct 2022 01:58:38 +0000

In the previous post, we discussed how to build a web API applying useful patterns like dependency injection, repository, and some NuGet packages like automapper Part 1.
At this time, we are continuing with CQRS and Mediator patterns.

Before starting with visual studio, we explain what kind of problems resolve CQRS and Mediator patterns.

CQRS

CQRS are the acronyms of Command Query and Responsibility Segregation. This pattern pursues how to separate read and update operations for CRUD. However, be careful not to apply for any project and add extra complexity because this pattern is not bulletproof.

Why use CQRS

In common architectures, the typical case is to use the same model for query and update databases, which works perfectly for simple CRUD operations. But in complex projects, it can be tricky. To be more explicit, we would need to perform different queries returning specific Dtos, and the write models set multiples and complex validations following the business logic.

Can you check more about CQRS

Mediator Pattern

This pattern is part of the family of the behavior design pattern, and the main goal is coordinate the relations between associate objects. And is help us to define how to encapsulate the integration of each of these different objects. On the other hand, it Promotes low coupling to prevent these objects from being referenced explicitly and allows to change dependency easier between them.

Why use Mediator

In this case, we need to use this pattern because we are creating a mechanism to communicate all requests to use queries or commands through the handlers.
The handler is the class where you create the task, follow the queries or commands requirements, accessing the storage through repositories.

MediatR

But to facilitate the implementation of these patterns described before, we are using these NuGet packages.

*MediatR
*MediatR.Extensions.Microsoft.DependencyInjection

Before to start creating commands and query models, we are adding the service MediatR to the program.cs file like this way :

builder.Services.AddMediatR(Assembly.GetCallingAssembly();

Step 1
Now We have to build different types of elements for the queries, commands, and handlers. Therefore we have to add these folders to keep a clean structure.

/queries
/commands
/handlers

The next step is to start defining the queries and command models.

Tips:

Commands: should be defined like a simple name task and not describe action data on the database.
Example “CreateNewCustomer” instead of “InsertCustomer”
Queries: the queries never update the database. Only could return dtos with the data requested.

Step 2

Queries

Now Let’s go to create the query models.

In this case, we are creating the query models, so we will be required to use the IRequest interface with the dto to return.

In this case, we take advantage of records. In this way, we don't have to define a constructor and keep the immutability.

GetAllCustomersQuery

using MediatR;
using WebApiCustomers.Dtos;
namespace WebApiCustomers.Queries;
public sealed record GetAllCustomersQuery : IRequest<List<CustomerReadDto>>;

GetOneCustomerByIdentifierQuery

using MediatR;
using WebApiCustomers.Dtos;

namespace WebApiCustomers.Queries;
public sealed record GetOneCustomerByIdentifierQuery (int Id)  :IRequest<CustomerReadDto>;

Commands

In this step, we continue creating the commands.

CreateNewCustomerCommand

In this case, we are creating a simple record that returns the CustomerCreateDto object.

using MediatR;
using WebApiCustomers.Dtos;

namespace WebApiCustomers.Commands;
public sealed record CreateNewCustomerCommand (CustomerCreateDto customerToCreate) : IRequest<CustomerReadDto>;

EditExistingCustomerCommand

In this case, the IRequest interface has no parameters because we don't want to return anything.

using MediatR;
using WebApiCustomers.Dtos;

namespace WebApiCustomers.Commands;

public sealed record EditExistingCustomerCommand (CustomerUpdateDto customerToUpdate) : IRequest;

RemoveExistingCustomer

We have the same signature in this command because we don't want to return anything either.

using MediatR;
using WebApiCustomers.Dtos;
namespace WebApiCustomers.Commands;
public sealed record RemoveExistingCustomerCommand (int Id) : IRequest;

Step 3

Now we are ready to add our handlers for queries and command models.

Handlers

The handlers are responsible for receiving the request and encapsulating the functionality to accomplish the incoming request with specific signatures that may change if they are queries or command requests inherited from the IRequestHandler interface.

Now we are defining these handlers.

GetAllCustomersHandler

On this handler, we are using the repository to get all customers and mapping the object to the requested object CustomerReadDto

using AutoMapper;
using MediatR;
using WebApiCustomers.Dtos;
using WebApiCustomers.Queries;
using WebApiCustomers.Repositories;

namespace WebApiCustomers.Handlers;

public class GetAllCustomersHandler : IRequestHandler<GetAllCustomersQuery, List<CustomerReadDto>>
{
   private readonly ICustomerRepository _customerRepository;
   private IMapper _mapper;
   public GetAllCustomersHandler(ICustomerRepository customerRepository, IMapper mapper)
   {
       _customerRepository = customerRepository;
       _mapper = mapper;
   }
   public async Task<List<CustomerReadDto>> Handle(GetAllCustomersQuery request, CancellationToken cancellationToken)
   {
       var customerList = await _customerRepository.GetAllAsync();
       return _mapper.Map<List<CustomerReadDto>>(customerList);
   }
}

GetOneCustomerByIdentifierHandler

On this handler, we are using the repository to get one customer by identifier and mapping the requested object CustomerReadDto.

Using AutoMapper;
using MediatR;
using WebApiCustomers.Data;
using WebApiCustomers.Dtos;
using WebApiCustomers.Queries;
using WebApiCustomers.Repositories;

namespace WebApiCustomers.Handlers;

public sealed class GetOneCustomerByIdentifierHandler :
IRequestHandler<GetOneCustomerByIdentifierQuery, CustomerReadDto>
{
   private readonly ICustomerRepository _customerRepository;
   private readonly IMapper _mapper;

   public GetOneCustomerByIdentifierHandler(ICustomerRepository customerRepository, IMapper mapper )
   {
       _customerRepository = customerRepository;
       _mapper = mapper;
   }
   public async Task<CustomerReadDto> Handle(GetOneCustomerByIdentifierQuery request, CancellationToken cancellationToken)
   {
       var customer = await _customerRepository.GetAsync(request.Id);
       return _mapper.Map<CustomerReadDto>(customer);
   }
}

CreateNewCustomerHandler

On this handler, we are using the repository to create a new customer and mapping the object requested object CustomerReadDto.

using AutoMapper;
using MediatR;
using WebApiCustomers.Commands;
using WebApiCustomers.Data;
using WebApiCustomers.Dtos;
using WebApiCustomers.Repositories;

namespace WebApiCustomers.Handlers;
public class CreateNewCustomerHandler : IRequestHandler<CreateNewCustomerCommand, CustomerReadDto>
{
   private readonly ICustomerRepository _customerRepository;
   private readonly IMapper _mapper;

   public CreateNewCustomerHandler(ICustomerRepository customerRepository, IMapper mapper)
   {
       _customerRepository = customerRepository;
       _mapper = mapper;
   }
   public async Task<CustomerReadDto?> Handle(
       CreateNewCustomerCommand request,
       CancellationToken cancellationToken)
   {
         var customerToInsert = _mapper.Map<Customer>(request.customerToCreate);
           await _customerRepository.AddAsync(customerToInsert);
           await _customerRepository.SaveAsync();
           var result  = _mapper.Map<CustomerReadDto>(customerToInsert);

           return result == null ? null : await Task.FromResult(result);

   }
}

EditExistingCustomerHandler

On this handler, we are using the repository to edit the requested and return the Unit object because we don't need to return it.

using AutoMapper;
using MediatR;
using WebApiCustomers.Commands;
using WebApiCustomers.Data;
using WebApiCustomers.Dtos;
using WebApiCustomers.Repositories;

namespace WebApiCustomers.Handlers;
public sealed class EditExistingCustomerHandler : IRequestHandler<EditExistingCustomerCommand, Unit>
{
   private readonly ICustomerRepository _customerRepository;
   private readonly IMapper _mapper;

   public EditExistingCustomerHandler(ICustomerRepository customerRepository,
                                   IMapper mapper )
   {
        _customerRepository = customerRepository;
        _mapper = mapper;
   }
   public async Task<Unit> Handle(EditExistingCustomerCommand request, CancellationToken cancellationToken)
   {
       var customerToUpdate =  _mapper.Map<Customer>(request.customerToUpdate);
       await _customerRepository.UpdateAsync(customerToUpdate);
       return Unit.Value;
   }
}

RemoveExistingCustomerHandler

On this handler, we are using the repository to remove the requested customer and return the Unit object when we don't need to return it.

using AutoMapper;
using MediatR;
using WebApiCustomers.Commands;
using WebApiCustomers.Repositories;

namespace WebApiCustomers.Handlers;

public sealed class RemoveExistingCustomerHandler : IRequestHandler<RemoveExistingCustomerCommand, Unit>
{
   private readonly ICustomerRepository _customerRepository;
   private readonly IMapper _mapper;

   public RemoveExistingCustomerHandler(ICustomerRepository customerRepository,
                                       IMapper mapper)
   {
       _customerRepository = customerRepository;
       _mapper = mapper;
   }
   public async Task<Unit> Handle(RemoveExistingCustomerCommand request, CancellationToken cancellationToken)
   {
           await _customerRepository.DeleteAsync(request.Id);
           await _customerRepository.SaveAsync();

           return Unit.Value;
   }
}

Controller

In the last step, we update the controller class to remove unnecessary injected objects and use the method “Send” from the mediator object.

using AutoMapper;
using MediatR;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using WebApiCustomers.Commands;
using WebApiCustomers.Data;
using WebApiCustomers.Dtos;
using WebApiCustomers.Queries;
using WebApiCustomers.Repositories;

namespace WebApiCustomers.Controllers;

   [Route("api/[controller]")]
   [ApiController]
   public class CustomersController : ControllerBase
   {
       private readonly IMediator _mediator;

       public CustomersController(IMediator mediator)
       {
          _mediator = mediator;

       }

       [HttpGet]
       public async Task<IActionResult> GetAll()
       {

           var result  = await _mediator.Send( new GetAllCustomersQuery());
           return Ok(result);
       }

       [HttpGet("{id:int}")]
       public async Task<IActionResult> Get(int id)
       {

           var result = await _mediator.Send(new GetOneCustomerByIdentifierQuery(id));
           return result == null ? NotFound() : Ok(result);

       }

       [HttpPost]
       public async Task<IActionResult> PostCustomer([FromBody] CustomerCreateDto customerCreateDto)
       {
           var result = await _mediator.Send(
               new CreateNewCustomerCommand(customerCreateDto));

           return CreatedAtAction("Get", new { id = result.Id }, result);
       }

       [HttpPut("{id}")]
       public async Task<IActionResult> UpdateCustomer(int id, [FromBody] CustomerUpdateDto customerUpdateDto)
       {
           if (id != customerUpdateDto.Id) return BadRequest();

           await _mediator.Send(new EditExistingCustomerCommand(customerUpdateDto));

           return NoContent();
       }

       [HttpDelete("{id}")]
       public async Task<IActionResult> DeleteCustomer(int id)
       {
           await _mediator.Send(new RemoveExistingCustomerCommand(id));
           return NoContent();
       }
   }

Recaps

On these topics, we gain new tools to reduce the complexity of big projects and how we can apply different queries and command models.

Secondly, we learned how to write more readable code, reducing the responsibility from the controllers and encapsulating the logic, and creating coupled requests.

In the end, with learned about these topics:

CQRS and Mediator Patterns.
How to separate Queries and Commands Models
How to implement the MediatR Nuget Package.

Source code WebApiCustomers Part 2

If you enjoyed this article, please subscribe and follow this series about building clean web API Net Core 6.

How to Build a WEB API ASP.NET Core 6 (Part 1)

Andrés Díaz — Mon, 05 Sep 2022 19:17:00 +0000

Introduction

This tutorial is Part of the Step by Step Series: How to build a Clean Web API from the basics of ASP.NET Core.

We are starting building a Customer Web API with Net Core 6
using the native dependency injection provided on this framework and creating a repository pattern taking advantage of the entity framework and one of the most used nuget packages, automapper following the Solid Principles.

You may need to research this on the web if you don't know the SOLID principles.

Why should I use this?

Dependency Injection

In short, dependency injection is a design pattern in which an object receives other objects. A form of inversion of control, dependency injection aims to separate the concerns of constructing objects and using them, leading to loosely coupled programs.

Some of the problems that you resolve are these:

Use of an interface or base class to abstract the dependency implementation.
Register the dependency in a service container. ASP.NET Core provides a built-in service container.
Inject the service into the class's constructor where it needs. The framework takes on the responsibility of creating an instance of the dependency and disposing of it when it's no longer needed.

See more details in Dependency Injection

Repository pattern

According to Martin Flower A repository mediates between the domain and data mapping layers, acting like an in-memory domain object collection. Client objects construct query specifications declaratively and submit them to the repository for satisfaction.

See more details in repository pattern.

AutoMappter

Automapper is a simple library that helps us to transform one object type into another. It is a convention-based object-to-object mapper that requires minimal configuration.

What problems will resolve automapper?

One of the common uses is when we have to map one object type to another. It is boring to do it every time we have to do it, so this simple tool makes it for us.

See more details in automapper

HTTP methods

We are defining these HTTP methods in our Customer API project following the standard conventions to create restful services.

Prerequisites

In this case, we are using Visual Studio 2022, Download here
SQL Express Edition or Developer Edition, Download here

Create a web API project

We start Creating a new project

Step 1

From the File menu, select New > Project.
Enter Web API in the search box.
Select the ASP.NET Core Web API template and select Next.
In the Configure your new project dialog, name the project CustomerAPI and select Next.
In the Additional information dialog:
Confirm the Framework is .NET 6.0 (Long-term support).
Confirm the checkbox for Use controllers(uncheck to use minimal APIs) is checked.
Select Create.

Step 2

Step 3

Your solution should look like this:

We remove all unnecessary files WeatherForecastController.cs and WeatherForecast.cs.

In this case, we choose the first option under API called API Controller-Empty.

And then, we create the controller class, CustomersController, inheriting from ControllerBase, and before continuing to define the endpoint, start defining the necessary DTO.

If you are unfamiliar with the Dto class, we recommend reading Create Data Transfer Objects (DTOs) | Microsoft Docs..

But to summarize, what I have to do is create a DTO because we don't want to reveal all our columns specified by internal objects related to our database. We define in our DTO only the properties that I want to expose on the endpoints.

At this point, we are to define one property to reuse similar properties. For this purpose, we only have one property, but in real scenarios, we may need to specify more than one.



namespace WebApiCustomers.Dtos;
public class BaseDto
{
    public int Id { get; set; }
}

The following Dto Classes are CustomerReadDto, CustomerCreateDto, and CustomerUpdateDto; we must create Dto according to requirements.

We have these cases:

CustomerReadDto, used to read Customer Info and return from the Get Methods.
CustomerCreateDto, used in POST Method, for creating customer records.
CustomerUpdateDto, used in Put Method, for updating customer records.



namespace WebApiCustomers.Dtos;
public class CustomerReadDto
{
    public string? FirstName { get; set; }
    public string? LastName { get; set; }
    public DateTime DateOfBirth { get; set; }
    public string? EmailAddress { get; set; }
}



namespace WebApiCustomers.Dtos;
public class CustomerCreateDto
{
    public string? FirstName { get; set; }
    public string? LastName { get; set; }
    public DateTime DateOfBirth { get; set; }
    public string? EmailAddress { get; set; }
}



namespace WebApiCustomers.Dtos;
public class CustomerUpdateDto: BaseDto
{
    public string? FirstName { get; set; }
    public string? LastName { get; set; }
    public DateTime DateOfBirth { get; set; }
    public string? EmailAddress { get; set; }
}

Scaffold Models Class from Existing Database

Because in real scenarios, you will likely work with an existing database. In this case, we are creating a little database "CustomerDemoDb" on SQL Server Object Explorer Tab From Visual Studio.

Step One: Create a CustomerDemoDb database by right-clicking > New Database > CustomerDemoDb and then using New Query and copy-pasting this syntax.



Use CustomerDemoDb

CREATE TABLE [dbo].[Customer]
(
    [Id] INT NOT NULL PRIMARY KEY IDENTITY (1, 1),
    [FirstName] NVARCHAR (150) NULL,
    [LastName] NVARCHAR (150) NULL,
    [EmailAddress] NVARCHAR (150) NULL,
    [DateOfBirth] DATE NULL,
    [CreatedAt] DATE NULL
);

Great! We created the database, and now we have to build our DatabaseDbContext for adding and getting records from this database.

For creating the Database Context, we have to install some Packages:

Microsoft.EntityFrameworkCore.SqlServer

Microsoft.EntityFrameworkCore.Tools

To Accomplish This, Go to > Nuget Package Manager > Browse Type each of them.

The Last One is necessary to execute the command "Scaffold-DbContext" we are using in the next step.

Create Data Folder in your project, and on the same Screen, Go to Package Manage Console which shows it up at the Bottom, and Type this command :

Remember to replace [ServerName] with your Current ServerName.



Scaffold-DbContext "Server=[ServerName];Database=CustomerDemoDb;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -outPutDir Data

On This approach, we create our DbContext using "First Database."

Your Data Folder should look like this.

Go to CustomerDemoDbContext, Copy the ConnectionString and define your connecting string on appsettings.json.



"ConnectionStrings": {

"CustomerDbConext": "Server=[ServerName];Database=CustomerDemoDb;Trusted_Connection=True;"

}

From CustomerDemoDbContext Class, Remove the block inside the OnConfiguring Method because on the next step with defining our connectionstring on File Program.cs on services File on NetCore 5 is Startup.cs.

Add this code after this line of code:

var builder = WebApplication.CreateBuilder(args);

Code to add :



builder.Services.AddDbContext<CustomerDemoDbContext>(options => options.UseSqlServer(builder.Configuration.GetConnectionString("CustomerDbConext")));

Here we are using Dependency Injection for injecting DbContext Service. The Method AddDbContext internally defines the LifeTime of Service AddScope for Injecting our DbContext.

Resuming, we can register services in 3 ways :

Transient, this is created each time on every request.
Scoped, this is created once and reused on the same request.
Singleton, this is created once and is reused across the application lifetime.

If you want more detail about Dependency Injection LifeTime in ASP.NET Core, I recommend reading this article.

Dependency Injection Lifetimes in ASP.NET Core — Code Maze (code-maze.com)

Create Generic Repository for CRUD Operations with Repository Pattern and Entity Framework

On this Topic, We have to create a Repository Class Based on a Design Pattern named Repository Pattern, and one of the common uses is to define all related methods for accessing database records.

The first step is to create Repositories Folder and define IRepository Interface like this:



namespace WebApiCustomers.Repositories;
public interface IRepository<TEntity>
{
    Task<IEnumerable<TEntity>> GetAllAsync();
    Task<TEntity?> GetAsync(int? id);
    Task AddAsync(TEntity entity);
    Task UpdateAsync(TEntity entity);
    Task DeleteAsync(int id);
    Task SaveAsync();
}

In this case, we take advantage of Generic Class TEntity and DbSet Object from DbContext, explained in the next step.

Here we are using DbSet to use any class related to the database context in this way to create Base Repository :



using Microsoft.EntityFrameworkCore;
using WebApiCustomers.Data;
namespace WebApiCustomers.Repositories;
public class BaseRepository<TEntity> : IRepository<TEntity> where TEntity : class
{
    private readonly CustomerDemoDbContext _context;
    private readonly DbSet<TEntity> _dbset;

    public BaseRepository(CustomerDemoDbContext context)
    {
        _context = context;
        _dbset = _context.Set<TEntity>();
    }
    public async Task AddAsync(TEntity entity) => await _dbset.AddAsync(entity);
    public async Task<IEnumerable<TEntity>> GetAllAsync() => await _dbset.ToListAsync();
    public async Task<TEntity?> GetAsync(int? id) => await _dbset.FindAsync(id);

    public async Task DeleteAsync(int id)
    {
        var dataToDelete = await _dbset.FindAsync(id);
        _dbset.Remove(dataToDelete);
    }
    public async Task UpdateAsync(TEntity entity)
    {
        await Task.Run(()=> _dbset.Attach(entity));
        _context.Entry(entity).State = EntityState.Modified;
    }
    public async Task SaveAsync()
    {
        await _context.SaveChangesAsync();
    }
}

Now we have to create the ICustomerRepository because sometimes you have to add additional methods, and you can define them on this interface.



public interface ICustomerRepository: IRepository<Customer>
{
//Define your Additional Signature methods here
}



using Microsoft.EntityFrameworkCore;
using WebApiCustomers.Data;

namespace WebApiCustomers.Repositories;

public class CustomerRepository : BaseRepository<Customer>, ICustomerRepository
{
    private readonly CustomerDemoDbContext _context;
    public CustomerRepository(CustomerDemoDbContext context) : base(context) => _context = context;
}

This Repository Pattern complete their function with one table but in real scenarios maybe you have to work with more entities, now we need to go, to the program and inject our repository in this case CustomerRepository.

To accomplish that, we have to add this code, after the line

builder.Services.AddControllers();

For the Generic Repository

builder.Services.AddTransient(typeof(IRepository<>),typeof(BaseRepository<>));

For the Customer Repository

builder.Services.AddTransient<ICustomerRepository, CustomerRepository>();

Creating Dto and Mapping Dto With Models using AutoMapper Nuget Package.

Why Use Dtos ?, the purpose of using Dtos is to use classes to expose only the fields you need, it is not safer to expose all columns from our table than we created I, classes, with only needed columns.

Firstly install two AutoMapper Nuget Package for Map ours Dto to Entities

· AutoMapper

· AutoMapper.Extensions.Microsoft.DependencyInjection

And then with need to add this line on un program.cs file

builder.Services.AddAutoMapper(Assembly.GetExecutingAssembly());

After this, we must define the profile class, where I can define all mapping that we need it

And then we can start to Add our profile class for all necessary Dependency Injection that we need, like this.



using AutoMapper;
using WebApiCustomers.Data;
using WebApiCustomers.Dtos;
namespace WebApiCustomers.Profiles
{
    public class CustomerProfile : Profile
    {
        public CustomerProfile()
        {
            CreateMap<Customer, CustomerReadDto>();
            CreateMap<CustomerCreateDto, Customer>().
                ForMember(m => m.CreatedAt, o => o.MapFrom(s => DateTime.Now.Date));
        }
    }
}

On the second line, CreateMap specifies a default value for the CreatedAt column, because we are taking de date from the system, not from the user.

Now we go back to the controller and inject two objects ICustomerRepository and IMapper, you constructor class should look like this:



private readonly ICustomerRepository _customerRepository;
private readonly IMapper _mapper;

public CustomersController(ICustomerRepository customerRepository,IMapper mapper)
{
    _customerRepository = customerRepository;
    _mapper = mapper;
}

Creating HTTP methods for CRUD Operations

Now are need to defined each HTTP method defined on the previous table

Get /api/customers

Here we are to define the action for a get method /api/customers and we have to return array of customers like this:



[HttpGet]
public async Task<IActionResult> GetAll()
{
    var listCustomers = await _customerRepository.GetAllAsync();
    var result = _mapper.Map<List<CustomerReadDto>>(listCustomers);
    return Ok(result);

}

We have three lines of code :

List of customers :



var listCustomers = await _customerRepository.GetAllAsync();

Mapping list of Customers to CustomerReadDto :



var result = _mapper.Map<List<CustomerReadDto>>(listCustomers);

Return Response:



return Ok(result);

Get /api/customers/{id}

Here we are to define the action for a get method /api/customers/{id} and we have to return a CustomerReadDto object on, here we don't have to explain the following methods because are too similar :




[HttpGet]
public async Task<IActionResult> Get(int id)
{
    var customerItem = await _customerRepository.GetAsync(id);
    var result = _mapper.Map<CustomerReadDto>(customerItem);
    return Ok(result);
}

POST /api/customers

Here we are to define the action for a POST method /api/customers like this;



[HttpPost]
public async Task<IActionResult> PostCustomer([FromBody]CustomerCreateDto customerCreateDto)
{
    var customerToInsert = _mapper.Map<Customer>(customerCreateDto);
    await _customerRepository.AddAsync(customerToInsert);
    await _customerRepository.SaveAsync();
    return CreatedAtAction("Get",
    new { id = customerToInsert.Id }, customerToInsert);
}

PUT /api/customers/{id}

Here we are to define the action for a PUT method /api/customers/{id} like this;



[HttpPut("{id}")]
public async Task<IActionResult> UpdateCustomer(int id, [FromBody] CustomerUpdateDto customerUpdateDto)
{
    if (id != customerUpdateDto.Id) return BadRequest();
    var customerToUpdate = _mapper.Map<Customer>.(customerUpdateDto);
    await _customerRepository.UpdateAsync(customerToUpdate);
    await _customerRepository.SaveAsync();
    return NoContent();
}

Delete /api/customers/{id}

Here we are to define the action for a Delete method /api/customers/{id} like this;



[HttpDelete("{id}")]
public async Task<IActionResult> DeleteCustomer(int id)
{
    await _customerRepository.DeleteAsync(id);
    await _customerRepository.SaveAsync();
    return NoContent();
}

Swagger

This tool enables development across the entire API lifecycle, from design and documentation to testing and deployment.

Swagger is integrated to the project in a easy way in our services by default is enabled in our project.

If you defined the project following all steps, you could use the swagger page to test all your HTTP methods:

Conclusion

We learned about these topics.

Dependency Injection
Repository Pattern
AutoMapper
Create a web API project
Create Generic Repository for CRUD Operations

Source code WebApiCustomers

If you enjoyed this article, please subscribe and follow this series about Building clean web API Net Core 6.