C# / .NET Kompendium PLEN
.NET / C# / SOLID, Clean Code, DI

DDD - Domain-Driven Design

Czym jest DDD

Domain-Driven Design (projektowanie sterowane domeną, Eric Evans, 2003) to podejście do tworzenia złożonego oprogramowania, w którym model biznesowej domeny jest sercem aplikacji. Zamiast zaczynać od tabel i kontrolerów, zaczynasz od zrozumienia biznesu i odzwierciedlasz go w kodzie, razem z jego słownictwem i regułami.

DDD to nie framework ani biblioteka, tylko zestaw idei w dwóch warstwach:

  • Strategiczne DDD - jak podzielić duży system i jak rozmawiać z biznesem,
  • Taktyczne DDD - jakie klocki (encje, agregaty, ...) wykorzystać w kodzie domeny.

DDD ma sens przy złożonej logice biznesowej. Dla prostego CRUD-a to przerost formy nad treścią.

Strategiczne DDD

Ubiquitous Language (język wszechobecny)

Wspólny słownik programistów i ekspertów domenowych. Te same słowa padają w rozmowach, dokumentacji i w kodzie. Jeśli biznes mówi „zatwierdzić zamówienie”, w kodzie jest order.Confirm(), a nie order.SetStatus(2).

Bounded Context (kontekst ograniczony)

Granica, w której dany model i dany język mają jedno, spójne znaczenie. To samo słowo znaczy co innego w różnych kontekstach:

  • „Klient” w kontekście Sprzedaży - ma koszyk i historię zamówień,
  • „Klient” w kontekście Fakturowania - ma NIP, adres rozliczeniowy i warunki płatności.

Zamiast jednej gigantycznej klasy Customer są dwa modele, każdy w swoim kontekście. Bounded Context to naturalny kandydat na granicę modułu (modularny monolit) lub mikroserwisu.

Context Map i integracja kontekstów

Mapa opisująca, jak konteksty ze sobą rozmawiają (zdarzenia, API). Ważny wzorzec: Anti-Corruption Layer - warstwa tłumacząca, która chroni własny model przed „zanieczyszczeniem” cudzym (np. starym systemem legacy).

Subdomeny

  • Core domain - to, co daje przewagę konkurencyjną; tu inwestujesz w najlepszy model i ludzi,
  • Supporting subdomain - potrzebna, ale nie wyróżnia firmy,
  • Generic subdomain - problem rozwiązany wszędzie tak samo (uwierzytelnianie, płatności, e-mail) - kupuj lub używaj gotowca.

Taktyczne DDD - klocki modelu

Entity (encja)

Obiekt o tożsamości (Id), która trwa mimo zmiany jego danych. Dwa zamówienia z tymi samymi pozycjami to wciąż dwa różne zamówienia. Porównujemy po Id.

Value Object (obiekt wartościowy)

Obiekt bez tożsamości, definiowany wyłącznie przez swoje wartości; niemutowalny i porównywany po wartościach. Idealny kandydat na record (zobacz Record - deklaracja).

public record Money(decimal Amount, string Currency)
{
    public Money Add(Money other)
    {
        if (other.Currency != Currency)
            throw new InvalidOperationException("Różne waluty");
        return this with { Amount = Amount + other.Amount };
    }
}

public record Address(string Street, string City, string PostalCode);

Zamiast decimal price używasz Money price - kompilator pilnuje, żeby nie dodać złotówek do euro, a reguły (np. „kwota nie jest ujemna”) mieszkają w jednym miejscu. To walka z antywzorcem Primitive Obsession.

Aggregate i Aggregate Root (agregat)

Grupa obiektów traktowana jako jedna spójna całość pod kątem zmian. Dostęp z zewnątrz tylko przez korzeń agregatu (Aggregate Root), który pilnuje niezmienników (invariants). Szczegóły i przykład są w temacie Clean Architecture (sekcja o agregatach).

public class Order   // Aggregate Root
{
    private readonly List<OrderItem> _items = new();
    public int Id { get; private set; }
    public OrderStatus Status { get; private set; } = OrderStatus.Draft;
    public IReadOnlyList<OrderItem> Items => _items;   // brak publicznego Add na liście

    public void AddItem(int productId, int quantity, Money unitPrice)
    {
        if (Status != OrderStatus.Draft)
            throw new DomainException("Nie można zmieniać zatwierdzonego zamówienia");
        if (quantity <= 0)
            throw new DomainException("Ilość musi być dodatnia");

        _items.Add(new OrderItem(productId, quantity, unitPrice));
    }

    public void Confirm()
    {
        if (!_items.Any())
            throw new DomainException("Zamówienie jest puste");
        Status = OrderStatus.Confirmed;
    }
}

Zasady projektowania agregatów:

  • Jedna transakcja = jeden agregat (zmieniasz jeden agregat w jednej transakcji),
  • agregaty małe - zawierają tylko to, co musi być spójne razem,
  • inne agregaty wskazujesz po Id, a nie przez referencję do obiektu,
  • spójność między agregatami jest ostateczna (eventual consistency), np. przez zdarzenia domenowe.

