Dependency Injection in C#: Ein einfacher Leitfaden für Anfänger

Dependency Injection in C#: Ein einfacher Leitfaden für Anfänger

Dependency Injection (DI) ist eines der wichtigsten Entwurfsmuster in der modernen Entwicklung mit C# und .NET. Wenn Sie gerade erst mit dem Programmieren beginnen, mag der Begriff kompliziert erscheinen, aber in Wirklichkeit ist alles viel einfacher. In diesem Artikel werden wir erklären, was Dependency Injection ist, warum sie benötigt wird und wie man sie in der Praxis einsetzt.

Was ist Dependency Injection in einfachen Worten?

Stellen Sie sich vor, Sie bauen einen Computer zusammen. Sie können ein fertiges Gehäuse kaufen, in dem alles fest verlötet und nicht austauschbar ist. Oder Sie können ihn aus einzelnen Komponenten zusammenbauen: Prozessor, Grafikkarte, Arbeitsspeicher. Der zweite Ansatz ist viel flexibler – Sie können die Grafikkarte leicht gegen eine leistungsstärkere austauschen oder einen weiteren Riegel Arbeitsspeicher hinzufügen.

Dependency Injection funktioniert nach dem gleichen Prinzip. Anstatt Abhängigkeiten fest in eine Klasse "einzulöten" (Objekte direkt im Code zu erstellen), "injizieren" Sie sie von außen. Das macht Ihren Code flexibel, testbar und leicht wartbar.

Betrachten wir ein schlechtes Beispiel ohne DI:

public class EmailService{    private SmtpClient _client;        public EmailService()    {        // Feste Kopplung – die Klasse erstellt die Abhängigkeit selbst        _client = new SmtpClient("smtp.example.com", 587);    }        public void Send(string to, string message)    {        _client.Send(to, message);    }}

Nun das gleiche Beispiel mit DI:

public class EmailService{    private readonly ISmtpClient _client;        // Die Abhängigkeit wird über den Konstruktor injiziert    public EmailService(ISmtpClient client)    {        _client = client;    }        public void Send(string to, string message)    {        _client.Send(to, message);    }}

Der Unterschied ist offensichtlich: Im zweiten Fall arbeiten wir über das Interface ISmtpClient und die konkrete Implementierung wird von außen übergeben.

Die wichtigsten Methoden der Abhängigkeitsinjektion in C#

In C# gibt es drei Hauptmethoden zur Implementierung von DI. Betrachten wir jede davon.

1. Injektion über den Konstruktor

Dies ist die gängigste und empfohlene Methode. Abhängigkeiten werden über die Parameter des Konstruktors übergeben und in privaten Feldern gespeichert.

public class OrderService{    private readonly IEmailService _emailService;    private readonly ILogger _logger;        public OrderService(IEmailService emailService, ILogger logger)    {        _emailService = emailService;        _logger = logger;    }        public void ProcessOrder(Order order)    {        _logger.Log("Auftragsverarbeitung gestartet");        _emailService.Send(order.CustomerEmail, "Ihr Auftrag wurde angenommen");        _logger.Log("Auftragsverarbeitung abgeschlossen");    }}

2. Injektion über eine Eigenschaft

Die Abhängigkeit wird über eine öffentliche Eigenschaft gesetzt. Diese Methode ist praktisch, wenn die Abhängigkeit optional ist.

public class ReportGenerator{    public ILogger Logger { get; set; }        public void GenerateReport()    {        Logger?.Log("Bericht wird generiert...");        // Logik zur Generierung    }}

3. Injektion über eine Methode

Die Abhängigkeit wird direkt an die Methode übergeben, in der sie benötigt wird. Dies wird normalerweise selten verwendet, kann aber in bestimmten Szenarien nützlich sein.

public class DataProcessor{    public void ProcessData(string data, IValidator validator)    {        if (validator.Validate(data))        {            // Datenverarbeitung        }    }}

Praktisches Beispiel: Von schlechtem zu gutem Code

Schauen wir uns an, wie DI echten Code verbessern kann. Angenommen, wir haben eine Klasse für die Arbeit mit einer Datenbank.

Schlechter Code (ohne DI):

public class UserRepository{    private SqlConnect