What is AutoMapper in ASP.NET Core and its Usage?

AutoMapper in .NET Core

Using object-to-object mappings in your ASP.NET application is a process that many times proves to be difficult. This is where AutoMapper can be helpful as it simplifies this process while reducing boilerplate code.

Let's get to know what AutoMapper is with this ASP.NET Tutorial, how it is used, and why it is so essential in the .NET Core ecosystem. Learn more about other core concepts related to ASP.NET in detail through our ASP.NET Certification Training.

What is AutoMapper?

How to Use AutoMapper in Our Application?

Using AutoMapper in your ASP.NET Core Application is pretty easy. Let’s get to know the steps involved.

1. Installation

In the beginning, you need to install the NuGet package called AutoMapper. This can either be done by the package manager in the visual studio or through running the given command in the package manager console:

Install-Package AutoMapper

2. Configuration

public void ConfigureServices(IServiceCollection services)
{
    // Auto Mapper Configurations
    var mapperConfig = new MapperConfiguration(mc =>
    {
        mc.AddProfile(new MappingProfile());
    });

    IMapper mapper = mapperConfig.CreateMapper();
    services.AddSingleton(mapper);
    services.AddMvc();
}

3. Usage

public class Source
{
    public int Value { get; set; }
}

public class Destination
{
    public int Value { get; set; }
}

public class MyService
{
    private readonly IMapper _mapper;

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

    public Destination GetMappedObject(Source source)
    {
        return _mapper.Map<Destination>(source);
    }
}

4. Profiles

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<Source, Destination>();
    }
}

5. Use AutoMapper in Your Services or Controllers:

public class MyController : ControllerBase
{
    private readonly IMapper _mapper;

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

    public IActionResult Get()
    {
        var source = new Source();
        var destination = _mapper.Map<Destination>(source);
        return Ok(destination);
    }
}

Creating Rules for Mapping Properties With Different Names

CreateMap<Source, Destination>()
    .ForMember(dest => dest.DifferentName, opt => opt.MapFrom(src => src.OriginalName));
/pre>

Reverse Mapping

CreateMap<Source, Destination>().ReverseMap();

Why Do We Need AutoMapper in .NET Core?

• Reduces Boilerplate Code- AutoMapper reduces the amount of code needed to map properties between objects.
• Enhances Maintainability- With centralized mapping configurations, maintaining and updating mappings becomes easier.
• Improves Code Readability- AutoMapper makes the code cleaner and more readable by abstracting the mapping logic.

Usage Guidelines and Best Practices

• Use Profiles- Organize your mappings into profiles for better maintainability.
• Avoid Complex Mappings- Keep your mappings simple. For complex scenarios, consider using custom resolvers.
• Test Your Mappings- Ensure you write unit tests for your mappings to avoid runtime issues.
• Stay Updated- Keep your AutoMapper package up to date to benefit from the latest features and fixes.

Conclusion

Take our Aspnet skill challenge to evaluate yourself!

In less than 5 minutes, with our skill challenge, you can identify your knowledge gaps and strengths in a given skill.

GET FREE CHALLENGE