Auto Mapper and Fluent Validation

Ankush Verma

5y2.6kLearn iOS Programming

Hello everyone Please let me know what is Auto Mapper and Fluent Validation in .net core and How to use this Thanks

3 Replies

Know the answer? Post it — somebody with the same question will find it here.

Rijwan Ansari5y ago
Accepted answer
Hi,

Auto Mapper
- We use this package for Model conversion. Normally, for example, we convert ViewModel to Database Model, vice versa, Dto to DB Models likewise.
- Simply, the code that mapped of one object to another.
- Instead of doing manual mapping, we can use this library to do it aumatically based on properties and save huge time for developers.

Why use AutoMapper?
Mapping code is boring. Testing mapping code is even more boring. AutoMapper provides simple configuration of types, as well as simple testing of mappings. The real question may be “why use object-object mapping?” Mapping can occur in many places in an application, but mostly in the boundaries between layers, such as between the UI/Domain layers, or Service/Domain layers. Concerns of one layer often conflict with concerns in another, so object-object mapping leads to segregated models, where concerns for each layer can affect only types in that layer.

Real case example with code:
https://www.c-sharpcorner.com/article/using-automapper-in-mvc-project/

Fluent validation
This another package for developers to validate models. This another library that helps developer to validate model in backend.
A popular .NET library for building strongly-typed validation rules.
There are several built-in validators and also can develop custom validatiors.

How to implement:
https://docs.fluentvalidation.net/en/latest/aspnet.html
Example:
public class Person {
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public int Age { get; set; }
}

public class PersonValidator : AbstractValidator {
    public PersonValidator() {
        RuleFor(x => x.Id).NotNull();
        RuleFor(x => x.Name).Length(0, 10);
        RuleFor(x => x.Email).EmailAddress();
        RuleFor(x => x.Age).InclusiveBetween(18, 60);
    }
}
+3
Daril4y ago
Automaper helps us solve the problem of having to write heavy mapping codes between objects it is an object-object mapper which allows you to solve the problem of manually mapping each property of a class with the same properties of another class
Fluent validation is a validation library which is seperated from the business logic that uses a fluent interface and lambda expressions for building strongly-typed validation rules.
+1
Sachin Singh5y ago
Automapper is used to map one data from one type to another. This involves the following three steps
step 1. Install automapper from NuGet
Install-Package AutoMapper.Extensions.Microsoft.DependencyInjection
public void ConfigureServices(IServiceCollection services)
{

    services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
}
step 2.
Create profile
using AutoMapper;

namespace automapper_sample
{
    public class AutoMapperProfile : Profile
    {
        public AutoMapperProfile()
        {
            CreateMap();
        }
    }
}
step 3. Use it
public class EmployeeController : Controller
    {
        private readonly IMapper _mapper;

        public EmployeeController (IMapper mapper)
        {
            _mapper = mapper;
        }

        // GET: api/
        [HttpGet]
        public Employee Get()
        {
            Employee emp= new Employee ()
            {
                Name = "Sachin",
                Age = 25,

            };

            return _mapper.Map(emp);
        }
    }
Fluent validation
we use fluent API to write all validation logic in one place and to separate the validation part from domain Entities.
protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        //Write Fluent API configurations here
           //ex shown below
                    modelBuilder.Entity()
                                .Property(x => x.Name)
                                .IsRequired();
                    base.OnModelCreating(modelBuilder);

     }
+2