AutoMapper em C# (Como funciona para desenvolvedores)

Principais funcionalidades do AutoMapper

• Simplificação do código: O AutoMapper reduz drasticamente a necessidade de código manual, automatizando o mapeamento de propriedades, evitando erros e economizando tempo.
• Flexibilidade nas configurações de mapeamento: O AutoMapper permite a personalização detalhada das configurações de mapeamento, atendendo a uma ampla gama de cenários de mapeamento.
• Eficiência de desempenho: A biblioteca foi projetada para lidar com modelos de objetos grandes e complexos sem sobrecarga de desempenho significativa.

Instalação via Console do Gerenciador de Pacotes

Você pode instalar facilmente o AutoMapper em seu projeto executando um comando simples no console do gerenciador de pacotes:

Install-Package AutoMapper

Configuração básica de mapeamento

O passo fundamental para usar o AutoMapper é definir a configuração de mapeamento. Isso envolve especificar como as propriedades do objeto de entrada (origem) devem ser transferidas para o objeto de saída (destino).

var config = new MapperConfiguration(cfg => 
{
    cfg.CreateMap<SourceClass, DestinationClass>();
});
IMapper mapper = config.CreateMapper();

var config = new MapperConfiguration(cfg => 
{
    cfg.CreateMap<SourceClass, DestinationClass>();
});
IMapper mapper = config.CreateMapper();

Dim config = New MapperConfiguration(Sub(cfg)
	cfg.CreateMap(Of SourceClass, DestinationClass)()
End Sub)
Dim mapper As IMapper = config.CreateMapper()

• No exemplo acima, uma configuração de mapeamento é criada para mapear propriedades de SourceClass para DestinationClass.
• Uma instância de IMapper é então criada usando esta configuração.

Aplanamento de Modelos de Objetos Complexos

Um dos pontos fortes do AutoMapper é sua capacidade de simplificar modelos de objetos complexos. Essa funcionalidade é particularmente útil ao lidar com objetos aninhados, permitindo o mapeamento dessas propriedades aninhadas para uma estrutura de classe de destino plana.

Manipulação versátil de tipos de objetos

O AutoMapper consegue mapear com eficiência diversos tipos de objetos, incluindo objetos de domínio do usuário, DTOs e até mesmo view models, oferecendo uma solução versátil para diferentes necessidades de transferência de dados.

Exemplo 1: Mapeamento Simples

Considere um cenário em que precisamos mapear propriedades de uma entidade de usuário para um DTO de usuário:

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Address { get; set; }
    public string City { get; set; }
}

public class UserDTO
{
    public string FullName { get; set; }
    public string Address { get; set; }
    public string City { get; set; }
}

// Mapping Configuration
var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<User, UserDTO>()
       .ForMember(dest => dest.FullName, opt => opt.MapFrom(src => src.FirstName + " " + src.LastName));
});
IMapper mapper = config.CreateMapper();
User user = new User { FirstName = "John", LastName = "Doe", Address = "123 Street", City = "CityName" };
UserDTO userDto = mapper.Map<UserDTO>(user);

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Address { get; set; }
    public string City { get; set; }
}

public class UserDTO
{
    public string FullName { get; set; }
    public string Address { get; set; }
    public string City { get; set; }
}

// Mapping Configuration
var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<User, UserDTO>()
       .ForMember(dest => dest.FullName, opt => opt.MapFrom(src => src.FirstName + " " + src.LastName));
});
IMapper mapper = config.CreateMapper();
User user = new User { FirstName = "John", LastName = "Doe", Address = "123 Street", City = "CityName" };
UserDTO userDto = mapper.Map<UserDTO>(user);

Public Class User
	Public Property FirstName() As String
	Public Property LastName() As String
	Public Property Address() As String
	Public Property City() As String
End Class

Public Class UserDTO
	Public Property FullName() As String
	Public Property Address() As String
	Public Property City() As String
End Class

' Mapping Configuration
Private config = New MapperConfiguration(Sub(cfg)
	cfg.CreateMap(Of User, UserDTO)().ForMember(Function(dest) dest.FullName, Function(opt) opt.MapFrom(Function(src) src.FirstName & " " & src.LastName))
End Sub)
Private mapper As IMapper = config.CreateMapper()
Private user As New User With {
	.FirstName = "John",
	.LastName = "Doe",
	.Address = "123 Street",
	.City = "CityName"
}
Private userDto As UserDTO = mapper.Map(Of UserDTO)(user)

• Este exemplo mostra o mapeamento entre User e UserDTO onde o FullName em UserDTO é uma concatenação de FirstName e LastName de User.

