Automapper In .NET Core

using AutoMapper;

// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services) {
    services.AddAutoMapper(typeof(Startup));
    services.AddControllers();
}

public class Employee {
    public int Id {
        get;
        set;
    }
    public string FirstName {
        get;
        set;
    }
    public string LastName {
        get;
        set;
    }
    public string Email {
        get;
        set;
    }
    public string Address {
        get;
        set;
    }
}

public class EmployeeViewModel
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
}

/// <summary>
/// AutoMapperProfile: Use to map domain object ot View model and reverse map
/// </summary>
public class AutoMapperProfile : Profile
{
    public AutoMapperProfile()
    {
        CreateMap<Employee, EmployeeViewModel>();
    }
}

[Route("api/[controller]")]
[ApiController]
public class AutoMapperTestController : ControllerBase 
{
    private readonly IMapper _mapper;
    public AutoMapperTestController(IMapper mapper) 
    {
        _mapper = mapper;
    }
    // GET: api/AutoMapperTest
    [HttpGet]
    public IEnumerable<EmployeeViewModel> Get() 
    {
        var empList = new List<Employee>() 
        {
            new Employee { Id = 1, FirstName = "F1", LastName = "L1", Email = "[email protected]" },
            new Employee { Id = 2, FirstName = "F2", LastName = "L2", Email = "[email protected]" },
            new Employee { Id = 1, FirstName = "F3", LastName = "L3", Email = "[email protected]" }
        };
        var employeeViewModel = _mapper.Map<List<EmployeeViewModel>>(empList);
        return employeeViewModel;
    }
}

Now the obvious question comes to mind, which is what happens when the View model property is different from the domain model.

The answer is yes, but the object property names may be different.

In this case, we need to map in the mapping profile using this.

Let's take the same example, but the ViewModel property is different.

public class EmployeeViewModel 
{
    public string FName { get; set; }
    public string LName { get; set; }
    public string Email { get; set; }
}

Here in this view model, I have changed only the first name and the Last name. These properties need to be mapped explicitly and there's no need to map for email.

public AutoMapperProfile() 
{
    CreateMap<Employee, EmployeeViewModel>()
        .ForMember(dest => dest.FName, opt => opt.MapFrom(src => src.FirstName))
        .ForMember(dest => dest.LName, opt => opt.MapFrom(src => src.LastName));
}

Once we change this, then let's run our application again. We will see the result below, as expected.

[
    {"fName":"F1","lName":"L1","email":"[email protected]"},
    {"fName":"F2","lName":"L2","email":"[email protected]"},
    {"fName":"F3","lName":"L3","email":"[email protected]"}
]

Reverse Mapping

We have seen mapping from the domain model to the view model, but what about mapping from the view model to the domain model?

Automapper provides the inbuilt method ReverseMap.

// Summary:
// Create a type mapping from the destination to the source type, with validation
// disabled. This allows for two-way mapping.
//
// Returns:
// Itself
IMappingExpression<TDestination, TSource> ReverseMap();

This method will be used for reverse mapping in your mapping profile class.

public AutoMapperProfile()
{
    CreateMap<Employee, EmployeeViewModel>()
        .ForMember(dest => dest.FName, opt => opt.MapFrom(src => src.FirstName))
        .ForMember(dest => dest.LName, opt => opt.MapFrom(src => src.LastName))
        .ReverseMap();
}

In code, when you need to map it, use the method shown below.

var mappedUser = _mapper.Map<Employee>(employeeViewModel);

Complex object mapping

We have seen that we are using a simple object, but in a real scenario, we will be using an object inside an object.

In the employee model, we may have its address. The address is a separate class.

public class AddressViewModel
{
    public string AddressLine1 { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string Country { get; set; }
}

Address Model class

public class Address
{
    public string AddressLine1 { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string Country { get; set; }
}

And our Employee Class is like this

public class Employee
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
    public Address Address { get; set; }
}

The Employee View Model class is like this.

public class EmployeeViewModel
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
    public AddressViewModel Address { get; set; }
}

Now our profile class will be like this.

public AutoMapperProfile()
{
    //CreateMap<Employee, EmployeeViewModel>();
    CreateMap<Employee, EmployeeViewModel>()
        .ForMember(dest => dest.FName, opt => opt.MapFrom(src => src.FirstName))
        .ForMember(dest => dest.LName, opt => opt.MapFrom(src => src.LastName))
        .ReverseMap();
    CreateMap<AddressViewModel, Address>().ReverseMap();
}

Now we have done the part of complex mapping as well.

Let's run the application and see the behavior.

[
    {
        "fName": "F1",
        "lName": "L1",
        "email": "[email protected]",
        "address": {
            "addressLine1": "add1",
            "city": "LKO",
            "state": "UP",
            "country": "India"
        }
    },
    {
        "fName": "F2",
        "lName": "L2",
        "email": "[email protected]",
        "address": null
    },
    {
        "fName": "F3",
        "lName": "L3",
        "email": "[email protected]",
        "address": {
            "addressLine1": "add3",
            "city": "Delhi",
            "state": "Delhi",
            "country": "India"
        }
    }
]

We got the expected result!

Summary

There are so many features available in Automapper that it is impossible to cover them all in the same article.

If you wish to learn more about Automapper, please visit AutoMapperDoc.

Here in this article, we have learned

• What is Automapper?
• How to install and use.
• How to do reverse mapping.
• How to do mapping for a completed object.

If you have any issues, please download the attached code and run it.

I hope this will help you to handle this concept in .NET Core.

Thank you for taking your valuable time to read the full article!