How to Map Object-to-Object using Automapper in .NET Core


Mapping objects between different types is a common task in software development. Whether working with data transfer objects (DTOs), view models, or entities in your .NET Core application, we often need to convert one type of object to another. Manually writing mapping code can be time-consuming and error-prone. This is where AutoMapper comes to the rescue. AutoMapper is a popular open-source library that simplifies the object-to-object mapping process in .NET Core.

What is Automapper?

Automapper is an open-source library for .NET that provides an easy way to perform object-to-object mapping. It eliminates the need for manual mapping code, reduces boilerplate code, and enhances productivity. Automapper helps developers write cleaner, more maintainable code by abstracting away the repetitive mapping logic.

Key Benefits of Automapper

  1. Simplifies Mapping: Automapper simplifies mapping by automatically matching properties between source and destination objects. It eliminates the need for manual property assignment, reducing the code you need to write.
  2. Convention-based Mapping: Automapper follows a convention-based approach, where properties with the same name and type are automatically mapped. This convention can be customized and overridden when needed.
  3. Supports Complex Mappings: Automapper can handle complex object graphs and nested properties, reducing the complexity of mapping operations. It handles the mapping of nested objects and collections automatically, saving developers from writing tedious recursive mapping code.
  4. Supports Projection: Automapper supports the projection of objects into custom types. It allows you to define custom mappings using LINQ expressions, enabling you to shape the output based on specific requirements.

Getting Started with Automapper in .NET Core

To demonstrate the usage of Automapper in a .NET Core application, let's consider a simple scenario where we have a Person class and a PersonDto class, and we want to map properties from the Person object to the PersonDto object.

Step 1. Install Automapper

To install AutoMapper in .NET Core, you can follow different approaches depending on your project setup and preferences. Here are three common ways to install AutoMapper.

  1. Using NuGet Package Manager Console.

    • Open Visual Studio.
    • From the menu, go to "View" -> "Other Windows" -> "Package Manager Console." This will open the NuGet Package Manager Console at the bottom of the screen.
    • In the Package Manager Console, make sure the correct project is selected from the "Default project" dropdown at the top.
    • To install AutoMapper, use the following command: Install-Package AutoMapper Press Enter to execute the command.
    • NuGet will download and install the AutoMapper package and its dependencies into your project.
    • Once the installation is complete, you can use AutoMapper in your .NET Core project.
  2. Using NuGet Package Manager.

    • Open Visual Studio.
    • Right-click on your project in Solution Explorer.
    • Select "Manage NuGet Packages."
    • In the "Browse" tab, search for "AutoMapper."
    • Select the AutoMapper package and click on the "Install" button.
    • Wait for the installation, and the package will be added to your project.
  3. I was manually editing the project file.

    • Open your project folder in a text editor or Visual Studio Code.
    • Locate the .csproj file of your project.
    • Open the .csproj file and add the following line within the <ItemGroup> element:
      <PackageReference Include="AutoMapper" Version="x.x.x" />
    • Replace x.x.x with the desired version of AutoMapper.
    • Save the .csproj file.
    • Restore the packages by running dotnet restore the command in the terminal or reloading the project in Visual Studio.

After installing AutoMapper using any of these methods, you can start using it in your .NET Core project by adding the necessary statements and configuring the mappings.

Step 2. Define Source and Destination Classes

Let's define the Person and PersonDto classes as follows:

public class Person
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }

public class PersonDto
    public string FullName { get; set; }
    public int Age { get; set; }

Step 3. Configure Automapper

In your application startup code (e.g., Startup.cs), you must configure Automapper by creating a mapping configuration. Add the following code to the ConfigureServices method.

using AutoMapper;

public void ConfigureServices(IServiceCollection services)
    // Other configurations...

    var mappingConfig = new MapperConfiguration(mc =>
        mc.CreateMap<Person, PersonDto>()
            .ForMember(dest => dest.FullName, opt => opt.MapFrom(src => $"{src.FirstName} {src.LastName}"));

    IMapper mapper = mappingConfig.CreateMapper();

    // Other configurations...

In the mapping configuration, we create a mapping from Person to PersonDto. We also define a custom mapping for the FullName property using the ForMember method.

Step 4. Perform Object Mapping

Once the configuration is set up, you can inject the IMapper interface into your classes and use it to perform object mapping. Here's an example of how to use Automapper in a controller.

using AutoMapper;

public class PersonController : ControllerBase
    private readonly IMapper _mapper;

    public PersonController(IMapper mapper)
        _mapper = mapper;

    public ActionResult<PersonDto> CreatePerson(Person person)
        var personDto = _mapper.Map<PersonDto>(person);
        // Use the mapped personDto object as needed
        return Ok(personDto);

In the above example, we inject the IMapper interface into the PersonController class and map the Person object to a PersonDto object in the CreatePerson action.


Automapper is a powerful and flexible library that greatly simplifies the object-to-object mapping process in .NET Core applications. Automating the mapping process reduces boilerplate code and improves productivity. With its convention-based mapping and support for complex mappings, Automapper provides an elegant solution for handling object mapping scenarios. By following the steps outlined in this article, you can quickly integrate Automapper into your .NET Core applications and simplify your object mapping needs.

Similar Articles