Dependency injection hufanya kazi vipi katika .NET?

Question

Accepted Answer

**Dependency Injection (DI)** imejengwa ndani ya .NET ya kisasa — framework inajumuisha DI container ambayo huunda classes kiotomatiki na **kuingiza dependencies zao**. Unasajili services (kuoanisha interfaces na implementations) na container huzitatua, ikiwezesha msimbo unaounganishwa kwa urahisi, unaoweza kupimwa. Ni msingi wa ASP.NET Core. ## Kusajili services ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` Unasajili kila service kwa kuoanisha **interface na implementation** ukiwa na lifetime. Kisha chochote kinachotegemea interface hupata implementation iliyosajiliwa. ## Constructor injection (mfumo wa kawaida) ```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 ``` Dependencies hutangazwa kama constructor parameters (zikiwa na aina za interfaces); container huunda class na kuingiza implementations zilizosajiliwa, ikitatua dependency graph nzima kiotomatiki. ## Service lifetimes (muhimu kuchagua kwa usahihi) ```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. ``` ## Faida: loose coupling na testability ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## Kwa nini ni muhimu Dependency injection ni msingi wa .NET ya kisasa — imejengwa **ndani ya framework** na ni uti wa mgongo wa ASP.NET Core, hivyo kuielewa ni jambo la lazima kwa uendelezaji wowote wa programu ya kisasa ya C#. DI container iliyojengwa ndani ya framework huunda classes kiotomatiki na kuingiza dependencies zao (ikitatua dependency graph nzima), hivyo unasajili services na kuruhusu container kuunganisha kila kitu badala ya kuanzisha dependencies kwa mkono. Faida za msingi ni muhimu na kuu kwa sababu DI inasisitizwa: **loose coupling** (kutegemea interfaces badala ya concrete classes, hivyo implementations zinaweza kubadilishwa) na hasa **testability** (kuingiza mock implementations katika tests badala ya dependencies halisi kama databases au email services — kufanya unit testing kamili kuwa ya vitendo). Kuelewa jinsi ya kusajili services (kuoanisha interfaces na implementations), constructor injection (mfumo wa kawaida), na — kwa umuhimu — **service lifetimes** (`Singleton`, `Scoped`, `Transient`) ni jambo la lazima: kuchagua lifetime isiyo sahihi husababisha bugs za hila, ngumu kutatua (mfano singleton inayoshikilia scoped `DbContext`, au matatizo ya thread-safety na shared singletons), hivyo kuelewa wakati kila lifetime inahusika (Scoped per-request kwa vitu kama DbContext, Singleton kwa shared stateless services, Transient kwa zile nyepesi) ni muhimu. Kwa kuwa DI imejengwa ndani ya .NET, inasimamia usanifu wa ASP.NET Core, na ni ufunguo wa kuandika msimbo unaounganishwa kwa urahisi, unaoweza kupimwa, kuibobea — container, constructor injection, muundo wa interface-based, na hasa service lifetimes — ni ujuzi muhimu, unaotumika mara kwa mara wa senior kwa kujenga programu za kisasa za C# zinazoweza kudumishwa, kupimwa, na ni mada ya kawaida ya interview.