Kif taħdem dependency injection f'.NET?

Question

Accepted Answer

**Dependency Injection (DI)** hija integrata fil-modern .NET — il-framework jinkludi kontenitur DI li awtomatikament jibni klassiz u **jinjetta d-dipendenzji tagħhom**. Tirreġistra servizzi (mapping interfaces għal implementazzjonijiet) u l-kontenitur jirrisolviha, li jippermetti kod li jkun loosely-coupled u testable. Din hija fundamentali għal ASP.NET Core. ## Irriġistrazzjoni tal-servizzi ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` Tirreġistra kull mapping ta' servizz **interface għal implementazzjoni** b'lifetime. Imbagħad kull ħaġa li tiddipendi fuq l-interface tikseb l-implementazzjoni rreġistrata. ## Constructor injection (il-mudell 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 ``` Id-dipendenzji huma ddikjarati bħala parametri tal-konstrutttur (ttipizzati bħala interfaces); il-kontenitur jibni l-klassi u jinjetta l-implementazzjonijiet rreġistrati, jirrisolvi l-graf ta' dipendenzji kollu awtomatikament. ## Service lifetimes (importanti biex tagħżel b'mod korrett) ```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. ``` ## Il-benefiċċji: loose coupling u testability ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## Għaliex hija importanti Dependency injection hija fundamentali għall-modern .NET — hija **integrata fil-framework** u hija l-backbone ta' ASP.NET Core, għalhekk il-fehim tagħha hu essenzjali għal kwalunkwe sviluppi ta' applikazzjoni C# moderna. Il-kontenitur DI integrat tal-framework awtomatikament jibni klassiz u jinjetta d-dipendenzji tagħhom (jirrisolvi l-graf ta' dipendenzji kollu), għalhekk tirreġistra servizzi u tħalli l-kontenitur jdawwel kull ħaġa flok li manwalment tikkonkretizza d-dipendenzji. Il-benefiċċji bażiċi huma sinifikanti u ċentrali għaliex DI hija enfasizzata: **loose coupling** (tiddipendi fuq interfaces aktar minn klassiz konkreti, allura l-implementazzjonijiet jistgħu jitbidlu) u speċjalment **testability** (jinjetta implementazzjoniji mock fit-testit minflok dipendenzji reali bħal databases jew servizzi tal-email — jagħmel unit testing esaustiv pratiku). Il-fehim kif tirreġistra servizzi (mapping interfaces għal implementazzjonijiet), constructor injection (il-mudell standard), u — importantement — is-**service lifetimes** (`Singleton`, `Scoped`, `Transient`) hu essenzjali: l-għażla tal-lifetime ħażin tikkawża bugs sottili u diffiċli biex jiġu ddebuggjati (eż. singleton li żomm `DbContext` scoped, jew issues ta' thread-safety ma' singletons maqsuma), għalhekk il-fehim meta kull lifetime japplika (Scoped per-request għal affarijiet bħal DbContext, Singleton għal servizzi maqsuma stateless, Transient għal leġen lightweight) hu kritiku. Mindakin DI hija integrata f'.NET, suporta l-arkitettura ta' ASP.NET Core, u hija l-ċavetta biex tikteb kod loosely-coupled u testable, il-master tagħha — il-kontenitur, constructor injection, interface-based design, u speċjalment is-service lifetimes — hu importanti, għarfien senjur li spiss jiġi applikat għall-bini ta' applikazzjoniji C# moderna maintainable u testable, u suġġett ta' intervista komuni.