Introdução

O AutoMapper é uma biblioteca utilizada para mapear objetos. Ele ajuda a resolver esse problema ao automatizar o mapeamento entre diferentes objetos de diferentes camadas, como entre entidades de bancos de dados e objetos de transferências de dados (DTOs). Isso facilita o desenvolvimento ao reduzir a quantidade de código manual para conversões, promovendo um maior desacoplamento e flexibiliade do projeto.

O problema que o AutoMapper resolve

Imagine que você tem uma aplicação que têm muitas entidades e DTOs parecidos, como por exemplo Product. Você precisará mapear manualmente dezenas ou centenas de classes e DTO, e fazer isso

Exemplo didático do problema

Baixe o automapper:

Install-Package AutoMapper.Extensions.Microsoft.DependencyInjection

Vamos retomar o exemplo do Product, descrito acima.

Imagine que você tem um Model de Product:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

E um DTO que representa o que você quer enviar ao cliente sem o ID:

public class ProductDTO
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}

O problema é: toda vez que você quiser converter de Product -> ProductDTO, você teria que escrever:

var productDTO = new ProductDTO
{
    Name = product.Name,
    Price = product.Price
};

e quando for o contrário (DTO → Entidade)

var product = new Product
{
    Name = productDTO.Name,
    Price = productDTO.Price
};

Essa prática em projetos de pequeno porte pode ser eficiente, mas em projetos grandes significa:

• Muito código repetitivo
• Alta chance de erro (esquecer um campo, errar um nome, etc.).
• Difícil manutenção (se mudar o nome de uma propriedade, você precisará alterar em todos os lugares)

O papel do automapper é automatizar essa conversão. Ele faz um mapeamento de propriedades entre objetos de tipos diferentes, desde que o nomes e tipos sejam compatíveis.

1. Primeiro você cria uma configuração de mapeamento (Profile)

using AutoMapper;

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<Product, ProductDTO>(); // diz como mapear de Product → ProductDTO
    }
}

1. Depois registra essa configuração no seu projeto (normalmente no Program.cs ou em arquivo de configurações como método de extensão)

using AutoMapper;

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<Product, ProductDTO>(); // diz como mapear de Product → ProductDTO
    }
}

1. E finalmente, em qualquer lugar do código, você pode converter objetos facilmente:

// injeta a dependência no seu código:
private readonly IMapper _autoMapper;

var productDTO = _mapper.Map<ProductDTO>(product);

Desse modo o AutoMapper automatica copia as propriedades Name, Price sem você precisar escrever nada disso manualmente.

Registrar serviços do AutoMapper

O registro do automapper pode ser feito de diferentes maneiras, e dependem da estrutura e do tamanho do projeto.

Ele deve ser feito uma única vez no ponto central da aplicação, onde o container de injeção de dependência deve ser configurado

Dependendo da arquitetura, isso pode ficar em lugares diferentes:

• Program.cs (projetos .NET 6+)
• Startup.cs (projetos .NET 5 ou anteriores)
• um método de extensão (boa prática para Clean Architecture)

Projeto simples sem camadas

Nos projetos mais simples, geralmente configuramos no Program.cs do projeto:

using AutoMapper;
using MyApp.Mappings; // pasta onde ficam seus Profiles

var builder = WebApplication.CreateBuilder(args);

// Registro do AutoMapper
builder.Services.AddAutoMapper(typeof(MappingProfile));

var app = builder.Build();

app.Run();

Projeto com Clean Architecture

Esse é o cenário mais comuns em projetos profisisonais. A ideia é criar um método de extensão para centralizar os registros dessa camada:

using Microsoft.Extensions.DependencyInjection;
using System.Reflection;

namespace MyApp.Application
{
    public static class DependencyInjection
    {
        public static IServiceCollection AddApplication(this IServiceCollection services)
        {
            services.AddAutoMapper(Assembly.GetExecutingAssembly());
            return services;
        }
    }
}

Quando usar vs. Quando não usar

É importante entender o contexto de arquitetura e escalabilidade do projeto antes de decidir utilizar o AutoMapper.

Alternativas modernas ao AutoMapper

Mapster: mais rápido e com menos configuração.

Manual mapping + extensions: simples e explícito, ideal para APIs pequenas:

public static UserDto ToDto(this User user) =>
    new UserDto(user.Id, user.Name, user.Email)