Dependency Injection na yadda ya aiki a .NET?

Question

Accepted Answer

**Dependency Injection (DI)** yana gina wajen .NET na zamani — framework ɗin ya ɗauki wani container na DI wanda zai gina ajiyoyi a kai da sa **shi da zomawar sa**. Kaka rubuta ayyukan (yunƙuri zuwa aiwatarwa) kuma container din zai warware su, yana baiwa arziki na loshshi-maimakon da ake buƙata, aiki ne na asali ga ASP.NET Core. ## Rubuta ayyukan ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` Ka rubuta kowane aiki a taron wani **interface zuwa aiwatarwa** tare da lokaci na baliyo. Sannan duk wanda zai dogara kan interface din zai sami aiwatarwar da aka rubuta. ## Constructor injection (tsarin da aka saba) ```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 ``` Zomawar ayyukan za a bayyana a matsayin parameters na constructor (da aka yi jiya a matsayin interfaces); container din zai gina ajiya din kuma zai share zomawar ayyukan da aka rubuta, yana warware whole dependency graph a kai. ## Service lifetimes (mahimman a zaba da daidai) ```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. ``` ## Bennaye: loshshi-maimakon da ake buƙata da buƙatun a bincike ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## Me ya saba Dependency injection ƙaƙƙarfa ƙaƙƙarfa ce ga .NET na zamani — yana **gina wajen framework** kuma shine gida na ASP.NET Core, don haka fahim-fahim shi ƙaƙƙarfa ne ga duk wani halin C# na zamani. Built-in na framework container din zai gina ajiyoyi a kai da share su da zomawar ayyukan sa (yana warware whole dependency graph), saboda haka ka rubuta ayyukan kuma bari container din yatsar da duk abu mahimmanci a taushi maimakon ka gina zomawar ayyukan da kai. Bennaye na asali suna da mahimmi sosai kuma suna da mahimmi ga me ya saba DI: **loshshi-maimakon** (dogara kan interfaces maimakon concrete classes, don aiwatarwa za a iya canja) kuma musamman **testing** (share mock implementations a cikin tests maimakon tunani na gida kamar databases ko ayyukan email — wanda zai sami unit testing da kyau). Faham yadda za a rubuta ayyukan (yunƙuri zuwa aiwatarwa), constructor injection (tsarin da aka saba), kuma — mahimman — **service lifetimes** (`Singleton`, `Scoped`, `Transient`) yana da mahimmi sosai: zabar-zabar timeouts na abubuwan ba daidai ba ya ƙarɗa savvy-savvy, da aka danna bugs (misali singletonin da zai riƙe scoped `DbContext`, ko thread-safety abubuwan marasa tsare singletons), saboda haka faham lokacin kowane lifetime ya kamata (Scoped per-request don abubuwa kamar DbContext, Singleton don ayyukan marasa state, Transient don masu karfi) yana da muhimmanci. Domin DI yana gina wajen .NET, yana gida na ASP.NET Core's architecture, kuma yana maɓalli-maɓalli zuwa rubuta loshshi-maimakon, buƙatun a bincike, kasua duk haka — master shi — container din, constructor injection, interface-based design, kuma musamman service lifetimes — yana mahimmi, ana amfani da shi a tsare akan gida na baiwa, testable modern C# applications, kuma wani wadataccen bincike jabbar.