Kako funkcionira dependency injection u .NET-u?

Question

Accepted Answer

**Dependency Injection (DI)** je ugrađen u moderni .NET — okvir uključuje DI spremnik koji automatski konstruira klase i **ubacuje njihove ovisnosti**. Registrirate servise (mapiranje sučelja na implementacije) i spremnik ih rješava, omogućavajući labavo povezan, testabilan kod. To je temelj ASP.NET Core-a. ## Registracija servisa ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` Registrirate svako mapiranje servisa sučelja na **implementaciju** s vremenom trajanja. Zatim sve što ovisi o sučelju dobiva registriranu implementaciju. ## Constructor injection (standardni obrazac) ```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 ``` Ovisnosti se deklariraju kao parametri konstruktora (tipizirani kao sučelja); spremnik konstruira klasu i ubacuje registrirane implementacije, automatski rješavajući cijeli graf ovisnosti. ## Service lifetimes (važno je pravilno birati) ```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. ``` ## Prednosti: labavo povezivanje i testabilnost ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## Zašto je to važno Dependency injection je temeljen u modernom .NET-u — **ugrađen je u okvir** i predstavlja okosnica ASP.NET Core-a, tako da je razumijevanje tog koncepta nužno za bilo koji razvoj modernih C# aplikacija. Ugrađeni DI spremnik okvira automatski konstruira klase i ubacuje njihove ovisnosti (rješavajući cijeli graf ovisnosti), tako da registrirate servise i dozvoljavate spremniku da sve međusobno poveže umjesto ručnog instanciranja ovisnosti. Ključne prednosti su značajne i centralne razlozima zašto se DI naglašava: **labavo povezivanje** (ovisi o sučeljima umjesto konkretnih klasa, tako da se implementacije mogu zamijeniti) i posebno **testabilnost** (ubacivanje mock implementacija u testove umjesto stvarnih ovisnosti poput baza podataka ili email servisa — čineći temeljitu testiranje jedinica praktičnim). Razumijevanje kako registrirati servise (mapiranje sučelja na implementacije), constructor injection (standardni obrazac) i — što je važno — **service lifetimes** (`Singleton`, `Scoped`, `Transient`) je nužno: odabir pogrešnog vremena trajanja uzrokuje suptilne, teške greške za ispravljanje (npr. singleton koji drži scoped `DbContext`, ili thread-safety probleme sa zajedničkim singletonima), tako da razumijevanje kada se primjenjuje svako vrijeme trajanja (Scoped po zahtjevu za stvari poput DbContext-a, Singleton za dijeljene bezzavršne servise, Transient za lagane) je kritično. Budući da je DI ugrađen u .NET, je temeljen na arhitekturi ASP.NET Core-a i predstavlja ključ za pisanje labavo povezanog, testabilnog koda, savladavanje toga — spremnika, constructor injection-a, dizajna temeljenog na sučeljima i posebno service lifetimes-a — je važno, često primjenjivano znanje za suradnike pri izgradnji održavajućih, testabilnih modernih C# aplikacija, i česta tema na razgovorima za posao.