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

OOP i "Enterprise OOP"

OOP - cztery filary

Programowanie obiektowe opiera się na czterech zasadach, które w praktyce już wielokrotnie przewijały się w naszej rozmowie (SOLID, modyfikatory dziedziczenia, abstract/interface) - tu zbieram je w jedną, zwięzłą odpowiedź na klasyczne pytanie "co to jest OOP".

1. Encapsulation (hermetyzacja)

Ukrycie wewnętrznego stanu obiektu i kontrola dostępu do niego przez publiczne API.

public class BankAccount
{
    private decimal _balance; // stan UKRYTY, niedostępny z zewnątrz

    public decimal Balance => _balance; // tylko odczyt z zewnątrz

    public void Deposit(decimal amount)
    {
        if (amount <= 0) throw new ArgumentException("Kwota musi być pozytywna");
        _balance += amount; // jedyny sposób modyfikacji - przez kontrolowaną metodę
    }
}

To wraca do modyfikatorów dostępu, o których mówiliśmy - private/protected to mechanizm, który to fizycznie wymusza.

2. Inheritance (dziedziczenie)

Klasa pochodna dziedziczy zachowanie i stan klasy bazowej - to dokładnie virtual/override/abstract, które już omawialiśmy przy modyfikatorach dziedziczenia.

3. Polymorphism (polimorfizm)

Ten sam interfejs/metoda zachowuje się różnie zależnie od faktycznego typu obiektu w runtime.

Animal[] animals = { new Dog(), new Cat() };
foreach (var a in animals) a.MakeSound(); // WOŁA różną implementację, ta SAMA linijka kodu

4. Abstraction (abstrakcja)

Ukrycie złożoności implementacji za prostym interfejsem - IOrderRepository nie mówi Ci jak dane są zapisywane, tylko co można z nim zrobić.


"Enterprise OOP" - termin krytyczny, nie techniczny

To jest ważne rozróżnienie: "Enterprise OOP" nie jest formalną nazwą kolejnego wzorca projektowego - to potoczny, lekko ironiczny termin opisujący patologiczne nadużycie zasad OOP/SOLID w dużych, korporacyjnych kodowbazach (klasycznie kojarzone z Java EE/Spring z lat 2000., ale to samo zdarza się w .NET) - gdzie proste zadanie zostaje owinięte w kilkanaście warstw abstrakcji "na wszelki wypadek", bez realnej potrzeby biznesowej.

Skąd się to bierze - historyczny punkt odniesienia

Istnieje słynny, satyryczny projekt open-source FizzBuzzEnterpriseEdition - implementacja trywialnego zadania rekrutacyjnego FizzBuzz (wypisz liczby 1-100, "Fizz" dla podzielnych przez 3, "Buzz" dla podzielnych przez 5) rozdmuchana do dziesiątek klas, fabryk, strategii i interfejsów - żeby w praktyce pokazać, jak wygląda ten antywzorzec, kiedy zastosuje się "wszystkie dobre praktyki" bez zastanowienia, czy problem tego wymaga.

Rozbudowany przykład - kalkulacja rabatu zamówienia

To jest częste zadanie rekrutacyjne w wersji biznesowej (nie abstrakcyjnej jak FizzBuzz): "oblicz cenę zamówienia po rabacie - 10% zniżki, jeśli suma przekracza 1000 zł". Zobaczmy, jak wygląda to samo zadanie w stylu "Enterprise OOP" i jak wygląda pragmatyczne rozwiązanie - to jest dobry materiał do pokazania na rozmowie, że rozumiesz różnicę, nie tylko potrafisz wymienić wzorce.

Wersja "Enterprise OOP" - 9 typów, żeby policzyć jeden rabat

// --- Kontrakty ---
public enum DiscountPolicyType { Standard, None }

public interface IDiscountPolicy
{
    decimal Apply(decimal amount);
}

public interface IDiscountPolicyFactory
{
    IDiscountPolicy Create(DiscountPolicyType type);
}

public interface IDiscountPolicyFactoryProvider
{
    IDiscountPolicyFactory GetFactory();
}

public interface IOrderDiscountOrchestrator
{
    decimal Calculate(OrderDiscountRequest request);
}

// --- DTO żądania (bo przekazanie samego "decimal" byłoby "nieelastyczne") ---
public sealed class OrderDiscountRequest
{
    public decimal Amount { get; init; }
    public DiscountPolicyType PolicyType { get; init; }
}

// --- Implementacje polityk rabatowych ---
public sealed class StandardDiscountPolicy : IDiscountPolicy
{
    private const decimal Threshold = 1000m;
    private const decimal Rate = 0.10m;

    public decimal Apply(decimal amount)
        => amount >= Threshold ? amount - amount * Rate : amount;
}

public sealed class NoDiscountPolicy : IDiscountPolicy
{
    public decimal Apply(decimal amount) => amount;
}

// --- Fabryka polityk ---
public sealed class DiscountPolicyFactory : IDiscountPolicyFactory
{
    public IDiscountPolicy Create(DiscountPolicyType type) => type switch
    {
        DiscountPolicyType.Standard => new StandardDiscountPolicy(),
        _ => new NoDiscountPolicy()
    };
}

// --- Dostawca fabryki - bo "a co jeśli w przyszłości będzie WIELE fabryk?" ---
public sealed class DiscountPolicyFactoryProvider : IDiscountPolicyFactoryProvider
{
    public IDiscountPolicyFactory GetFactory() => new DiscountPolicyFactory();
}

