C# / .NET Kompendium PLEN
.NET / C# / AutoMapper

AutoMapper - mapowanie obiektów

Problem, który rozwiązuje - ręczne mapowanie jest nudne i podatne na błędy

// Ręczne mapowanie - działa, ale rozrasta się i łatwo o pomyłkę przy dodaniu nowego pola
public OrderDto MapToDto(Order order)
{
    return new OrderDto
    {
        Id = order.Id,
        CustomerName = order.Customer.Name, // nawigacja
        Total = order.TotalAmount,
        ItemCount = order.Items.Count
    };
}

Dla dużych obiektów z dziesiątkami pól, ręczne mapowanie to sporo powtarzalnego kodu - i łatwo zapomnieć zmapować nowe pole po dodaniu go do encji/DTO.

Podstawowa konfiguracja Profile

public class OrderMappingProfile : Profile
{
    public OrderMappingProfile()
    {
        CreateMap<Order, OrderDto>()
            .ForMember(dest => dest.CustomerName, opt => opt.MapFrom(src => src.Customer.Name))
            .ForMember(dest => dest.ItemCount, opt => opt.MapFrom(src => src.Items.Count));
        // Total → TotalAmount mapowane AUTOMATYCZNIE, jeśli nazwy się różnią tylko konwencją,
        // albo Id → Id, CustomerName → CustomerName gdy nazwy IDENTYCZNE - bez ForMember
    }
}

Konwencja automatycznego mapowania: AutoMapper domyślnie mapuje właściwości o identycznych nazwach bez żadnej konfiguracji - ForMember potrzebny jest tylko dla pól wymagających niestandardowej logiki (inna nazwa, transformacja, nawigacja przez zagnieżdżone obiekty).

Rejestracja w DI

builder.Services.AddAutoMapper(typeof(OrderMappingProfile).Assembly); // skanuje assembly, rejestruje WSZYSTKIE profile

Użycie przez IMapper (wstrzykiwane przez DI - constructor injection, jak zawsze)

public class OrderService : IOrderService
{
    private readonly AppDbContext _context;
    private readonly IMapper _mapper;

    public OrderService(AppDbContext context, IMapper mapper)
    {
        _context = context;
        _mapper = mapper;
    }

    public async Task<OrderDto> GetOrderAsync(int id)
    {
        var order = await _context.Orders.Include(o => o.Customer).FirstOrDefaultAsync(o => o.Id == id);
        return _mapper.Map<OrderDto>(order); // jedna linia zamiast ręcznego mapowania
    }
}

ProjectTo<T>() - mapowanie NA POZIOMIE SQL (kluczowa optymalizacja z EF Core)

To jest najważniejsza rzecz do wiedzenia o AutoMapper w kontekście EF Core - i nawiązuje wprost do rozmowy o IQueryable/IEnumerable:

// ❌ NIEEFEKTYWNE - najpierw materializuje WSZYSTKIE kolumny, POTEM mapuje w pamięci
var orders = await _context.Orders.ToListAsync(); // SELECT * (wszystkie kolumny!)
var dtos = _mapper.Map<List<OrderDto>>(orders); // mapowanie w C#, po pobraniu WSZYSTKIEGO

// ✅ EFEKTYWNE - ProjectTo tłumaczy mapowanie NA SQL SELECT z konkretnymi kolumnami
var dtos = await _context.Orders
    .ProjectTo<OrderDto>(_mapper.ConfigurationProvider) // generuje SELECT TYLKO potrzebnych kolumn!
    .ToListAsync();

ProjectTo<T>() działa na IQueryable (dokładnie ten interfejs, o którym mówiliśmy szczegółowo) - AutoMapper analizuje konfigurację mapowania i wbudowuje ją w drzewo wyrażeń zapytania, więc EF Core generuje SQL SELECT z wyłącznie potrzebnymi kolumnami, zamiast pobierać całą encję i mapować w pamięci C#.

-- Map() po ToListAsync() - EF Core generuje:
SELECT * FROM Orders  -- WSZYSTKIE kolumny, w tym te niepotrzebne do OrderDto

-- ProjectTo() - EF Core generuje:
SELECT Id, TotalAmount, (SELECT COUNT(*) FROM OrderItems WHERE OrderId = Orders.Id) AS ItemCount
FROM Orders -- TYLKO kolumny potrzebne do OrderDto

Custom Value Resolvers - złożona logika mapowania

public class DiscountResolver : IValueResolver<Order, OrderDto, decimal>
{
    public decimal Resolve(Order source, OrderDto destination, decimal destMember, ResolutionContext context)
    {
        return source.TotalAmount * (source.Customer.IsVip ? 0.9m : 1.0m); // logika zbyt złożona na ForMember
    }
}

CreateMap<Order, OrderDto>()
    .ForMember(dest => dest.DiscountedTotal, opt => opt.MapFrom<DiscountResolver>());

Mapowanie odwrotne - ReverseMap()

CreateMap<Order, OrderDto>()
    .ReverseMap(); // automatycznie generuje TEŻ mapowanie OrderDto → Order

Walidacja konfiguracji - AssertConfigurationIsValid()

// W testach - sprawdza, że WSZYSTKIE mapowania są kompletne (żadne pole nieprzypisane bez wyjątku)
var config = new MapperConfiguration(cfg => cfg.AddProfile<OrderMappingProfile>());
config.AssertConfigurationIsValid();

To jest ważna praktyka - AutoMapper domyślnie nie rzuca błędu, jeśli jakieś pole docelowe nie ma odpowiadającego źródła (zostaje z wartością domyślną) - AssertConfigurationIsValid() w teście wychwytuje takie przypadki przed wdrożeniem, zamiast dowiadywać się o tym z pustych danych na produkcji.

Kontrowersje wokół AutoMapper - warto znać na rozmowie

To jest częsty temat dyskusyjny (podobny do Repository/UoW) - część zespołów unika AutoMapper na rzecz ręcznych metod mapujących albo generatorów kodu (np. Mapperly - nowsza alternatywa generująca kod w compile-time):

Argumenty przeciw AutoMapper: - "Magia" utrudnia debugowanie - błąd mapowania ujawnia się w runtime, nie w compile-time - Refaktoryzacja (zmiana nazwy pola) nie jest bezpieczna - ForMember(dest => dest.OldName, ...) po zmianie nazwy property nadal się skompiluje, ale przestanie działać poprawnie - Narzut wydajnościowy dla prostego mapowania 1:1 (choć ProjectTo częściowo to łagodzi)

Argumenty za: - Mniej powtarzalnego kodu przy dużej liczbie DTO - ProjectTo daje realną, praktyczną optymalizację SQL bez ręcznego pisania projekcji LINQ

Podsumowanie

AutoMapper eliminuje powtarzalny kod ręcznego mapowania między encjami i DTO, przez konfigurację w Profile i konwencję dopasowania po nazwach właściwości. Kluczowa, praktyczna optymalizacja to ProjectTo<T>(), które - w przeciwieństwie do Map() wywoływanego po materializacji - działa na poziomie IQueryable, tłumacząc mapowanie na SQL SELECT z tylko potrzebnymi kolumnami, zamiast pobierać całą encję i mapować ją w pamięci C#.

Postaw mi kawę