Dependency injection .NET मध्ये कसे कार्य करते?

Question

Accepted Answer

**Dependency Injection (DI)** आधुनिक .NET मध्ये अंतर्निर्मित आहे — फ्रेमवर्कमध्ये एक DI container समाविष्ट आहे जो स्वयंचलितपणे classes तयार करतो आणि **त्यांच्या dependencies inject करतो**. आप services नोंदणी करता (interfaces ला implementations शी मॅप करून) आणि container त्यांना resolve करतो, loosely-coupled, testable code सक्षम करतो. हे ASP.NET Core साठी मूलभूत आहे. ## Services नोंदणी करणे ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` आप प्रत्येक service मॅपिंग एक **interface ला implementation सह** एक lifetime सह नोंदणी करता. मग interface वर अवलंबून असलेले काहीही नोंदलेले 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 तयार करतो आणि नोंदलेले 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 साठी मूलभूत आहे — हे **फ्रेमवर्कमध्ये अंतर्निर्मित** आहे आणि ASP.NET Core चाचणी आहे, त्यामुळे समजून घेणे कोणत्याही आधुनिक C# application development साठी आवश्यक आहे. फ्रेमवर्कचा अंतर्निर्मित DI container स्वयंचलितपणे classes तयार करतो आणि त्यांच्या dependencies inject करतो (संपूर्ण dependency graph resolve करतो), त्यामुळे आप services नोंदणी करता आणि container सर्वकाही एकत्र करण्याची परवानगी देता, dependencies स्वचलितपणे तयार करण्याऐवजी. मुख्य फायदे महत्त्वपूर्ण आणि केंद्रीय आहेत की DI का जोर दिला जातो: **loose coupling** (concrete classes ऐवजी interfaces वर अवलंबून, त्यामुळे implementations स्वॅप केल्या जाऊ शकतात) आणि विशेषतः **testability** (tests मध्ये databases किंवा email services सारख्या खर्‍या dependencies ऐवजी mock implementations inject करून — comprehensive unit testing व्यावहारिक करून). Services नोंदणी (interfaces ला implementations सह मॅप करणे), constructor injection (मानक पद्धत), आणि — महत्वाचे म्हणून — **service lifetimes** (`Singleton`, `Scoped`, `Transient`) कसे कार्य करते हे समजून घेणे आवश्यक आहे: चुकीचे lifetime निवडणे सूक्ष्म, डीबग करण्यास कठीण bugs कारण करते (उदाहरणार्थ एक singleton scoped `DbContext` धरून, किंवा shared singletons सह thread-safety issues), त्यामुळे केव्हा प्रत्येक lifetime लागू होते हे समजून घेणे (Scoped per-request DbContext सारख्या गोष्टींसाठी, Singleton shared stateless services साठी, Transient lightweight ones साठी) गंभीर आहे. कारण DI .NET मध्ये अंतर्निर्मित आहे, ASP.NET Core च्या आर्किटेक्चरला समर्थन देतो, आणि loosely-coupled, testable code लिहिण्याचा मुख्य मार्ग आहे, त्यात प्रभुत्व मिळवणे — container, constructor injection, interface-based design, आणि विशेषतः service lifetimes — maintainable, testable आधुनिक C# applications तयार करण्यासाठी महत्वपूर्ण, वारंवार-लागू senior knowledge आहे, आणि एक सामान्य interview विषय आहे.