Dependency Injection .NET లో ఎలా పనిచేస్తుంది?

Question

Accepted Answer

**Dependency Injection (DI)** ఆధુनిక .NET లో నిర్మితమైనది — ఫ్రేమ్‌వర్క్ DI కంటైనర్‌ను కలిగి ఉంది, ఇది క్లాస్‌లను స్వయంచాలకంగా నిర్మించి **వాటి డిపెండెన్సీలను ఇంజెక్ట్ చేస్తుంది**. మీరు సేవలను నమోదు చేస్తారు (interfaces లను implementations కు మ్యాపింగ్ చేస్తారు) మరియు కంటైనర్ వాటిని పరిష్కరిస్తుంది, loosely-coupled, testable కోడ్ ను ఎనేబల్ చేస్తుంది. ఇది ASP.NET Core కు ఆధారం. ## సేవలను నమోదు చేయడం ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` మీరు ప్రతి సేవ మ్యాపింగ్‌ను **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 ``` డిపెండెన్సీలు constructor పారామిటర్‌లుగా ప్రకటించబడతాయి (interfaces గా టైప్ చేయబడతాయి); కంటైనర్ క్లాస్‌ను నిర్మించి, నమోదు చేసిన implementations ను ఇంజెక్ట్ చేస్తుంది, మొత్తం డిపెండెన్సీ గ్రాఫ్‌ను స్వయంచాలకంగా సమాధానం చేస్తుంది. ## సేవ 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# అప్లికేషన్ డెవలప్‌మెంట్ కు దీన్ని అర్థం చేసుకోవడం అవసరం. ఫ్రేమ్‌వర్క్ నిర్మిత DI కంటైనర్ క్లాస్‌లను స్వయంచాలకంగా నిర్మించి, వాటి డిపెండెన్సీలను ఇంజెక్ట్ చేస్తుంది (మొత్తం డిపెండెన్సీ గ్రాఫ్‌ను సమాధానం చేస్తుంది), కాబట్టి మీరు సేవలను నమోదు చేస్తారు మరియు కంటైనర్ ప్రతిదీ సరిపోల్చనివ్వండి బదులుగా manually డిపెండెన్సీలను ఇన్‌స్టాంషియేట్ చేయడం. ప్రధాన ఉపయోగాలు ముఖ్యమైనవి మరియు DI ఎందుకు నొక్కుతారు అనే కేంద్రీయమైనవి: **loose coupling** (concrete క్లాసుల కంటే interfaces పై ఆధారపడటం, కాబట్టి implementations స్వాప్ చేయబడతాయి) మరియు ప్రత్యేకంగా **testability** (tests లో real databases లేదా email సేవలు వంటి నిజమైన డిపెండెన్సీల బదులుగా mock implementations ను ఇంజెక్ట్ చేయడం — thorough unit testing ను ఆచరణీయం చేస్తుంది). సేవలను నమోదు చేయడం ఎలా (interfaces లను implementations కు మ్యాపింగ్ చేయడం), constructor injection (ప్రామాణిక నమూనా), మరియు — ముఖ్యంగా — **సేవ lifetimes** (`Singleton`, `Scoped`, `Transient`) అర్థం చేసుకోవడం ముఖ్యం: తప్పు lifetime ఎంచుకోవడం సూక్ష్ములాలను, హార్డ్-టు-డీబగ్ బగ్‌లను కలిగిస్తుంది (ఉదా. singleton scoped `DbContext` ను పట్టుకుంది, లేదా shared singletons తో thread-safety సమస్యలు), కాబట్టి ప్రతి lifetime ఎప్పుడు వర్తిస్తుంది అర్థం చేసుకోవడం (Scoped per-request DbContext వంటి విషయాల కోసం, Singleton shared stateless సేవల కోసం, Transient lightweight వాటి కోసం) క్లిష్టమైనది. DI .NET లో నిర్మితమైనది, ASP.NET Core యొక్క ఆర్కిటెక్చర్‌ను అండర్‌పిన్‌లు చేస్తుంది, మరియు loosely-coupled, testable కోడ్ రాయడానికి కీ, కంటైనర్‌ను మాస్టర్ చేయడం, constructor injection, interface-based డిజైన్, మరియు ప్రత్యేకంగా సేవ lifetimes — ముఖ్యమైనది, తరచుగా-వర్తించిన సీనియర్ జ్ఞానం maintainable, testable ఆధునిక C# అప్లికేషన్‌లను నిర్మించడానికి, మరియు సాధారణ ఇంటర్‌వ్యూ విషయం.