Wie funktioniert Dependency Injection in .NET?

Question

Accepted Answer

**Dependency Injection (DI)** ist in modernem .NET integriert — das Framework enthält einen DI-Container, der Klassen automatisch konstruiert und **ihre Abhängigkeiten injiziert**. Sie registrieren Services (Mapping von Interfaces zu Implementierungen) und der Container löst sie auf, was zu lose gekoppeltem, testbarem Code führt. Es ist grundlegend für ASP.NET Core. ## Services registrieren ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` Sie registrieren jedes Service-Mapping, das ein **Interface auf eine Implementierung** mit einer Lebensdauer abbildet. Dann erhält alles, das vom Interface abhängt, die registrierte Implementierung. ## Constructor Injection (das 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 ``` Abhängigkeiten werden als Constructor-Parameter deklariert (typisiert als Interfaces); der Container konstruiert die Klasse und injiziert die registrierten Implementierungen, wobei der gesamte Dependency Graph automatisch aufgelöst wird. ## Service Lifetimes (wichtig, richtig zu wählen) ```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. ``` ## Die Vorteile: lose Kopplung und Testbarkeit ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## Warum es wichtig ist Dependency Injection ist grundlegend für modernes .NET — es ist **in das Framework integriert** und ist das Rückgrat von ASP.NET Core, daher ist das Verständnis dafür essentiell für jede moderne C#-Anwendungsentwicklung. Der integrierte DI-Container des Frameworks konstruiert Klassen automatisch und injiziert ihre Abhängigkeiten (wobei der gesamte Dependency Graph aufgelöst wird), daher registrieren Sie Services und lassen den Container alles zusammenfügen, anstatt Abhängigkeiten manuell zu instanziieren. Die Kernvorteile sind erheblich und zentral dafür, warum DI betont wird: **lose Kopplung** (Abhängigkeit von Interfaces statt konkreten Klassen, sodass Implementierungen ausgetauscht werden können) und besonders **Testbarkeit** (Injizieren von Mock-Implementierungen in Tests statt echter Abhängigkeiten wie Datenbanken oder E-Mail-Services — was gründliches Unit Testing praktisch macht). Zu verstehen, wie man Services registriert (Mapping von Interfaces zu Implementierungen), Constructor Injection (das Standard-Pattern) und — wichtig — die **Service Lifetimes** (`Singleton`, `Scoped`, `Transient`) ist essentiell: die falsche Lifetime zu wählen führt zu subtilen, schwer zu debuggenden Fehlern (z. B. ein Singleton, das einen Scoped `DbContext` hält, oder Thread-Safety-Probleme mit gemeinsamen Singletons), daher ist zu verstehen, wann jede Lifetime anwendbar ist (Scoped pro Request für Dinge wie DbContext, Singleton für gemeinsame zustandslose Services, Transient für leichte), kritisch. Da DI in .NET integriert ist, die Architektur von ASP.NET Core unterstützt und der Schlüssel zum Schreiben von lose gekoppeltem, testbarem Code ist, ist das Beherrschen davon — der Container, Constructor Injection, Interface-basiertes Design und besonders die Service Lifetimes — wichtiges, häufig angewendetes Senior-Wissen zum Erstellen wartbarer, testbarer moderner C#-Anwendungen und ein häufiges Interview-Thema.