Webframeworkk/ASP.NET Core/SOLID-Prinzipien

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).

---

Dieses Tutorial gibt einen umfassenden Überblick über die SOLID-Prinzipien, ein Akronym für fünf grundlegende Entwurfsmuster in der objektorientierten Programmierung. Das Ziel dieser Prinzipien ist es, die Wartbarkeit, Testbarkeit und Flexibilität Ihres Codes zu erhöhen, indem Abhängigkeiten reduziert werden.

---

1. Single Responsibility Principle (SRP) – Einzelverantwortungsprinzip

Definition: Eine Klasse sollte nur einen einzigen Grund haben, sich zu ändern. Jede Klasse sollte nur eine Funktionalität implementieren.

Kernpunkte:

• Vermeiden Sie mehrere, eng gekoppelte Funktionalitäten in einer Klasse.
• Eine Klasse, die Validierungen durchführt, sollte nur für Validierungen zuständig sein und beispielsweise keine Konfigurationsdaten lesen.

Beispiel:

public class ProductService
{
    // Logik für Produkte (Hinzufügen, Abrufen)
}

public class OrderService
{
    // Logik für Bestellungen (Erstellen, Verarbeiten)
}

---

2. Open/Closed Principle (OCP) – Offen/Geschlossen-Prinzip

Definition: Software-Einheiten (Klassen, Module) sollten offen für Erweiterungen, aber geschlossen für Modifikationen sein.

Kernpunkte:

• Behandeln Sie Klassen während der Entwicklung als schreibgeschützt (außer für Fehlerbehebungen).
• Funktionalitätserweiterungen sollten durch neue Klassen (alternative Implementierungen) erfolgen, statt bestehenden Code zu ändern.
• Verhindert neue Bugs in bereits getestetem Code.

Beispiel: Anstatt eine GetPersons() Methode zu ändern, um Sortierung hinzuzufügen, erstellen Sie eine neue Klasse:

public interface IPersonGetter { List<Person> GetPersons(); }

public class PersonGetter : IPersonGetter { 
    public List<Person> GetPersons() { /* Standard Abruf */ } 
}

public class SortedPersonGetter : IPersonGetter { 
    public List<Person> GetPersons() { /* Sortierter Abruf */ } 
}

---

3. Liskov Substitution Principle (LSP) – Liskovsches Substitutionsprinzip

Definition: Objekte einer Basisklasse müssen durch Objekte ihrer abgeleiteten Klassen ersetzt werden können, ohne die Korrektheit des Programms zu beeinträchtigen.

Kernpunkte:

• Untertypen müssen für ihre Basistypen austauschbar sein.
• Abgeleitete Klassen sollten das gleiche Verhalten wie die Basisklasse bieten.
• Die Kindklasse sollte keine neuen Ausnahmen werfen oder strengere Regeln als die Basisklasse implementieren.

Beispiel für eine Verletzung (Square/Rectangle Problem):

public class Rectangle {
    public virtual int Width { get; set; }
    public virtual int Height { get; set; }
}

public class Square : Rectangle { // Verletzt LSP
    public override int Width {
        set { base.Width = value; base.Height = value; }
    }
    public override int Height {
        set { base.Height = value; base.Width = value; }
    }
}

---

4. Interface Segregation Principle (ISP) – Schnittstellentrennungsprinzip

Definition: Clients sollten nicht gezwungen werden, von Schnittstellen abzuhängen, die sie nicht verwenden.

Kernpunkte:

• Bevorzugen Sie viele kleine, spezialisierte Schnittstellen gegenüber einer einzigen großen Schnittstelle.
• Macht es einfacher, alternative Implementierungen für spezifische Funktionen zu erstellen.

Beispiel: Anstatt einer großen IMachine Schnittstelle:

public interface IPrinter { void Print(); }
public interface IScanner { void Scan(); }

public class PrintScanMachine : IPrinter, IScanner {
    public void Print() { /* ... */ }
    public void Scan() { /* ... */ }
}

---

5. Dependency Inversion Principle (DIP) – Abhängigkeitsinversionsprinzip

Definition: Module hoher Ebene sollten nicht von Modulen niedriger Ebene abhängen. Beide sollten von Abstraktionen abhängen.

Kernpunkte:

• Abstraktionen (Interfaces) sollten nicht von Details abhängen; Details sollten von Abstraktionen abhängen.
• Löst das Problem der engen Kopplung (Tightly-Coupled).
• Ermöglicht einfacheres Testen (Unit-Testing) durch Mocking von Abhängigkeiten.

Beispiel:

public class OrderProcessor
{
    private readonly IPaymentProcessor _paymentProcessor; 

    // Constructor Injection: Abhängigkeit von Abstraktion
    public OrderProcessor(IPaymentProcessor paymentProcessor) 
    {
        _paymentProcessor = paymentProcessor;
    }
}

---

Zusammenfassung & Vorteile

Die Anwendung der SOLID-Prinzipien bietet klare Vorteile:

• Wartbarkeit: Code ist leichter zu verstehen, zu modifizieren und zu erweitern.
• Testbarkeit: Fördert Unit-Tests durch lose Kopplung.
• Flexibilität: Code passt sich leichter an neue Anforderungen an.
• Wiederverwendbarkeit: Erleichtert die Erstellung wiederverwendbarer Komponenten.

Interview-Tipps:

1. Verständnis: Erklären Sie jedes Prinzip klar und prägnant.
2. Beispiele: Halten Sie reale oder Code-Beispiele bereit.
3. Abwägungen: Seien Sie sich bewusst, dass die Anwendung dieser Prinzipien manchmal die Komplexität erhöhen kann.

---

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).