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

Inversion of Control (IoC)

Fundamentalna idea - odwrócenie kontroli

Inversion of Control to zasada projektowa mówiąca: zamiast Twój kod kontroluje przepływ i sam decyduje, kiedy wywołać zależności - to zewnętrzny framework/kontener kontroluje przepływ i wywołuje Twój kod. Kontrola zostaje "odwrócona" - stąd nazwa.

To jest szersza zasada (koncepcja architektoniczna), a DI to jedna konkretna technika realizująca tę zasadę - to jest kluczowa relacja, o którą często pytają wprost: "Czym różni się IoC od DI?" Odpowiedź: DI jest formą IoC, ale IoC to coś szerszego niż tylko DI.

Klasyczny przykład - "Hollywood Principle"

IoC bywa nazywane "Hollywood Principle": "Don't call us, we'll call you" (Nie dzwoń do nas, my zadzwonimy do Ciebie).

Kod BEZ IoC - Ty kontrolujesz przepływ

class Program
{
    static void Main()
    {
        var validator = new OrderValidator();
        var repository = new OrderRepository();
        var order = new Order();

        // TY decydujesz o kolejności, TY wywołujesz wszystko ręcznie
        if (validator.Validate(order))
        {
            repository.Save(order);
        }
    }
}

Tutaj Twój kod jest "szefem" - to on tworzy obiekty, decyduje o kolejności wywołań, kontroluje cały przepływ programu od początku do końca.

Kod Z IoC - framework kontroluje przepływ

[ApiController]
public class OrdersController : ControllerBase
{
    private readonly IOrderService _orderService;

    // Framework (ASP.NET Core) SAM wywołuje ten konstruktor
    public OrdersController(IOrderService orderService)
    {
        _orderService = orderService;
    }

    [HttpPost]
    public async Task<ActionResult> CreateOrder(Order order)
    {
        // Framework SAM decyduje KIEDY wywołać tę metodę (gdy przyjdzie request HTTP)
        await _orderService.PlaceOrderAsync(order);
        return Ok();
    }
}

Tutaj to ASP.NET Core jest "szefem": - Framework sam decyduje, kiedy stworzyć OrdersController (gdy przyjdzie request) - Framework sam wywołuje konstruktor i wstrzykuje zależności (to jest DI - konkretna technika) - Framework sam decyduje, którą metodę wywołać (na podstawie routingu) - Framework sam zarządza cyklem życia obiektu

Ty nie piszesz new OrdersController(...) nigdzie w swoim kodzie - oddałeś kontrolę nad tworzeniem obiektów i wywoływaniem Twojego kodu do frameworka.

IoC to coś więcej niż tylko DI - inne formy IoC

To jest właśnie to, co odróżnia dobrą odpowiedź od powierzchownej - IoC realizuje się na kilka różnych sposobów, DI to tylko jeden z nich:

1. Dependency Injection

Framework wstrzykuje zależności do Twoich klas, zamiast Twój kod je tworzył.

2. Template Method Pattern

public abstract class OrderProcessorBase
{
    // Framework/klasa bazowa kontroluje KOLEJNOŚĆ wykonania
    public void Process(Order order)
    {
        Validate(order);
        Save(order);
        Notify(order);
    }

    // Ty implementujesz TYLKO poszczególne kroki - nie kontrolujesz kiedy są wołane
    protected abstract void Validate(Order order);
    protected abstract void Save(Order order);
    protected abstract void Notify(Order order);
}

public class StandardOrderProcessor : OrderProcessorBase
{
    protected override void Validate(Order order) { /* Twoja logika */ }
    protected override void Save(Order order) { /* Twoja logika */ }
    protected override void Notify(Order order) { /* Twoja logika */ }
}

Klasa bazowa (Process) kontroluje kolejność i moment wywołania Twoich metod - Ty tylko dostarczasz implementację poszczególnych kroków. To też jest IoC - odwrócenie kontroli nad przepływem, tylko bez żadnego DI.

3. Event-driven / Callbacks

button.Click += (sender, e) => SaveOrder(); // Ty piszesz CO ma się stać
// ale to FRAMEWORK (WPF) decyduje KIEDY to wywoła - gdy user faktycznie kliknie

To dokładnie ten sam mechanizm "callback", o którym rozmawialiśmy - i to też jest forma IoC. Framework WPF kontroluje pętlę komunikatów, wykrywa kliknięcie, i sam wywołuje Twój handler - Ty nie piszesz SaveOrder() bezpośrednio w Main().

4. Frameworki webowe w ogóle (ASP.NET Core, Middleware pipeline)

app.Use(async (context, next) =>
{
    Console.WriteLine("Przed requestem");
    await next(); // oddajesz kontrolę z powrotem do frameworka
    Console.WriteLine("Po response");
});

Framework sam decyduje, kiedy wywołać Twój middleware, w jakiej kolejności, i kiedy wywołać kolejny w łańcuchu (next()).

5. WPF Dependency Properties / Data Binding

<TextBlock Text="{Binding User.Name}" />

Ty nie piszesz kodu, który "ręcznie" aktualizuje TextBlock przy zmianie User.Name - framework WPF sam obserwuje PropertyChanged i sam decyduje, kiedy odświeżyć UI. To też IoC - oddałeś kontrolę nad "kiedy update'ować UI" do frameworka.

Diagram myślowy - "kto do kogo dzwoni"

BEZ IoC (tradycyjny kod proceduralny):
Twój kod → tworzy obiekty → woła metody → kontroluje wszystko

Z IoC:
Framework → tworzy Twoje obiekty → woła Twoje metody →
            → w momencie, który framework uzna za stosowny

Dlaczego IoC jest wartościowe - z perspektywy SOLID

Wracając do tego, co omawialiśmy na samym początku (Dependency Inversion Principle) - IoC to mechanizm, który umożliwia realizację DIP. DIP mówi "zależ od abstrakcji, nie implementacji" - ale coś musi faktycznie dostarczyć tę konkretną implementację w runtime. IoC (poprzez kontener DI) to właśnie ten "ktoś", kto się tym zajmuje, żebyś Ty (jako klasa) mógł pozostać niewinny i zależeć tylko od interfejsu.

Praktyczna odpowiedź na rozmowie

Dobra, zwięzła odpowiedź na "co to jest IoC":

"IoC to zasada, w której kontrola nad tworzeniem obiektów i przepływem sterowania jest przekazana z Twojego kodu do zewnętrznego frameworka/kontenera - zamiast Ty wołać zależności, framework woła Twój kod. Dependency Injection to najpopularniejsza, konkretna technika realizująca IoC w kontekście zarządzania zależnościami, ale IoC obejmuje też inne mechanizmy jak Template Method, event-driven programming czy middleware pipeline - wspólny mianownik to zawsze 'ktoś inny kontroluje kiedy mój kod się wykona'."

To pokazuje, że rozróżniasz zasadę ogólną od konkretnej implementacji tej zasady - dokładnie tego typu rozróżnień szukają na poziomie SE III, żeby odróżnić kogoś, kto "zna nazwy wzorców", od kogoś, kto rozumie dlaczego te wzorce istnieją i jak się mają do siebie nawzajem.

Postaw mi kawę