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.