Come funziona l'iniezione di dipendenze in .NET?

Question

IT Interview Practice · Accepted Answer

**Dependency Injection (DI)** è integrata in .NET moderno — il framework include un contenitore DI che costruisce automaticamente le classi e **inietta le loro dipendenze**. Registri i servizi (mappando interfacce a implementazioni) e il contenitore le risolve, abilitando codice debolmente accoppiato e testabile. È fondamentale per ASP.NET Core. ## Registrazione dei servizi ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` Registri ogni mappatura di servizio collegando un'**interfaccia a un'implementazione** con una durata di vita. Quindi tutto ciò che dipende dall'interfaccia riceve l'implementazione registrata. ## Iniezione nel costruttore (il pattern 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 ``` Le dipendenze sono dichiarate come parametri del costruttore (tipizzate come interfacce); il contenitore costruisce la classe e inietta le implementazioni registrate, risolvendo automaticamente l'intero grafo delle dipendenze. ## Durate dei servizi (importante sceglierne una corretta) ```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. ``` ## I vantaggi: accoppiamento loose e testabilità ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## Perché è importante L'iniezione di dipendenze è fondamentale per .NET moderno — è **integrata nel framework** ed è la spina dorsale di ASP.NET Core, quindi comprenderla è essenziale per qualsiasi sviluppo moderno di applicazioni C#. Il contenitore DI integrato del framework costruisce automaticamente le classi e inietta le loro dipendenze (risolvendo l'intero grafo delle dipendenze), quindi registri i servizi e lasci che il contenitore colleghi tutto insieme piuttosto che istanziare manualmente le dipendenze. I vantaggi fondamentali sono significativi e centrali al motivo per cui DI è enfatizzata: **accoppiamento loose** (dipendere da interfacce anziché da classi concrete, quindi le implementazioni possono essere scambiate) e soprattutto **testabilità** (iniettare implementazioni mock nei test invece di dipendenze reali come database o servizi email — rendendo i unit test approfonditi pratici). Comprendere come registrare i servizi (mappando interfacce a implementazioni), iniezione nel costruttore (il pattern standard), e — importantemente — le **durate dei servizi** (`Singleton`, `Scoped`, `Transient`) è essenziale: scegliere una durata sbagliata causa bug sottili e difficili da debuggare (ad esempio un singleton che contiene un `DbContext` scoped, o problemi di thread-safety con singleton condivisi), quindi comprendere quando applica ogni durata (Scoped per-richiesta per cose come DbContext, Singleton per servizi condivisi stateless, Transient per quelli leggeri) è critico. Poiché DI è integrata in .NET, sottende l'architettura di ASP.NET Core, ed è la chiave per scrivere codice debolmente accoppiato e testabile, padroneggiare — il contenitore, iniezione nel costruttore, design basato su interfacce, e soprattutto le durate dei servizi — è importante, conoscenza applicata frequentemente a livello senior per costruire applicazioni C# moderne manutenibili e testabili, ed è un argomento frequente nei colloqui.

Registrazione dei servizi

Iniezione nel costruttore (il pattern standard)

Durate dei servizi (importante sceglierne una corretta)

I vantaggi: accoppiamento loose e testabilità

Perché è importante

Domande correlate