Exemplo 2: Mapeamento avançado com objetos complexos

Em um cenário mais complexo, vamos mapear um objeto de pedido com detalhes de usuário aninhados para um DTO de pedido simplificado:

public class Order
{
    public User OrderedBy { get; set; }
    // Other properties...
}

public class OrderDTO
{
    public string FullName { get; set; }
    // Other properties...
}

// Mapping Configuration
var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Order, OrderDTO>()
       .ForMember(dest => dest.FullName, opt => opt.MapFrom(src => src.OrderedBy.FirstName + " " + src.OrderedBy.LastName));
});
IMapper mapper = config.CreateMapper();
Order order = new Order { OrderedBy = new User { FirstName = "Jane", LastName = "Doe" } };
OrderDTO orderDto = mapper.Map<OrderDTO>(order);

public class Order
{
    public User OrderedBy { get; set; }
    // Other properties...
}

public class OrderDTO
{
    public string FullName { get; set; }
    // Other properties...
}

// Mapping Configuration
var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Order, OrderDTO>()
       .ForMember(dest => dest.FullName, opt => opt.MapFrom(src => src.OrderedBy.FirstName + " " + src.OrderedBy.LastName));
});
IMapper mapper = config.CreateMapper();
Order order = new Order { OrderedBy = new User { FirstName = "Jane", LastName = "Doe" } };
OrderDTO orderDto = mapper.Map<OrderDTO>(order);

Public Class Order
	Public Property OrderedBy() As User
	' Other properties...
End Class

Public Class OrderDTO
	Public Property FullName() As String
	' Other properties...
End Class

' Mapping Configuration
Private config = New MapperConfiguration(Sub(cfg)
	cfg.CreateMap(Of Order, OrderDTO)().ForMember(Function(dest) dest.FullName, Function(opt) opt.MapFrom(Function(src) src.OrderedBy.FirstName & " " & src.OrderedBy.LastName))
End Sub)
Private mapper As IMapper = config.CreateMapper()
Private order As New Order With {
	.OrderedBy = New User With {
		.FirstName = "Jane",
		.LastName = "Doe"
	}
}
Private orderDto As OrderDTO = mapper.Map(Of OrderDTO)(order)

• Este exemplo demonstra o mapeamento de um objeto Order, contendo detalhes aninhados OrderedBy, para uma propriedade plana OrderDTO, extraindo e combinando nomes de usuário em uma única propriedade FullName.

Com a versão 9.0, o AutoMapper passou de uma API estática (Mapper.Initialize) para uma API baseada em instâncias. Essa mudança aumenta a flexibilidade e é mais adequada para aplicações modernas, especialmente aquelas que utilizam injeção de dependência. Se você estiver trabalhando com versões anteriores à 9.0, a abordagem de API estática é aplicável. No entanto, para versões mais recentes, recomenda-se adotar a API baseada em instâncias, conforme descrito nos exemplos acima.

Componentes principais do pacote de Iron Software

1. IronPDF para gerenciamento de PDFs : Este componente permite que desenvolvedores criem, leiam, editem e assinem PDFs. Oferece também a capacidade de converter HTML em PDF, um recurso que pode ser particularmente útil na geração de relatórios ou documentação a partir de dados da web.

   

2. Manipulação de arquivos Excel com o IronXL : O IronXL facilita o trabalho com arquivos Excel sem a necessidade do Office Interop, simplificando as tarefas de manipulação e análise de dados.

   

3. IronOCR para Extração de Texto : Permite a extração de texto de imagens, suportando uma ampla gama de 125 idiomas, o que o torna altamente versátil para projetos internacionais.

   

4. IronBarcode para suporte a QR e código de barras : Uma biblioteca que permite a leitura e gravação de códigos QR e códigos de barras, aprimorando os recursos de gerenciamento de estoque, rastreamento e outras tarefas relacionadas.

Complementaridade com o AutoMapper

Embora o Automapper se destaque no mapeamento de propriedades entre diferentes modelos de objetos em C#, as bibliotecas da Iron Software ampliam a funcionalidade, oferecendo ferramentas para lidar com diversos formatos e tipos de dados. Por exemplo, após usar o AutoMapper para transformar um objeto de domínio do usuário em um DTO, o IronPDF pode ser usado para gerar um relatório completo em formato PDF. Da mesma forma, os dados extraídos ou transformados usando o AutoMapper podem ser posteriormente manipulados ou analisados ​​usando o IronXL para operações com arquivos do Excel.