Jak funguje dependency injection v .NET?

Question

Accepted Answer

**Dependency Injection (DI)** je vestavěná do moderního .NET — framework obsahuje DI kontejner, který automaticky konstruuje třídy a **injektuje jejich závislosti**. Registrujete služby (mapování rozhraní na implementace) a kontejner je řeší, což umožňuje volně vázaný, testovatelný kód. Je to základem ASP.NET Core. ## Registrace služeb ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` Každé mapování služby registrujete mapováním **rozhraní na implementaci** s určitou dobou životnosti. Poté cokoli závislého na rozhraní dostane registrovanou implementaci. ## Constructor injection (standardní pattern) ```csharp public class UserService { private readonly IUserRepository _repo; private readonly IEmailSender _email; // dependencies are declared in the constructor — the container INJECTS them automatically public UserService(IUserRepository repo, IEmailSender email) { _repo = repo; _email = email; } } // you never `new UserService(...)` manually — the container builds it, resolving the chain ``` Závislosti se deklarují jako parametry konstruktoru (typizované jako rozhraní); kontejner konstruuje třídu a injektuje registrované implementace, přitom automaticky řeší celý graf závislostí. ## Service lifetimes (důležité je vybrat správně) ```text Singleton → ONE instance for the entire app lifetime (shared; must be thread-safe) Scoped → one instance PER request (the common default for web — e.g. DbContext) Transient → a NEW instance every time it's requested (lightweight, stateless services) → Choosing wrong (e.g. a singleton capturing a scoped DbContext) causes subtle bugs. ``` ## Výhody: volné vazby a testovatelnost ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## Proč je to důležité Dependency injection je základem moderního .NET — je **vestavěná do frameworku** a je páteří ASP.NET Core, takže její pochopení je nezbytné pro vývoj jakékoli moderní C# aplikace. Vestavěný DI kontejner frameworku automaticky konstruuje třídy a injektuje jejich závislosti (řeší celý graf závislostí), takže registrujete služby a necháte kontejner, aby vše propojil, místo abyste ručně instanciovali závislosti. Jádní výhody jsou významné a centrální pro to, proč je DI zdůrazňováno: **volné vazby** (závislost na rozhraních spíše než na konkrétních třídách, takže implementace lze vyměňovat) a zejména **testovatelnost** (injektování mock implementací do testů místo skutečných závislostí jako databází nebo emailových služeb — díky čemuž je důkladné unit testování praktické). Pochopení toho, jak registrovat služby (mapování rozhraní na implementace), constructor injection (standardní pattern) a — důležitě — **service lifetimes** (`Singleton`, `Scoped`, `Transient`) je nezbytné: volba špatné doby životnosti způsobuje jemné, těžko laditelné chyby (např. singleton držující scoped `DbContext` nebo problémy s thread-safety sdílených singletonů), takže pochopení, kdy se jednotlivé doby životnosti používají (Scoped per-request pro věci jako DbContext, Singleton pro sdílené bezstavové služby, Transient pro lehké), je kritické. Keďže je DI vestavěná do .NET, tvoří základ architektury ASP.NET Core a je klíčem k psaní volně vázaného, testovatelného kódu, zvládnutí — kontejneru, constructor injection, návrhu založeného na rozhraních a zejména service lifetimes — je důležitá, často aplikovaná znalost seniorní úrovně pro vytváření udržovatelných, testovatelných moderních C# aplikací a je to běžné téma na pohovorech.