C# / .NET Kompendium PLEN
.NET / C# / Przypomnienie / wzorce web

Gdzie umieszczać DTO w projekcie MVVM (WPF)

Problem - DTO żyje "między" warstwami

DTO (Data Transfer Object) to obiekt reprezentujący dane w formie, w jakiej przemieszczają się między warstwami (np. z Web API do klienta WPF) - nie jest to ani czysty Model domenowy, ani ViewModel. Pytanie "gdzie go umieścić" dotyka fundamentalnej struktury projektu.

Typowa struktura projektu WPF z DI (nawiązanie do wcześniejszej rozmowy)

MyApp/
├── Models/              ← Model domenowy (jeśli lokalny, nie tylko przez API)
│   └── User.cs
├── DTOs/                ← DTO - format wymiany danych z API
│   └── OrderDto.cs
├── Services/            ← serwisy, klienci API (Services/OrderApiClient.cs z wcześniejszej rozmowy)
│   ├── IOrderApiClient.cs
│   └── OrderApiClient.cs
├── ViewModels/
│   ├── ViewModelBase.cs
│   └── OrderDetailsViewModel.cs
├── Views/
│   └── OrderDetailsView.xaml

DTO żyje w osobnym folderze DTOs/ (albo Contracts/), równolegle do Models/ - to jest kluczowa decyzja architektoniczna: DTO nie jest Modelem domenowym, mimo że mogą wyglądać podobnie.

Dlaczego NIE używać DTO bezpośrednio jako Property w ViewModelu (częsty błąd)

// ❌ Wątpliwa praktyka - ViewModel bezpośrednio operuje na DTO z API
public class OrderDetailsViewModel : ViewModelBase
{
    private OrderDto _order; // DTO z API, jako typ Property ViewModelu
    public OrderDto Order
    {
        get => _order;
        set => SetProperty(ref _order, value);
    }
}

Problem: DTO jest zaprojektowane dla kontraktu API (format JSON), nie dla potrzeb UI. Jeśli serwer zmieni kontrakt API (np. zmieni nazwę pola), ViewModel i binding w XAML łamią się równocześnie - DTO "przecieka" przez wszystkie warstwy aż do UI.

Lepsze podejście - osobny model dla UI (czasem nazywany "Presentation Model" albo po prostu właściwości na samym ViewModelu)

// DTOs/OrderDto.cs - kontrakt z API, format 1:1 z JSON
public record OrderDto(int Id, string CustomerName, decimal TotalAmount, string Status, DateTime CreatedAt);
// ViewModels/OrderDetailsViewModel.cs - właściwości dopasowane do POTRZEB UI, nie do kontraktu API
public class OrderDetailsViewModel : ViewModelBase
{
    private readonly IOrderApiClient _apiClient;

    private int _orderId;
    public int OrderId { get => _orderId; set => SetProperty(ref _orderId, value); }

    private string _customerName;
    public string CustomerName { get => _customerName; set => SetProperty(ref _customerName, value); }

    // Właściwość WYLICZONA, potrzebna TYLKO w UI - DTO jej nie ma i nie powinien mieć
    private string _formattedTotal;
    public string FormattedTotal { get => _formattedTotal; set => SetProperty(ref _formattedTotal, value); }

    // Kolor/status specyficzny dla WYŚWIETLANIA - też nie ma sensu w DTO
    private Brush _statusColor;
    public Brush StatusColor { get => _statusColor; set => SetProperty(ref _statusColor, value); }

    public OrderDetailsViewModel(IOrderApiClient apiClient) => _apiClient = apiClient;

    public async Task LoadOrderAsync(int id)
    {
        var result = await _apiClient.GetOrderAsync(id); // pobiera DTO z API

        if (result.IsSuccess)
        {
            var dto = result.Value;

            // MAPOWANIE z DTO na właściwości ViewModelu - tu następuje "rozprzęgnięcie"
            OrderId = dto.Id;
            CustomerName = dto.CustomerName;
            FormattedTotal = dto.TotalAmount.ToString("C"); // logika PREZENTACJI, nie należy do DTO
            StatusColor = dto.Status == "Shipped" ? Brushes.Green : Brushes.Orange; // logika UI
        }
    }
}

Kluczowa zasada: DTO wchodzi do ViewModelu (jako parametr metody, tymczasowa zmienna), ale nie zostaje jako Property bindowana w XAML - ViewModel mapuje dane z DTO na własne właściwości, dopasowane do potrzeb UI (sformatowane, wyliczone, wzbogacone o logikę prezentacji).

Kiedy DTO JAKO Property jest akceptowalne - prostsze przypadki

Dla bardzo prostych ViewModeli, gdzie DTO 1:1 odpowiada temu, co UI potrzebuje wyświetlić (bez transformacji), bezpośrednie użycie DTO bywa pragmatycznym kompromisem - ale trzeba być tego świadomym jako decyzji, a nie przypadkowej konsekwencji "tak było łatwiej":

// Akceptowalne dla PROSTEJ listy, gdzie UI wyświetla dane 1:1
public class OrderListViewModel : ViewModelBase
{
    public ObservableCollection<OrderDto> Orders { get; } = new(); // ObservableCollection z wcześniejszej rozmowy o WPF
}

To jest kompromis praktyczny - dla listy wyświetlającej proste dane bez dodatkowej logiki prezentacji, tworzenie osobnego "Presentation Model" bywa niepotrzebnym narzutem.

Automapper - naturalne zastosowanie tu (nawiązanie do wcześniejszej rozmowy)

// Profile mapujący DTO na "model" ViewModelu, jeśli różnice są nietrywialne
public class OrderPresentationMappingProfile : Profile
{
    public OrderPresentationMappingProfile()
    {
        CreateMap<OrderDto, OrderPresentationModel>()
            .ForMember(dest => dest.FormattedTotal, opt => opt.MapFrom(src => src.TotalAmount.ToString("C")))
            .ForMember(dest => dest.StatusColor, opt => opt.MapFrom(src => src.Status == "Shipped" ? "Green" : "Orange"));
    }
}

Podsumowanie - reguła praktyczna

DTO powinien żyć w osobnym folderze/namespace (DTOs/), reprezentując wyłącznie kontrakt komunikacji z API - nigdy Model domenowy. W ViewModelu, DTO przechodzi przez metody ładujące dane, ale dla nietrywialnych przypadków (potrzeba formatowania, logiki prezentacji, właściwości wyliczanych) powinien być zmapowany na właściwości samego ViewModelu (albo dedykowany "Presentation Model"), żeby zmiana kontraktu API nie łamała bezpośrednio bindingu w XAML. Dla prostych, statycznych list bez transformacji, bezpośrednie bindowanie DTO jest pragmatycznym, akceptowalnym kompromisem.

Postaw mi kawę