// --- "Orchestrator" - bo samo wywołanie polityki byłoby zbyt bezpośrednie ---
public sealed class OrderDiscountOrchestrator : IOrderDiscountOrchestrator
{
    private readonly IDiscountPolicyFactoryProvider _provider;

    public OrderDiscountOrchestrator(IDiscountPolicyFactoryProvider provider)
        => _provider = provider;

    public decimal Calculate(OrderDiscountRequest request)
    {
        var factory = _provider.GetFactory();
        var policy = factory.Create(request.PolicyType);
        return policy.Apply(request.Amount);
    }
}

// --- Rejestracja w DI - i tak trzeba to WSZYSTKO podłączyć ---
var services = new ServiceCollection(); // z Microsoft.Extensions.DependencyInjection
services.AddSingleton<IDiscountPolicyFactoryProvider, DiscountPolicyFactoryProvider>();
services.AddSingleton<IOrderDiscountOrchestrator, OrderDiscountOrchestrator>();
var serviceProvider = services.BuildServiceProvider(); // zamienia rejestr w działający kontener

// --- Użycie ---
var orchestrator = serviceProvider.GetRequiredService<IOrderDiscountOrchestrator>();
var total = orchestrator.Calculate(new OrderDiscountRequest
{
    Amount = 1200m,
    PolicyType = DiscountPolicyType.Standard
});

Policzmy: 4 interfejsy, 5 klas, 1 enum, 1 DTO, 2 rejestracje DI - 9 typów, żeby wykonać jedno porównanie i jedno mnożenie. Każdy z tych elementów "broni się" pojedynczo (Factory Pattern! Dependency Inversion! Single Responsibility!), ale razem rozwiązują problem, który w ogóle nie istnieje: nikt nie zgłosił potrzeby wielu fabryk polityk, ani wielu dostawców fabryk.

Wersja pragmatyczna - to samo zadanie

public static class OrderPricing
{
    private const decimal DiscountThreshold = 1000m;
    private const decimal DiscountRate = 0.10m;

    public static decimal CalculateTotal(decimal amount)
        => amount >= DiscountThreshold ? amount * (1 - DiscountRate) : amount;
}
var total = OrderPricing.CalculateTotal(1200m); // 1080

1 metoda, 2 stałe. Identyczny wynik, w pełni testowalna ([Theory]/[InlineData], jak omawialiśmy przy xUnit), czytelna dla każdego, kto otworzy ten plik po raz pierwszy.

Kiedy wersja "enterprise" faktycznie miałaby sens

Żeby być fair - rozbudowana wersja przestaje być patologią, gdy realnie potrzebujesz: różnych polityk rabatowych wybieranych w runtime na podstawie konfiguracji/segmentu klienta, wielu niezależnych dostawców fabryk (np. per-region, per-tenant w multi-tenant SaaS), albo gdy IDiscountPolicy ma rzeczywiście wiele implementacji używanych zamiennie w produkcji. Różnica między dobrym designem a "Enterprise OOP" to nie obecność abstrakcji, tylko czy abstrakcja odpowiada na istniejącą, potwierdzoną potrzebę, czy tylko na hipotetyczną "a może kiedyś".

Jak rozpoznać "Enterprise OOP" w praktyce - checklist

Sygnał Przykład
Interfejs z jedną implementacją, na zawsze IOrderValidator z jedyną klasą OrderValidator, nigdy podmienioną
Głęboka hierarchia dziedziczenia "na przyszłość" AbstractBaseServiceProviderFactoryManager
Wzorzec projektowy zastosowany bez problemu, który rozwiązuje Strategy dla logiki, która nigdy się nie zmienia
Warstwy pośredniczące niedodające wartości Generyczne Repository nad EF Core, o którym mówiliśmy - GetAllAsync() zwracające to, co DbSet już daje
"Provider" dostawcy fabryki dostawcy Jak w przykładzie wyżej - IDiscountPolicyFactoryProvider
Nazwy klas dłuższe niż ich zawartość AbstractSingletonProxyFactoryBean (prawdziwa klasa ze Springa, klasyczny żart w tym środowisku)

Dlaczego to jest ważne na rozmowie SE III

To jest właściwie domknięcie tematu SOLID, o którym rozmawialiśmy na samym początku - dobra odpowiedź na "co sądzisz o SOLID" nie kończy się na entuzjastycznym wyliczeniu zasad, tylko pokazuje umiar: znajomość YAGNI ("You Aren't Gonna Need It") i KISS ("Keep It Simple") jako przeciwwagi. Rozmówca na poziomie SE III często właśnie tego szuka - czy kandydat wie, kiedy przestać stosować wzorce, a nie tylko że je zna.

Dobra, zwięzła odpowiedź na rozmowie: "OOP to encapsulation, inheritance, polymorphism i abstraction - fundament, na którym stoi SOLID. 'Enterprise OOP' to nieformalny, krytyczny termin na nadużywanie tych zasad - tworzenie abstrakcji, fabryk i interfejsów bez realnej, potwierdzonej potrzeby, tylko 'bo to dobra praktyka'. Klasyczny przykład to satyryczny projekt FizzBuzzEnterpriseEdition. Dobre wykorzystanie OOP to nie maksymalizacja liczby wzorców w kodzie, tylko rozwiązanie konkretnego problemu z odpowiednim, minimalnym poziomem abstrakcji - a każdą dodatkową warstwę powinieneś umieć uzasadnić konkretną, istniejącą potrzebą, nie hipotetyczną przyszłością."
Postaw mi kawę