SOLID-Prinzipien in C#: Theorie und Praxis mit Beispielen

SOLID-Prinzipien in C#: Theorie und Praxis

SOLID ist ein Akronym für fünf grundlegende Prinzipien der objektorientierten Programmierung und des Designs, die von Robert C. Martin (Onkel Bob) formuliert wurden. Diese Prinzipien helfen Entwicklern, flexiblen, wartbaren und skalierbaren Code zu erstellen. In diesem Artikel werden wir jedes SOLID-Prinzip in C# mit konkreten Codebeispielen durchgehen.

1. Single Responsibility Principle (SRP) — Prinzip der einzigen Verantwortung

Theorie: Jede Klasse sollte nur einen Grund für eine Änderung haben. Mit anderen Worten, die Klasse sollte für eine klar definierte Aufgabe verantwortlich sein.

Praxis in C#: Betrachten wir ein Beispiel für die Verletzung des SRP und dessen Korrektur.

Verletzung des SRP:

public class OrderService{    public void CreateOrder(Order order)    {        // Logik zur Auftragserstellung        Console.WriteLine("Auftrag erstellt");                // Logik zum E-Mail-Versand        SendEmail("order@example.com", "Neuer Auftrag");                // Logik zur Protokollierung        File.WriteAllText("log.txt", "Auftrag erstellt");    }}

Die Klasse OrderService ist für drei verschiedene Aufgaben verantwortlich: Auftragserstellung, E-Mail-Versand und Protokollierung. Dies verletzt das SRP.

Korrektur unter Einhaltung des SRP:

public class OrderService{    private readonly IEmailService _emailService;    private readonly ILogger _logger;        public OrderService(IEmailService emailService, ILogger logger)    {        _emailService = emailService;        _logger = logger;    }        public void CreateOrder(Order order)    {        // Logik zur Auftragserstellung        Console.WriteLine("Auftrag erstellt");                _emailService.SendEmail("order@example.com", "Neuer Auftrag");        _logger.Log("Auftrag erstellt");    }}

public interface IEmailService{    void SendEmail(string to, string message);}

public class EmailService : IEmailService{    public void SendEmail(string to, string message)    {        Console.WriteLine($"E-Mail gesendet an {to}");    }}

public interface ILogger{    void Log(string message);}

public class FileLogger : ILogger{    public void Log(string message)    {        File.WriteAllText("log.txt", message);    }}

Jetzt ist jede Klasse nur für ihre eigene Aufgabe verantwortlich: OrderService für die Auftragsverwaltung, EmailService für den E-Mail-Versand, FileLogger für die Protokollierung.

2. Open-Closed Principle (OCP) — Prinzip der Offenheit/Geschlossenheit

Theorie: Softwareentitäten (Klassen, Module, Funktionen) sollten für Erweiterungen offen, aber für Modifikationen geschlossen sein.

Praxis in C#: Wir verwenden Vererbung und Schnittstellen, um die Funktionalität zu erweitern, ohne vorhandenen Code zu ändern.

Verletzung des OCP:

public class PaymentProcessor{    public void ProcessPayment(string paymentType, decimal amount)    {        if (paymentType == "CreditCard")        {            // Verarbeitung der Kreditkarte        }        else if (paymentType == "PayPal")        {            // Verarbeitung von PayPal        }        // Hinzufügen eines neuen Typs erfordert eine Änderung der Klasse    }}

Korrektur unter Einhaltung des OCP:

public interface IPaymentMethod{    void Process(decimal amount);}

public class CreditCardPayment : IPaymentMethod{    public void Process(decimal amount)    {        Console.WriteLine($"Verarbeitung der Kreditkarte: {amount}");    }}

public class PayPalPayment : IPaymentMethod{    public void Process(decimal amount)    {        Console.WriteLine($"Verarbeitung von PayPal: {amount}");    }}

public class PaymentProcessor{    public void ProcessPayment(IPaymentMethod paymentMethod, decimal amount)    {        payment
```