Automapper In .NET Core

Introduction 

 

In this article, I will try to explain how to use AutoMapper in our .NET Core applications.

 

I will cover this topic in the following steps:

1. Introduction
2. Installation
3. Registration
4. Model Creation & Mapping
5. Reverse Mapping
6. Complex Object Mapping
7. Summary

AutoMapper is simple a dependency injection that is used to map one object type to another object type.

 

As you know, before Automapper, when we would map the view model object to the domain model object, then we would manually do for each property. This is not only time consuming, but also error-prone. However, Automapper solves this problem of mapping the source object of the destination object or from the destination object to thesource object.

 

Installation

 

There are two ways to install Automapper in our application

 

Using NuGet Package Manager

 

This is the package that needs to be installed:

 

Install-Package AutoMapper.Extensions.Microsoft.DependencyInjection

 

Using the Visual studio search option.

 

I am using option two, the Visual studio search option.

 

Please see the attached image:

 

 

After installing this package, you will be able to see this library in your solution package:

 

 

Registration

 

When this NuGet package is installed in your application, the next step is to register the service in ConfigureServices under the startup.cs class.

 

Note

This namespace is required in your startup.cs file:

 

using AutoMapper;

 

Just like this:

// 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();
}

Now we have completed the installation and registration.

 

The next step is to see how to create a model and its mapping using Automapper.

 

Model Creation & Mapping

 

Suppose we have domain model and its ViewModel, as shown below:

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;
    }
}

Let say the view model is like this, which we can use on UI:

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

We have created both the domain model and viewmodel.

 

The next step is to create a custom file and inherit it with Profile class provided by AutoMapper.

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

Now create your controller and map it using Automapper here:

[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, it is possible that both the object property names are different.

 

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

 

Let's take the same example, but 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 firstName 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 seen have mapping from the domain model to the view model, but what about mapping from the view model to the domain model?

 

Actually Automapper  provide 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 use 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 dome 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 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!