,.NET இல் dependency injection எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

**Dependency Injection (DI)** என்பது நவீன .NET இல் உள்ளமைக்கப்பட்டுள்ளது — framework ஆனது தானாகவே classes ஐ construct செய்து **அவற்றின் dependencies ஐ inject** செய்கிற ஒரு DI container ஐ உள்ளடக்கியுள்ளது. நீங்கள் services ஐ register செய்கிறீர்கள் (interfaces ஐ implementations க்கு map செய்தல்) மற்றும் container அவற்றை resolve செய்கிறது, loosely-coupled, testable code ஐ enable செய்கிறது. இது 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 mapping ஐ **interface ஐ implementation க்கு** lifetime உடன் register செய்கிறீர்கள். பின்னர் interface ஐ சார்ந்து இருக்கும் எதையும் registered 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 ஆக declare செய்யப்படுகிறது (interfaces ஆக type செய்யப்பட்ட); container class ஐ construct செய்து 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 இல் உள்ளமைக்கப்பட்டுள்ளது** மற்றும் ASP.NET Core ன் backbone ஆகும், எனவே இதை புரிந்துகொள்ள வேண்டியது எந்த நவீன C# application development க்கும் அপরிहार்யமாக உள்ளது. Framework ன் உள்ளமைக்கப்பட்ட DI container தானாகவே classes ஐ construct செய்து அவற்றின் dependencies ஐ inject செய்கிறது (முழு dependency graph ஐ resolve செய்து), எனவே நீங்கள் services ஐ register செய்து container ஐ எல்லாவற்றையும் wire செய்ய விடுகிறீர்கள் dependencies ஐ manually instantiate செய்வதற்கு பதிலாக. Major நன்மைகள் குறிப்பிடத்தக்கவை மற்றும் DI ஏன் emphasis செய்யப்படுகிறது என்பதற்கு மையமாக உள்ளது: **loose coupling** (concrete classes ஐ விட interfaces ஐ சார்ந்து இருத்தல், எனவே implementations ஐ swap செய்யலாம்) மற்றும் குறிப்பாக **testability** (tests இல் real dependencies போல் databases அல்லது email services க்கு பதிலாக mock implementations ஐ inject செய்தல் — thorough unit testing ஐ practical செய்தல்). Services ஐ register செய்வது (interfaces ஐ implementations க்கு map செய்தல்), constructor injection (standard pattern), மற்றும் — முக்கியமாக — **service lifetimes** (`Singleton`, `Scoped`, `Transient`) ஐ புரிந்துகொள்ள வேண்டியது அপরிहार்யமாக உள்ளது: தவறான lifetime ஐ தேர்வு செய்வது subtle, hard-to-debug bugs ஐ cause செய்கிறது (எ.கா. ஒரு singleton ஒரு scoped `DbContext` ஐ holding செய்தல், அல்லது shared singletons உடன் thread-safety issues), எனவே ஒவ்வொரு lifetime எப்போது apply செய்யப்படுகிறது என்பதை புரிந்துகொள்ள வேண்டியது critical ஆகும் (Scoped per-request DbContext போன்ற விஷயங்களுக்கு, Singleton shared stateless services க்கு, Transient lightweight ones க்கு). DI .NET இல் உள்ளமைக்கப்பட்டுள்ளது என்பதால், ASP.NET Core ன் architecture ஐ underpins செய்கிறது, மற்றும் loosely-coupled, testable code ஐ எழுத வேண்டியதற்கான key ஆகும், mastering அது — container, constructor injection, interface-based design, மற்றும் குறிப்பாக service lifetimes — maintainable, testable நவீன C# applications ஐ build செய்வதற்கு important, frequently-applied senior knowledge ஆக உள்ளது, மற்றும் ஒரு common interview topic ஆகும்.