Dependency injection .NET માં કેવી રીતે કાર્ય કરે છે?

Question

Accepted Answer

**Dependency Injection (DI)** આધુનિક .NET માં બિલ્ટ-ઈન છે — framework એમાં DI container શામેલ છે જે આપોઆપ classes બનાવે છે અને **તેમના dependencies ઇંજેક્ટ કરે છે**। તમે 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 mapping ને **interface ને implementation સાથે** lifetime સાથે રજિસ્ટર કરો છો। પછી જે કંઈ પણ interface પર આધારિત છે તેને રજિસ્ટર કરેલ implementation મળે છે। ## Constructor injection (standard pattern) ```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 ઇંજેક્ટ કરે છે, આખો 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 માં બિલ્ટ-ઈન છે** અને ASP.NET Core ની backbone છે, તેથી આધુનિક C# application development માટે તેને સમજવું આવશ્યક છે। Framework નું બિલ્ટ-ઈન DI container આપોઆપ classes બનાવે છે અને તેમના dependencies ઇંજેક્ટ કરે છે (આખો dependency graph resolve કરે છે), તેથી તમે services રજિસ્ટર કરો છો અને container ને બધું કનેક્ટ કરવા દો છો بجાય manually dependencies instantiate કરવા કે। મુખ્ય લાભ નોંધપાત્ર અને અતુલ્ય છે કે શા માટે DI પર ભાર આપવામાં આવે છે: **loose coupling** (concrete classes કરતાં interfaces પર આધારિત હોવું, તેથી implementations બદલી શકાય) અને ખાસ કરીને **testability** (tests માં mock implementations ઇંજેક્ટ કરવું real dependencies જેમ databases અથવા email services ને બદલે — thorough unit testing ને practical બનાવે છે)। Services રજિસ્ટર કરવો (interfaces ને implementations સાથે મેપ કરવો), constructor injection (standard pattern), અને — અગત્યપૂર્વક — **service lifetimes** (`Singleton`, `Scoped`, `Transient`) સમજવું આવશ્યક છે: ખોટો lifetime પસંદ કરવાથી સૂક્ષ્મ, debug કરવા માટે મુશ્કેલ bugs થાય છે (દા.ત. singleton જે scoped `DbContext` ધરાવે છે, અથવા shared singletons સાથે thread-safety મુદ્દાઓ), તેથી સમજવું કે પ્રત્યેક lifetime ક્યારે લાગુ પડે છે (Scoped per-request DbContext જેવી વસ્તુઓ માટે, Singleton shared stateless services માટે, Transient lightweight ones માટે) critical છે। DI .NET માં બિલ્ટ-ઈન હોવાથી, ASP.NET Core ની architecture પર આધારિત છે, અને loosely-coupled, testable code લખવાની key છે, તેને master કરવું — container, constructor injection, interface-based design, અને ખાસ કરીને service lifetimes — maintainable, testable આધુનિક C# applications બનાવવા માટે અગત્યપૂર્ણ, વારંવાર-લાગુ પડતું senior knowledge છે, અને ઇન્ટરવ્યુ ના સામાન્ય વિષય છે।