Webframeworkk/ASP.NET Core/SOLID-Prinzipien - Versionsgeschichte

imported>Import: Version 205

2026-02-28T00:03:03Z

Version 205

Neue Seite

''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:'''

<syntaxhighlight lang="csharp">public class ProductService
{
// Logik für Produkte (Hinzufügen, Abrufen)
}

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

-----

== 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 <code>GetPersons()</code> Methode zu ändern, um Sortierung hinzuzufügen, erstellen Sie eine neue Klasse:

<syntaxhighlight lang="csharp">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 */ }
}</syntaxhighlight>

-----

== 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):'''

<syntaxhighlight lang="csharp">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; }
}
}</syntaxhighlight>

-----

== 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 <code>IMachine</code> Schnittstelle:

<syntaxhighlight lang="csharp">public interface IPrinter { void Print(); }
public interface IScanner { void Scan(); }

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

-----

== 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:'''

<syntaxhighlight lang="csharp">public class OrderProcessor
{
private readonly IPaymentProcessor _paymentProcessor;

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

-----

== 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:'''

# '''Verständnis:''' Erklären Sie jedes Prinzip klar und prägnant.
# '''Beispiele:''' Halten Sie reale oder Code-Beispiele bereit.
# '''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).''

Thorsten: Die Seite wurde neu angelegt: „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 einzige…“

2026-02-28T00:03:03Z

Die Seite wurde neu angelegt: „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 einzige…“

← Nächstältere Version		Version vom 28. Februar 2026, 00:03 Uhr
Zeile 4:		Zeile 4:
	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.		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 ==		== 1. Single Responsibility Principle (SRP) – Einzelverantwortungsprinzip ==
Zeile 12:		Zeile 11:

	'''Kernpunkte:'''		'''Kernpunkte:'''

	* Vermeiden Sie mehrere, eng gekoppelte Funktionalitäten in einer Klasse.		* 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.		* Eine Klasse, die Validierungen durchführt, sollte nur für Validierungen zuständig sein und beispielsweise keine Konfigurationsdaten lesen.

	'''Beispiel:'''		'''Beispiel:'''
			<syntaxhighlight lang="csharp">
	<syntaxhighlight lang="csharp">public class ProductService		public class ProductService
	{		{
	// Logik für Produkte (Hinzufügen, Abrufen)		// Logik für Produkte (Hinzufügen, Abrufen)
Zeile 26:		Zeile 24:
	{		{
	// Logik für Bestellungen (Erstellen, Verarbeiten)		// Logik für Bestellungen (Erstellen, Verarbeiten)
	}</syntaxhighlight>		}
			</syntaxhighlight>

	-----		----

	== 2. Open/Closed Principle (OCP) – Offen/Geschlossen-Prinzip ==		== 2. Open/Closed Principle (OCP) – Offen/Geschlossen-Prinzip ==
Zeile 35:		Zeile 34:

	'''Kernpunkte:'''		'''Kernpunkte:'''

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

	'''Beispiel:''' Anstatt eine <code>GetPersons()</code> Methode zu ändern, um Sortierung hinzuzufügen, erstellen Sie eine neue Klasse:		'''Beispiel:'''
			Anstatt eine <code>GetPersons()</code> Methode zu ändern, um Sortierung hinzuzufügen, erstellen Sie eine neue Klasse:
	<syntaxhighlight lang="csharp">public interface IPersonGetter { List<Person> GetPersons(); }		<syntaxhighlight lang="csharp">
			public interface IPersonGetter { List<Person> GetPersons(); }

	public class PersonGetter : IPersonGetter {		public class PersonGetter : IPersonGetter {
Zeile 50:		Zeile 49:
	public class SortedPersonGetter : IPersonGetter {		public class SortedPersonGetter : IPersonGetter {
	public List<Person> GetPersons() { /* Sortierter Abruf */ }		public List<Person> GetPersons() { /* Sortierter Abruf */ }
	}</syntaxhighlight>		}
			</syntaxhighlight>

	-----		----

	== 3. Liskov Substitution Principle (LSP) – Liskovsches Substitutionsprinzip ==		== 3. Liskov Substitution Principle (LSP) – Liskovsches Substitutionsprinzip ==
Zeile 59:		Zeile 59:

	'''Kernpunkte:'''		'''Kernpunkte:'''

	* Untertypen müssen für ihre Basistypen austauschbar sein.		* Untertypen müssen für ihre Basistypen austauschbar sein.
	* Abgeleitete Klassen sollten das gleiche Verhalten wie die Basisklasse bieten.		* Abgeleitete Klassen sollten das gleiche Verhalten wie die Basisklasse bieten.
Zeile 65:		Zeile 64:

	'''Beispiel für eine Verletzung (Square/Rectangle Problem):'''		'''Beispiel für eine Verletzung (Square/Rectangle Problem):'''
			<syntaxhighlight lang="csharp">
	<syntaxhighlight lang="csharp">public class Rectangle {		public class Rectangle {
	public virtual int Width { get; set; }		public virtual int Width { get; set; }
	public virtual int Height { get; set; }		public virtual int Height { get; set; }
Zeile 78:		Zeile 77:
	set { base.Height = value; base.Width = value; }		set { base.Height = value; base.Width = value; }
	}		}
	}</syntaxhighlight>		}
			</syntaxhighlight>

	-----		----

	== 4. Interface Segregation Principle (ISP) – Schnittstellentrennungsprinzip ==		== 4. Interface Segregation Principle (ISP) – Schnittstellentrennungsprinzip ==
Zeile 87:		Zeile 87:

	'''Kernpunkte:'''		'''Kernpunkte:'''

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

	'''Beispiel:''' Anstatt einer großen <code>IMachine</code> Schnittstelle:		'''Beispiel:'''
			Anstatt einer großen <code>IMachine</code> Schnittstelle:
	<syntaxhighlight lang="csharp">public interface IPrinter { void Print(); }		<syntaxhighlight lang="csharp">
			public interface IPrinter { void Print(); }
	public interface IScanner { void Scan(); }		public interface IScanner { void Scan(); }

Zeile 99:		Zeile 99:
	public void Print() { /* ... */ }		public void Print() { /* ... */ }
	public void Scan() { /* ... */ }		public void Scan() { /* ... */ }
	}</syntaxhighlight>		}
			</syntaxhighlight>

	-----		----

	== 5. Dependency Inversion Principle (DIP) – Abhängigkeitsinversionsprinzip ==		== 5. Dependency Inversion Principle (DIP) – Abhängigkeitsinversionsprinzip ==
