ASP.NET Tutorial: .NET Object Mapping using AutoMapper

Object mapping is a common task faced by developers in software development. It involves mapping objects between different layers of an application and can be a time-consuming and complex process, especially in large-scale applications. However, there are tools available to make this task simpler, and AutoMapper is one such tool. AutoMapper is a widely-used object-object mapper for .NET applications that eliminates the need for writing repetitive and tedious mapping code. This allows developers to devote more time to critical aspects of their projects.

What exactly is AutoMapper?

AutoMapper is an open-source.NET framework that assists developers in automating object mapping. It allows for the simple movement of data between application levels, such as from database entities to DTOs (Data movement Objects) or vice versa, without the need for manual mapping code. Developers can use AutoMapper to set mapping rules once and let the library handle the rest.
How to Begin using AutoMapper

To get started with AutoMapper in your.NET project, first install the AutoMapper NuGet package. You can do this in the Package Manager Console by using the following command.

Install-Package AutoMapper

Once installed, you may define how objects should be mapped by creating mapping profiles. A mapping profile is a collection of rules that AutoMapper use to accomplish mapping. Here is an example of how to make a mapping profile.

using AutoMapper;

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<SourceClass, DestinationClass>();
    }
}

In this example, SourceClass objects will be automatically mapped to DestinationClass objects based on their property names and types.

Object Mapping Made Simple

One of AutoMapper’s key features is its ability to simplify difficult mappings. Consider the case of nested objects or objects with different property names. You can easily address these situations with AutoMapper. As an example.

public class Source
{
    public int Id { get; set; }
    public NestedSource Nested { get; set; }
}

public class NestedSource
{
    public string Name { get; set; }
}

public class Destination
{
    public int Id { get; set; }
    public string NestedName { get; set; }
}

// Define mapping profiles
public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<Source, Destination>()
            .ForMember(dest => dest.NestedName, opt => opt.MapFrom(src => src.Nested.Name));
    }
}

In this example, the source object’s Nested.Name property is mapped to the destination object’s NestedName property. AutoMapper supports custom mappings via the ForMember function, making it simple to handle complex cases.

Collections Administration

AutoMapper also makes collection mapping easier. AutoMapper can handle a list of items as well as nested collections with ease. Consider the following scenario.

public class Source
{
    public List<int> Numbers { get; set; }
}

public class Destination
{
    public string Numbers { get; set; }
}

// Define mapping profiles
public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<Source, Destination>()
            .ForMember(dest => dest.Numbers, opt => opt.MapFrom(src => string.Join(", ", src.Numbers)));
    }
}