Domain Service (serwis domenowy)

Logika domenowa, która nie pasuje do żadnej pojedynczej encji (np. przelew między dwoma kontami, kalkulacja ceny z wielu źródeł). Jest bezstanowy i operuje na obiektach domeny. Nie mylić z serwisem aplikacyjnym.

Domain Event (zdarzenie domenowe)

Fakt z przeszłości, który ma znaczenie dla biznesu, nazwany w czasie przeszłym: OrderConfirmed, PaymentReceived. Pozwala reagować na zmiany w innych agregatach i kontekstach bez ścisłego powiązania.

public record OrderConfirmed(int OrderId, DateTime OccurredAt) : INotification;

Często publikowane przez MediatR (INotification) lub, dla niezawodności między serwisami, przez wzorzec Outbox (zobacz Outbox).

Repository (repozytorium)

Abstrakcja kolekcji agregatów - jedno repozytorium na jeden agregat (nie na każdą tabelę). Interfejs należy do warstwy domeny, implementacja (EF Core) do infrastruktury. Więcej: Repository i Unit of Work.

public interface IOrderRepository
{
    Task<Order?> GetAsync(int id, CancellationToken ct);
    void Add(Order order);
}

Factory

Gdy tworzenie obiektu jest skomplikowane lub musi wymusić niezmienniki, wydzielasz metodę lub klasę fabryczną (często zwykła statyczna metoda Order.Create(...)).

Model anemiczny vs model bogaty

Anemic Domain Model (antywzorzec w DDD):

public class Order { public List<OrderItem> Items { get; set; } public string Status { get; set; } }
// cała logika w OrderService - encja to worek na dane

Rich Domain Model: logika i niezmienniki są w encji/agregacie (order.AddItem(), order.Confirm()), settery są prywatne, a stan nie może przejść w niepoprawny. Dzięki temu nie da się „zapomnieć” o walidacji w którymś serwisie.

DDD w .NET - jak to spiąć

  • Entity Framework Core wspiera DDD: konfiguracja przez Fluent API, prywatne settery, pola prywatne (_items), Value Objecty jako Owned Types (OwnsOne), konwersje wartości.
  • Clean Architecture daje strukturę projektów, w której warstwa Domain jest w środku i nie zależy od niczego (zobacz Clean Architecture).
  • CQRS + MediatR: Command Handler ładuje agregat, wywołuje jego metodę domenową i zapisuje; Query Handler czyta DTO prosto z bazy (zobacz Czym jest CQRS).
public class ConfirmOrderHandler : IRequestHandler<ConfirmOrderCommand>
{
    private readonly IOrderRepository _orders;
    private readonly IUnitOfWork _uow;
    public ConfirmOrderHandler(IOrderRepository orders, IUnitOfWork uow) { _orders = orders; _uow = uow; }

    public async Task Handle(ConfirmOrderCommand cmd, CancellationToken ct)
    {
        var order = await _orders.GetAsync(cmd.OrderId, ct)
                    ?? throw new NotFoundException(cmd.OrderId);

        order.Confirm();                 // logika biznesowa w agregacie
        await _uow.SaveChangesAsync(ct); // handler tylko orkiestruje
    }
}

Warstwy w DDD

Warstwa Odpowiedzialność
Domain Encje, Value Objecty, agregaty, zdarzenia domenowe, interfejsy repozytoriów
Application Use case'y (Command/Query Handlery), orkiestracja, transakcje
Infrastructure EF Core, repozytoria, kolejki, e-mail, integracje
Presentation API, kontrolery, UI

Kiedy stosować DDD, a kiedy nie

Stosuj, gdy: logika biznesowa jest złożona i często się zmienia, masz dostęp do eksperta domenowego, system będzie rozwijany latami.

Nie stosuj, gdy: aplikacja to prosty CRUD, zespół nie ma kontaktu z biznesem, prototyp lub krótkotrwałe narzędzie. Koszty: więcej kodu, krzywa uczenia, ryzyko przeinżynierowania.

DDD można stosować selektywnie - pełny model tylko w core domain, a w pozostałych częściach zwykły CRUD.

Pytania rekrutacyjne

  • Entity vs Value Object? Entity ma tożsamość (Id) i cykl życia, Value Object jest niemutowalny i porównywany po wartościach.
  • Co to agregat? Granica spójności transakcyjnej z korzeniem, który pilnuje niezmienników; z zewnątrz modyfikujemy go tylko przez korzeń.
  • Czym jest Bounded Context? Granica, w której model i język są spójne; ten sam termin może znaczyć co innego w różnych kontekstach.
  • Dlaczego model anemiczny jest problemem? Logika rozprasza się po serwisach, a encje mogą wejść w niepoprawny stan.
  • Jak komunikować agregaty między sobą? Przez Id i zdarzenia domenowe, ze spójnością ostateczną, a nie jedną wielką transakcją.
  • Czy DDD wymaga CQRS lub Clean Architecture? Nie - to niezależne, choć dobrze ze sobą współgrają.
Postaw mi kawę