Esqueça o AutoMapper, use Mapperly!

Não, não estou doido! De fato o AutoMapper é um ótimo recurso que vai te poupar intermináveis linhas de código na hora de transportar seus dados entre objetos.

Mas ele tem um problema, terrível; a reflexão.

Imagine gerar um relatório gerencial (com algumas centenas de linhas e milhares de dados) usando reflection em cada etapa… sua performance acabou de ir pro espaço e você pode se preparar pra ouvir reclamações do seu chefe.

É aí que entra o Mapperly.

O que é Mapperly?

Mapperly é uma biblioteca que usa a magia dos geradores de código fonte para criar métodos de mapeamento de objetos em tempo de compilação. Isso significa que você não precisa se preocupar com reflexão, configuração ou performance em tempo de execução. Você só precisa declarar os métodos de mapeamento que você quer e o Mapperly faz o resto por você. É como se você tivesse um assistente pessoal que escreve o código chato para você, enquanto você se diverte com as partes mais interessantes do seu projeto. Não é incrível?

Mas não se engane, o Mapperly não é um gênio da lâmpada que realiza todos os seus desejos. Ele tem algumas limitações e regras que você precisa seguir para usá-lo corretamente. Por exemplo, ele só funciona com classes que tenham propriedades públicas e getters e setters. Ele também não suporta tipos genéricos, coleções aninhadas ou herança. E ele não vai fazer café para você, nem te dar um abraço quando você estiver triste. Ele é um gerador de código fonte, não um terapeuta.

Como instalar o Mapperly?

Para usar o Mapperly, você precisa adicionar o pacote NuGet Riok.Mapperly ao seu projeto .NET Core Web API. Você pode fazer isso usando o comando:

dotnet add package Riok.Mapperly

Ou usando o gerenciador de pacotes do Visual Studio. Depois disso, você está pronto para usar o Mapperly no seu projeto.

Mas cuidado, não confunda o Mapperly com o Mapster, o AutoMapper ou o TinyMapper. Esses são outros geradores de código fonte para mapeamento de objetos em .NET, mas eles são diferentes do Mapperly em vários aspectos. Por exemplo, o Mapster usa expressões lambda para configurar os mapeamentos, o AutoMapper usa convenções e atributos e o TinyMapper usa reflexão e IL emit. O Mapperly é mais simples e rápido do que todos eles, pois ele usa apenas os nomes das propriedades para gerar os métodos de mapeamento em tempo de compilação. Além disso, o Mapperly tem um nome mais legal e uma logo mais bonita. 😎

Como usar o Mapperly?

Para usar o Mapperly, você precisa criar uma classe parcial que tenha o atributo [Mapper] e declare os métodos de mapeamento que você quer. Por exemplo, vamos supor que você tenha as seguintes classes:

public class Car
{
    public int Id { get; set; }
    public string Model { get; set; }
    public string Color { get; set; }
}

public class CarDto
{
    public int Id { get; set; }
    public string Model { get; set; }
    public string Color { get; set; }
}

E você quer criar um método que converte um objeto Car em um objeto CarDto. Você pode fazer isso criando uma classe parcial chamada CarMapper e declarando o método CarToCarDto:

[Mapper]
public partial class CarMapper
{
    public partial CarDto CarToCarDto(Car car);
}

E é isso! Você não precisa implementar o método, nem configurar nada. O Mapperly vai gerar o código do método para você em tempo de compilação, usando as convenções de nomes das propriedades. O código gerado será algo assim:

public partial class CarMapper
{
    public CarDto CarToCarDto(Car car)
    {
        return new CarDto
        {
            Id = car.Id,
            Model = car.Model,
            Color = car.Color
        };
    }
}

Você pode verificar o código gerado no Visual Studio, expandindo a classe CarMapper na janela do Solution Explorer e clicando no arquivo CarMapper.g.cs.

Mas não se assuste com a extensão .g.cs, isso não significa que o código foi escrito por um fantasma. Isso significa que o código foi gerado pelo Mapperly, usando a nova funcionalidade dos geradores de código fonte do .NET 5. Essa funcionalidade permite que bibliotecas como o Mapperly possam injetar código fonte no processo de compilação, sem precisar de ferramentas externas ou arquivos adicionais. É uma forma de automatizar e otimizar o desenvolvimento de software, sem perder o controle ou a qualidade do código.

E como fica num projeto .NET Core WebApi?

Simples, precisamos primeiro registrar o serviço como scopped, no seu arquivo program.cs, assim (supondo que você criou uma classe de mapeamento chamada “MainMapper”):

services.AddScoped<MainMapper>();

E então, fazer a injeção no construtor dos seus controllers. Logo abaixo temos um exemplo de classe responsável pela criação de um usuário no sistema:

using Application.Mappers;
using Domain.Interfaces;
using MediatR;

namespace Application.UseCases.CreateUser;
public sealed class CreateUserHandler : IRequestHandler
{
private readonly IUnitOfWork _unitOfWork;
private readonly IUserRepository _userRepository;
private readonly MainMapper _mainMapper;

public CreateUserHandler(IUnitOfWork unitOfWork, IUserRepository userRepository, MainMapper mainMapper)
{
    _unitOfWork = unitOfWork;
    _userRepository = userRepository;
    _mainMapper = mainMapper;
}

public async Task<CreateUserResponse> Handle(CreateUserRequest request, CancellationToken cancellationToken)
{
    var user = _mainMapper.UserFrom(request);

    _userRepository.Create(user);

    await _unitOfWork.Commit(cancellationToken);

    return _mainMapper.CreateUserResponseFrom(user);
}

}

Considerações Finais

O Mapperly realmente é uma excelente opção de mapeamento em suas aplicações. Ele é leve, robusto, e vai te poupar horas de código.

Faça uma visita também a documentação do projeto.

Existe uma aplicação que mostra seu desempenho frente as outras opções do mercado, basta acessar e fazer o download do projeto Benchmark.netCoreMappers.

Ao executar este projeto, você verá uma saída semelhante a esta abaixo:

E estamos conversados.