Zeile 108:		Zeile 109:

	'''Kernpunkte:'''		'''Kernpunkte:'''

	* Abstraktionen (Interfaces) sollten nicht von Details abhängen; Details sollten von Abstraktionen abhängen.		* Abstraktionen (Interfaces) sollten nicht von Details abhängen; Details sollten von Abstraktionen abhängen.
	* Löst das Problem der engen Kopplung (Tightly-Coupled).		* Löst das Problem der engen Kopplung (Tightly-Coupled).
Zeile 114:		Zeile 114:

	'''Beispiel:'''		'''Beispiel:'''
			<syntaxhighlight lang="csharp">
	<syntaxhighlight lang="csharp">public class OrderProcessor		public class OrderProcessor
	{		{
	private readonly IPaymentProcessor _paymentProcessor;		private readonly IPaymentProcessor _paymentProcessor;
Zeile 124:		Zeile 124:
	_paymentProcessor = paymentProcessor;		_paymentProcessor = paymentProcessor;
	}		}
	}</syntaxhighlight>		}
			</syntaxhighlight>

	-----		----

	== Zusammenfassung &~~amp;~~ Vorteile ==		== Zusammenfassung & Vorteile ==

	Die Anwendung der SOLID-Prinzipien bietet klare Vorteile:		Die Anwendung der SOLID-Prinzipien bietet klare Vorteile:

	* '''Wartbarkeit:''' Code ist leichter zu verstehen, zu modifizieren und zu erweitern.		* '''Wartbarkeit:''' Code ist leichter zu verstehen, zu modifizieren und zu erweitern.
	* '''Testbarkeit:''' Fördert Unit-Tests durch lose Kopplung.		* '''Testbarkeit:''' Fördert Unit-Tests durch lose Kopplung.
Zeile 138:		Zeile 138:

	'''Interview-Tipps:'''		'''Interview-Tipps:'''

	# '''Verständnis:''' Erklären Sie jedes Prinzip klar und prägnant.		# '''Verständnis:''' Erklären Sie jedes Prinzip klar und prägnant.
	# '''Beispiele:''' Halten Sie reale oder Code-Beispiele bereit.		# '''Beispiele:''' Halten Sie reale oder Code-Beispiele bereit.