.NET में dependency injection कैसे काम करता है?

Question

Accepted Answer

**Dependency Injection (DI)** आधुनिक .NET में built-in है — framework में एक DI container शामिल है जो स्वचालित रूप से classes का निर्माण करता है और **उनकी dependencies को inject करता है**। आप services को register करते हैं (interfaces को implementations से मैप करते हुए) और container उन्हें resolve करता है, loosely-coupled, testable कोड को सक्षम करते हुए। यह ASP.NET Core के लिए मौलिक है। ## services को register करना ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` आप प्रत्येक service को एक lifetime के साथ **interface को implementation** से मैप करते हुए register करते हैं। फिर interface पर निर्भर कुछ भी registered implementation प्राप्त करता है। ## constructor injection (मानक पैटर्न) ```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 को constructor parameters के रूप में घोषित किया जाता है (interfaces के रूप में typed); container class का निर्माण करता है और registered implementations को inject करता है, पूरे dependency graph को स्वचालित रूप से resolve करते हुए। ## service lifetimes (सही ढंग से चुनना महत्वपूर्ण) ```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. ``` ## लाभ: loose coupling और testability ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## यह क्यों महत्वपूर्ण है dependency injection आधुनिक .NET के लिए मौलिक है — यह **framework में built-in है** और ASP.NET Core की रीढ़ है, इसलिए इसे समझना किसी भी आधुनिक C# application विकास के लिए आवश्यक है। framework का built-in DI container स्वचालित रूप से classes का निर्माण करता है और उनकी dependencies को inject करता है (पूरे dependency graph को resolve करते हुए), इसलिए आप services को register करते हैं और container को सब कुछ wire करने देते हैं बजाय manually dependencies को instantiate करने के। मुख्य लाभ महत्वपूर्ण हैं और इस बात के केंद्र में हैं कि DI पर जोर क्यों दिया जाता है: **loose coupling** (concrete classes के बजाय interfaces पर निर्भर रहना, ताकि implementations को बदला जा सके) और विशेष रूप से **testability** (databases या email services जैसी वास्तविक dependencies के बजाय tests में mock implementations inject करना — पूरी तरह से unit testing को व्यावहारिक बनाते हुए)। यह समझना कि services को कैसे register करें (interfaces को implementations से मैप करना), constructor injection (मानक पैटर्न), और — महत्वपूर्ण रूप से — **service lifetimes** (`Singleton`, `Scoped`, `Transient`) आवश्यक है: गलत lifetime चुनना सूक्ष्म, debug करने में कठिन bugs पैदा करता है (जैसे एक singleton जो एक scoped `DbContext` रखता है, या shared singletons के साथ thread-safety मुद्दे), इसलिए यह समझना कि प्रत्येक lifetime कब लागू होता है (DbContext जैसी चीजों के लिए per-request Scoped, shared stateless services के लिए Singleton, lightweight के लिए Transient) महत्वपूर्ण है। चूंकि DI .NET में built-in है, ASP.NET Core की architecture को रेखांकित करता है, और loosely-coupled, testable कोड लिखने की कुंजी है, इसमें महारत हासिल करना — container, constructor injection, interface-based design, और विशेष रूप से service lifetimes — maintainable, testable आधुनिक C# applications बनाने के लिए महत्वपूर्ण, बारंबार लागू होने वाला senior ज्ञान है, और एक सामान्य interview विषय है।