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.