Cum funcționează injectarea dependențelor în .NET?

Question

Accepted Answer

**Injectarea Dependențelor (DI)** este încorporată în .NET-ul modern — framework-ul include un container DI care construiește automat clasele și **injectează dependențele acestora**. Înregistrezi servicii (mapând interfețe la implementări) iar containerul le rezolvă, permițând codul să fie slab cuplat și ușor de testat. Este fundamental pentru ASP.NET Core. ## Înregistrarea serviciilor ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` Înregistrezi fiecare mapare de serviciu care legă o **interfață la o implementare** cu o durată de viață. Apoi orice depinde de interfață va obține implementarea înregistrată. ## Injectarea prin constructor (modelul standard) ```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 ``` Dependențele sunt declarate ca parametri de constructor (cu tip de interfață); containerul construiește clasa și injectează implementările înregistrate, rezolvând automat întregul grafic de dependență. ## Duratele de viață ale serviciilor (important de ales corect) ```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. ``` ## Beneficiile: cuplaj slab și testabilitate ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## De ce contează Injectarea dependențelor este fundamentală pentru .NET-ul modern — este **încorporată în framework** și este coloana vertebrală a ASP.NET Core, deci înțelegerea ei este esențială pentru orice dezvoltare modernă de aplicații C#. Containerul DI încorporat al framework-ului construiește automat clasele și injectează dependențele acestora (rezolvând întregul grafic de dependență), deci înregistrezi servicii și lași containerul să conecteze totul împreună în loc să instanțiezi manual dependențele. Beneficiile principale sunt semnificative și centrale pentru motivul pentru care DI este evidențiat: **cuplaj slab** (depinzând de interfețe mai degrabă decât de clase concrete, deci implementările pot fi schimbate) și mai ales **testabilitate** (injectând implementări mock în teste în loc de dependențe reale precum baze de date sau servicii de email — făcând testarea unitară temeinică practică). Înțelegerea modului de înregistrare a serviciilor (mapând interfețe la implementări), injectarea prin constructor (modelul standard) și — importantă — **duratele de viață ale serviciilor** (`Singleton`, `Scoped`, `Transient`) este esențială: alegerea unei durate de viață greșite determină erori subtile, greu de debutat (de ex. un singleton care deține un `DbContext` scoped, sau probleme de thread-safety cu singletonuri partajate), deci înțelegerea când se aplică fiecare durată de viață (Scoped per-cerere pentru lucruri cum ar fi DbContext, Singleton pentru serviciile stateless partajate, Transient pentru cele ușoare) este critică. Din moment ce DI este încorporat în .NET, stă la baza arhitecturii ASP.NET Core și este cheia pentru a scrie cod slab cuplat și ușor de testat, stăpânirea ei — containerul, injectarea prin constructor, designul bazat pe interfețe și mai ales duratele de viață ale serviciilor — este cunoaștere seniori importantă și frecvent aplicată pentru a construi aplicații C# moderne ușor de menținut și testat, și un subiect comun în interviuri.