Conas a oibríonn Dependency Injection i .NET?

Question

Accepted Answer

**Dependency Injection (DI)** tógtha isteach i .NET nua-aimseartha — cuimsíonn an fhramwork coimeádán DI atá ag tógáil ranganna go huathoibríoch agus **ag instealladh a spleáchais**. Clárú a dhéanann tú seirbhísí (mapáil comhéadain go cur i bhfeidhm) agus réiteann an coimeádán iad, agus sin a bhaineann le cód scaoilte go fúarchúiseach agus sofhianáilte. Tá sé bunúsach do ASP.NET Core. ## Seirbhísí a chlárú ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` Clárúsíonn tú gach mapáil seirbhíse ag socrú comhéadain ar **dhul i bhfeidhm** le saolré. Ansin faigheann aon rud a bhraithíonn ar an chomhéadan an cur i bhfeidhm cláraithe. ## Instealladh tógálach (an patrún caighdeánach) ```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 ``` Dearbhaítear spleáchais mar phararóiméadair tógálaigh (clóscríofa mar chomhéadain); tógann an coimeádán an rang agus instealladh a dhéanann sé an cur i bhfeidhm cláraithe, ag réiteach an ghraif spleáchais iomlán go huathoibríoch. ## Saolré seirbhíse (tábhachtach a roghnú i gceart) ```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. ``` ## Na buntáistí: dímhaoiniú lag agus sofhianáilteacht ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## Cén fáth a bhfuil sé tábhachtach Tá dependency injection bunúsach do .NET nua-aimseartha — **tógtha isteach san fhramwork** atá ann agus is cnámh dromchla ASP.NET Core atá ann, mar sin tá tuiscint air riachtanach d'fhorbairt aon fheidhmchlár C# nua-aimseartha. Tógann coimeádán DI tógtha isteach san fhramwork ranganna go huathoibríoch agus instealladh a dhéanann sé a spleáchais (ag réiteach an ghraif spleáchais ar fad), mar sin clárú a dhéanann tú seirbhísí agus ligeann tú don choimeádán gach rud a nascadh le chéile seachas spleáchais a bhogadh go láimhe. Tá na príomhbhuntáistí suntasach agus lárnach cén fáth a ndeir daoine breis ar DI: **dímhaoiniú lag** (ag brath ar chomhéadain seachas ranganna nithiúla, ionas gur féidir feidhmchur a athrú) agus go háirithe **sofhianáilteacht** (ag instealladh fealsamh cur i bhfeidhm i dtrialacha in ionad spleáchais dhomhanda cosúil le bunachair dhonnta nó seirbhísí ríomhphoist — a dhéanamh triail aonaid iomlán praiticiúil). Tá tuiscint ar seirbhísí a chlárú (comhéadain a mhapáil ar chur i bhfeidhm), instealladh tógálaigh (an patrún caighdeánach), agus — ar an tábhacht — **saolré na seirbhíse** (`Singleton`, `Scoped`, `Transient`) riachtanach: bascadh ar an saolré mícheart is cúis le fabhtanna caolchúiseacha, deacair a dhífhabhraigh (m.sh. singleton a bhraithíonn ar `DbContext` scóipeach, nó saincheisteanna sábháilteachta snáithe le singletons comhroinnte), mar sin tá tuiscint ar cathain a ghabhann gach saolré i bhfeidhm (Scoped in aghaidh an iarratais ar nithe cosúil le DbContext, Singleton ar seirbhísí neamhbhríoch comhroinnte, Transient ar chinn foluain) ríthábhachtach. Ar bharr go bhfuil DI tógtha isteach sa .NET, ag fónamh do lonrú ailtireachta ASP.NET Core, agus is é an eochair a bhí ann do chód scaoilte go fúarchúiseach agus sofhianáilte a scríobh, is tábhachtach duit a oibriú ar bharr cumhachta — an coimeádán, instealladh tógálaigh, dearadh bunaithe ar chomhéadain, agus go háirithe an saolré seirbhíse — ní ionann eolas inúsáidte sinsearach atá úsáideach agus coitianta chun feidhmchláir chothromaithe, sofhianáilte C# nua-aimseartha a thógáil, agus is ábhar coitianta agallamh a bhí ann.