Webframeworkk/ASP.NET Core/SOLID-Prinzipien

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.