6. Schichtenarchitekturen
6.1. Einführung
Betrachten wir noch einmal die letzte Version der Anwendung zur Steuerberechnung (Version 3, vorheriges Kapitel). Auf das Wesentliche reduziert, hatte ihr Konsolenprogramm die folgende Struktur:
Dieses Programm vereint drei Verarbeitungsschritte, die sich in den meisten Anwendungen finden:
- das Abrufen von Daten, die in Dateien, Datenbanken usw. gespeichert sind: Zeilen 1–14;
- die Interaktion mit dem Benutzer: Zeilen 19–20 (Eingabe) und 23 (Ausgabe);
- die Anwendung eines fachlichen Algorithmus, hier der Steuerberechnung: Zeile 23. Diese Berechnung wurde bisher von der Klasse [AbstractTax], der Elternklasse von [FileTax] und [JsonTax]: In Version 3 sind das Lesen der Daten und die Berechnung noch in einem einzigen Objekt vereint.
Die Erfahrung hat gezeigt, dass die Trennung dieser Verarbeitungsschritte in eigene Klassen die Wartbarkeit der Anwendung verbessert. Die Architektur einer so strukturierten Anwendung sieht wie folgt aus:

Diese Architektur wird „Drei-Tier-Architektur“ genannt. Der Begriff „Tier“ bezeichnet normalerweise einen Teil der Anwendung, der auf einem anderen Rechner läuft. Befinden sich die Teile auf demselben Rechner, spricht man stattdessen von einer „Schichtenarchitektur“:
- Die [business]-Schicht enthält die Geschäftsregeln der Anwendung. Für unsere Anwendung sind das die Regeln zur Berechnung der Steuer eines Steuerpflichtigen. Diese Schicht benötigt zum Funktionieren Daten:
- die Steuerstufen, die sich jedes Jahr ändern;
- die Kinderzahl, den Familienstand des Steuerpflichtigen und sein Jahreseinkommen;
- die Datenzugriffsschicht oder [dao] (DAO = Data Access Object) liefert bereits in Dateien oder Datenbanken gespeicherte Daten. Dazu gehören die Steuerstufen, wie in Version 3 der Anwendung;
- die Benutzeroberflächenschicht oder [ui] (UI = User Interface) liefert die vom Benutzer eingegebenen Daten und zeigt dem Benutzer die Ergebnisse an. Das betrifft hier die Kinderzahl, den Familienstand und das Jahreseinkommen des Steuerpflichtigen.
Allgemein gilt:
- Die [dao]-Schicht kümmert sich um den Zugriff auf persistente Daten (Dateien, Datenbanken) oder nicht persistente Daten (Netzwerk, Sensoren usw.);
- die [ui]-Schicht kümmert sich um die Interaktion mit dem Benutzer, sofern es einen gibt;
- die drei Schichten werden durch den Einsatz von Schnittstellen voneinander unabhängig gemacht.
Wir greifen die Anwendung [Tax], die wir bereits mehrfach betrachtet haben, wieder auf, um ihr eine Schichtenarchitektur zu geben. Zunächst müssen wir die Schnittstellen der verschiedenen Schichten der Anwendung definieren.
6.2. Die Schnittstellen der Anwendung [Tax]
Denken Sie daran, dass eine Schnittstelle eine Menge von Methoden- und Eigenschaftssignaturen definiert. Die Klassen, die die Schnittstelle implementieren, liefern die tatsächliche Implementierung dieser Methoden und Eigenschaften.
Kehren wir zur Schichtenarchitektur unserer Anwendung zurück:

Bei dieser Art von Architektur geht die Initiative häufig vom Benutzer aus. Der Benutzer stellt in [1] eine Anfrage und erhält in [8] eine Antwort. Man spricht vom Anfrage-Antwort-Zyklus. Nehmen wir als Beispiel die Berechnung der Steuer eines Steuerpflichtigen. Dafür sind mehrere Schritte nötig:
- Die [ui]-Schicht fragt den Benutzer nach Familienstand, Kinderzahl und Jahresgehalt. Dies ist die oben beschriebene Operation [1];
- danach bittet die Schicht [ui] die Schicht [business] um die Berechnung der Steuer. Dazu sendet sie dieser Schicht die vom Benutzer erhaltenen Daten. Dies ist die Operation [2];
- Die [business]-Schicht benötigt für ihre Aufgabe bestimmte Informationen: die Steuerstufen. Sie fragt diese bei der Schicht [dao] über den Weg [3, 4, 5, 6] an: [3] ist die ursprüngliche Anfrage, und [6] ist die Antwort auf diese Anfrage;
- Mit allen benötigten Daten berechnet die Schicht [business] die Steuer;
- Die [business]-Schicht kann nun die von der [ui]-Schicht in [2] gestellte Anfrage beantworten. Dies ist der Weg [7];
- Die [ui]-Schicht formatiert dieses Ergebnis und präsentiert es dann dem Benutzer. Dies ist der Weg [8];
- Man könnte sich vorstellen, dass der Benutzer Steuersimulationen durchführt und speichern möchte. Dazu würde er denselben Weg [1-8] nutzen.
Wie diese Beschreibung zeigt, nutzt eine Schicht die Ressourcen der Schicht zu ihrer Rechten, niemals die der Schicht zu ihrer Linken. Betrachten wir zwei benachbarte Schichten:

Die Schicht [A] stellt Anfragen an die Schicht [B]. In den einfachsten Fällen wird eine Schicht von einer einzigen Klasse implementiert. Eine Anwendung entwickelt sich jedoch im Laufe der Zeit weiter, und die Schicht [B] kann nacheinander verschiedene Implementierungsklassen haben: [B1], [B2] und so weiter. Ist die Schicht [B] die Schicht [dao], kann sie eine erste Implementierung [B1], haben, die Daten aus einer Datei abruft. Einige Jahre später möchte man diese Daten vielleicht in einer Datenbank speichern: Dann würde man eine zweite Implementierungsklasse [B2] erstellen. Hätte in der ursprünglichen Anwendung die Schicht [A] direkt mit der Klasse [B1] gearbeitet, müssten wir den Code der Schicht [A] teilweise neu schreiben. Nehmen wir beispielsweise an, wir hätten in der Schicht [A] etwa Folgendes geschrieben:
- Zeile 1: Eine Instanz der Klasse [B1] wird erzeugt;
- Zeile 3: Von dieser Instanz werden Daten angefordert.
Hat die neue Implementierungsklasse [B2] Methoden mit derselben Signatur wie die Klasse [B1], müssen Sie alle Vorkommen von [B1] in [B2] ändern. Das ist der günstigste Fall, und er ist ziemlich unwahrscheinlich, wenn Sie nicht auf diese Signaturen geachtet haben. In der Praxis haben die Klassen [B1] und [B2] häufig unterschiedliche Methodensignaturen, sodass ein erheblicher Teil der Schicht [A] neu geschrieben werden muss.
Wir können dies verbessern, indem wir zwischen die Schichten [A] und [B] eine Schnittstelle einfügen. Damit werden die Methodensignaturen, die die Schicht [B] der Schicht [A] zur Verfügung stellt, in einer Schnittstelle festgeschrieben. Das vorherige Diagramm wird zum folgenden:

Die Schicht [A] kommuniziert nicht mehr direkt mit der Schicht [B] , sondern mit deren Schnittstelle [IB]. Im Code der Schicht [A] erscheint die Implementierungsklasse [Bi] der Schicht [B] nun nur noch ein einziges Mal, nämlich wenn das Objekt erzeugt wird, das die Schnittstelle [IB] implementiert. Danach wird die Schnittstelle [IB] verwendet – und nicht ihre Implementierungsklasse. Der vorherige Code wird zu:
- Zeile 1: Durch Instanziieren der Klasse
*[B1]wird eine Instanz*[ib]erzeugt, die die Schnittstelle*[IB]* implementiert; - Zeile 3: Von der Instanz [ib] werden Daten angefordert.
Ersetzen wir nun die Implementierung [B1] der Schicht [B] durch eine Implementierung [B2] und halten sich beide Implementierungen an dieselbe Schnittstelle [IB], muss nur Zeile 1 der Schicht [A] geändert werden. Das ist ein großer Vorteil, der allein schon den systematischen Einsatz von Schnittstellen zwischen zwei Schichten rechtfertigt.
Wir können noch weiter gehen und die Schicht [A] völlig unabhängig von der Schicht [B] machen. Im obigen Code ist Zeile 1 ein Problem, da sie den Klassennamen [B1] fest verdrahtet. Idealerweise sollte die Schicht [A] eine Implementierung der Schnittstelle [IB] erhalten, ohne einen Klassennamen angeben zu müssen. Das entspräche dem obigen Diagramm: Die Schicht [A] arbeitet mit der Schnittstelle [IB], und es gibt keinen Grund, warum sie den Namen der Klasse kennen müsste, die diese Schnittstelle implementiert.
Genau das ermöglicht die Dependency Injection (DI, Abhängigkeitsinjektion). Die bisherige Architektur entwickelt sich wie folgt weiter:

Eine übergreifende Komponente – der Dependency-Injection-Container – erzeugt die Objekte, die die Schichten implementieren, und verbindet sie miteinander: Er übergibt der Schicht [A] eine Referenz auf das Objekt, das die Schicht [B] implementiert. Der Code der Schicht [A] hat dann die folgende Form:
- Zeile 2: Die Schicht [A] erhält über ihren Konstruktor eine Instanz [ib], die die Schnittstelle [IB] implementiert. Nicht die Schicht [A] erzeugt sie, sondern der Container;
- Zeile 7: Von der Instanz [ib] werden Daten angefordert.
Die Implementierungsklasse [B1] erscheint nirgends mehr im Code der Schicht [A]. Wird die Implementierung [B1] durch eine neue Implementierung [B2] ersetzt, ändert sich nichts am Code der Schicht [A]: Es ändert sich lediglich die einzige Stelle in der Anwendung, an der dem Container mitgeteilt wird, welche Klasse [IB] implementiert. Diese Stelle kann den Namen der zu verwendenden Implementierung sogar aus einer Konfigurationsdatei lesen.
Der Kurs von 2008 verwendete hierfür das Framework Spring.NET und eine XML-Konfigurationsdatei mit dem Namen [App.config]. Spring.NET wird nicht mehr gepflegt; .NET stellt inzwischen einen eigenen Container bereit, [Microsoft.Extensions.DependencyInjection], der von allen ASP.NET-Core-Anwendungen verwendet wird. Diesen werden wir in Version 5 der Anwendung einsetzen. Die Kombination aus „C#-Schnittstellen + Dependency Injection“ bringt eine entscheidende Verbesserung für die Wartung von Anwendungen, indem sie die Schichten voneinander unabhängig macht.
Kehren wir zur Schichtenarchitektur unserer Anwendung zurück. In einfachen Fällen können wir mit der Schicht [business] beginnen, um die Schnittstellen der Anwendung zu erkunden. Zum Funktionieren benötigt die Anwendung Daten:
- die bereits in Dateien, Datenbanken oder über das Netzwerk verfügbar sind. Diese Daten liefert die Schicht [dao];
- die noch nicht verfügbar sind. In diesem Fall liefert sie die Schicht [ui], die sie vom Benutzer erhält.
Welche Schnittstelle muss die Schicht [dao] der Schicht [business] bieten? Die Schicht [dao] muss der Schicht [business] die Steuerstufen liefern. In unserer Anwendung verwendet die Schicht [dao] vorhandene Daten, erzeugt aber keine neuen. Ihre Schnittstelle kann wie folgt aussehen:
- Zeile 3: Die Schicht [dao] liegt im Namespace [Dao]. Wir verwenden dateibezogene Namespaces (C# 10): Die Deklaration [namespace Dao;] gilt für die gesamte Datei, ohne geschweifte Klammern und zusätzliche Einrückung;
- Zeile 9: Die Schnittstelle [ITaxDao] definiert die schreibgeschützte Eigenschaft [TaxBrackets], die der Schicht [business] die Steuerstufen liefert;
- Zeile 1: importiert den Namespace, in dem der Typ [TaxBracket] definiert ist:
Wie in den Versionen 2 und 3 wird eine Steuerstufe durch eine [readonly record struct] (C# 10) dargestellt: eine schreibgeschützte Struktur, für die der Compiler den Konstruktor (aus den nach dem Typnamen stehenden Parametern), die schreibgeschützten Eigenschaften [Limit], [CoeffR] und [CoeffN], die Wertgleichheit und die Methode [ToString] erzeugt. Wir schreiben [new TaxBracket(4962M, 0M, 0M)] , um eine Stufe zu erzeugen. Der Kurs von 2008 verwendete eine Struktur mit veränderbaren Eigenschaften; wir werden sehen, dass die Unveränderbarkeit einer Stufe einen Seiteneffekt der alten Schicht [business] beseitigt.
Welche Schnittstelle sollte die Schicht [business] der Schicht [ui] bieten? Sehen wir uns die Interaktionen zwischen diesen beiden Schichten noch einmal an:
- Die [ui]-Schicht fragt den Benutzer nach Familienstand, Kinderzahl und Jahresgehalt. Dies ist die Operation [1] im Schema;
- Danach bittet die Schicht [ui] die Schicht [business] um die Berechnung der Steuer. Dazu sendet sie die vom Benutzer erhaltenen Daten an die Schicht [business]. Dies ist die Operation [2].
Die Schnittstelle der Schicht [business] könnte wie folgt aussehen:
- Zeile 1: Alles, was zur Schicht [business] gehört, liegt im Namespace [Business];
- Zeile 6: Die Schnittstelle [ITaxBusiness] definiert nur eine Methode, die die Steuer eines Steuerpflichtigen anhand seines Familienstands, seiner Kinderzahl und seines Jahresgehalts berechnet.
Wir untersuchen nun eine erste Implementierung dieser Schichtenarchitektur.
6.3. Beispielanwendung – Version 4
6.3.1. Das Projekt
Version 4 ist ein einziges Konsolenprojekt, das wie folgt erstellt wird:
Jede Schicht belegt einen eigenen Ordner:
- Der Ordner [Entities] enthält die Typen, die von den Schichten [ui], [business] und [dao] gemeinsam genutzt werden: die Struktur [TaxBracket] und die Ausnahme [TaxException], übernommen aus Version 3;
- der Ordner [Dao] enthält die Schnittstelle und die Klassen der Schicht [dao]. Wir verwenden zwei Implementierungen der Schnittstelle [ITaxDao]: die Klasse [HardwiredTax], deren Daten fest im Code stehen (Version 2), und die Klasse [FileTax], die Daten aus einer Textdatei liest (Version 3). Das Lesen einer JSON-Datei – die andere Option in Version 3 – wird in Version 5 behandelt;
- Der Ordner [Business] enthält die Schnittstelle und die Klasse der Schicht [business];
- Der Ordner [Ui] enthält die Klasse der Schicht [ui];
- Die Datei [Program.cs] erzeugt die Schichten und verbindet sie miteinander;
- die Datei [TaxData.txt] enthält die Steuerstufen, die von der Implementierung [FileTax] der Schicht [dao] gelesen werden.
Die Ordnernamen sind für den Compiler ohne Bedeutung: Alle Dateien [.cs] im Projektordner und seinen Unterordnern werden kompiliert. Es handelt sich um eine Konvention, die das Projekt leichter lesbar macht; ergänzt wird sie dadurch, dass der Namespace nach dem Ordner benannt wird.
Die Datei [TaxV4.csproj] ist die von [dotnet new] erzeugte, ergänzt um eine Anweisung zum Kopieren der Datendateien:
- Zeile 12: Die Dateien [TaxData*.txt] werden bei der Kompilierung neben die ausführbare Datei in den Ordner [bin/Debug/net10.0] kopiert. Die Schicht [dao] sucht sie an dieser Stelle, unabhängig davon, ob das Programm mit [dotnet run] aus dem Projektordner oder direkt aus einem anderen Ordner gestartet wird.
6.3.2. Die Entitäten der Anwendung

Als Entitäten bezeichnen wir Typen, die mehrere Schichten durchziehen. Es sind im Allgemeinen die Klassen und Strukturen, die die Daten der Schicht [dao] kapseln. Diese Entitäten reichen im Allgemeinen bis in die Schicht [ui] hinauf. Die Entitäten der Anwendung sind die bereits vorgestellte Struktur [TaxBracket] und die Ausnahme [TaxException] aus Version 3 samt der Liste ihrer Fehlercodes:
- Zeilen 4–5: die Fehlercodes. Das Attribut [Flags] gibt an, dass die Werte der Aufzählung Bits sind, die mit dem Operator [|] kombiniert werden können: Der Wert [ErrorCode.Field2 | ErrorCode.Field3] (8 + 16 = 24) bedeutet, dass die Felder 2 und 3 einer Zeile fehlerhaft sind. Die Methode [ToString] einer solchen Aufzählung zeigt dann „Field2, Field3“ an. Der Wert [Json] aus Version 3 wurde entfernt, da diese Version die JSON-Datei nicht liest;
- Zeile 8: eine anwendungsspezifische Ausnahme, die von der Klasse [Exception] abgeleitet ist;
- Zeile 11: Der Fehlercode, eine ganze Zahl, die [ErrorCode]-Werte kombiniert, ist eine [init]-Eigenschaft (C# 9): Ihr kann nur bei der Erzeugung des Objekts ein Wert zugewiesen werden, beispielsweise mit einem Initialisierer [new TaxException(...) { Code = ... }];
- Zeilen 14–15: zwei Konstruktoren, einer mit einer Meldung, der andere mit einer Meldung und der ursprünglichen Ausnahme, die über die Eigenschaft [InnerException] zugänglich sein wird. Sie rufen lediglich den entsprechenden Konstruktor der Elternklasse [Exception] ([: base(...)]) auf.
In dieser Version instanziiert nur die Klasse [FileTax] der Schicht [dao] die Klasse [TaxException].
6.3.3. Die Schicht [dao]
Rufen wir uns die Schnittstelle der Schicht [dao] in Erinnerung:
Wir implementieren diese Schnittstelle auf zwei verschiedene Weisen. Zunächst mit der Klasse [HardwiredTax]:
- Zeile 6: Die Klasse [HardwiredTax] implementiert die Schnittstelle [ITaxDao];
- Zeile 9: Implementierung der Eigenschaft [TaxBrackets] der Schnittstelle. Es ist eine automatische, schreibgeschützte Eigenschaft, die durch einen Eigenschaftsinitialisierer initialisiert wird (C# 6);
- Zeilen 11–17: Der Anfangswert ist ein Collection-Ausdruck (C# 12): Die in eckige Klammern eingeschlossene Liste von Elementen erzeugt ein Array vom Typ [TaxBracket[]]. Jedes Element wird mit
***[new(...)]* erzeugt: Der Typ des erzeugten Objekts wird nicht wiederholt, sondern aus dem erwarteten Typ[TaxBracket]abgeleitet (C# 9).
Die Schnittstelle [ITaxDao] wird auch von der Klasse [FileTax] implementiert, die Steuerstufen aus einer Textdatei liest. Die Datei [TaxData.txt] lautet wie folgt:
Jede Zeile beschreibt eine Steuerstufe im Format [limit:coeffR:coeffN]. Zahlen werden unabhängig von der Systemsprache mit Dezimalpunkt geschrieben; so ist die Datei auf allen Rechnern lesbar. Die Werte stammen aus der Steuertabelle 2004 für die Einkommen von 2003 und werden unverändert beibehalten: Es handelt sich um eine Übung. Die Klasse [FileTax] lautet wie folgt:
- Zeile 3: Die Direktive [using static] (C# 6) erlaubt es, statische Member und verschachtelte Typen eines Typs ohne Präfix zu verwenden. Die Werte einer Aufzählung sind Konstanten und damit statische Member: Wir schreiben [Field1] statt [ErrorCode.Field1];
- Zeile 9: Die Klasse [FileTax] implementiert die Schnittstelle [ITaxDao];
- Zeile 15: die Eigenschaft der Schnittstelle [ITaxDao]. Sie hat keinen [set]-Zugriff: Ihr kann nur im Konstruktor ein Wert zugewiesen werden (Zeile 75);
- Zeile 18: Der Konstruktor erhält den Namen der Datei mit den Steuerstufen;
- Zeile 23: Die gelesenen Steuerstufen werden in einer Liste gesammelt, die mit einem leeren Collection-Ausdruck initialisiert wird;
- Zeile 25: Die Datei wird im Ordner der ausführbaren Datei gesucht, [AppContext.BaseDirectory], wohin die Datei [.csproj] sie kopiert hat. Ist [fileName] ein absoluter Pfad, lässt [Path.Combine] ihn unverändert;
- Zeilen 29–31: Existiert die Datei nicht, wird eine [FileNotFoundException] mit unserer eigenen Meldung ausgelöst. Die Ausnahmemeldung, die .NET andernfalls auslösen würde, enthält den vollständigen Pfad der Datei;
- Zeile 33: [File.ReadLines] liest die Datei zeilenweise: Die Zeilen werden im Verlauf der [foreach]-Schleife gelesen, und die Datei wird am Ende der Schleife geschlossen, auch wenn eine Ausnahme ausgelöst wird;
- Zeile 43: Die Zeile wird am Doppelpunkt zerlegt; die Option [StringSplitOptions.TrimEntries] entfernt die Leerzeichen um jedes Feld;
- Zeilen 46–48: Eine Zeile, die nicht drei Felder hat, ist ungültig;
- Zeilen 53–55: Umwandlung der drei Felder. Jedes fehlerhafte Feld fügt dem Fehlercode mit dem Operator [|=] ein Bit hinzu;
- Zeilen 58–60: Eine fehlerhafte Zeile löst eine [TaxException] aus, deren Meldung die Zeilennummer und den Inhalt angibt. Der Code vom Typ [ErrorCode] wird durch [(int)code] in eine ganze Zahl umgewandelt;
- Zeile 63: Die gelesene Stufe wird der Liste hinzugefügt;
- Zeile 66: Der Exception-Filter [when] (C# 6) fängt nur E/A-Fehler ab: [IOException], von der [FileNotFoundException] abgeleitet ist, und [UnauthorizedAccessException] (unzureichende Berechtigungen). Das Muster [e is IOException or UnauthorizedAccessException] (C# 9) prüft beide Typen. Die in Zeile 60 ausgelöste [TaxException] wird nicht abgefangen: Sie wird unverändert an den Aufrufer weitergereicht;
- Zeilen 69–71: Der E/A-Fehler wird in einer [TaxException] mit dem Code [Access] verpackt; die ursprüngliche Ausnahme bleibt in ihrer Eigenschaft [InnerException] erhalten;
- Zeile 75: Die Liste wird in ein Array kopiert. Der Operator [..] („Spread“) eines Collection-Ausdrucks fügt alle Elemente einer anderen Sammlung ein;
- Zeilen 79–80: Umwandlung eines Feldes in [decimal]. Der Stil [NumberStyles.AllowDecimalPoint] akzeptiert nur Ziffern und einen Dezimalpunkt, und die invariante Kultur [CultureInfo.InvariantCulture] verlangt einen Punkt als Dezimaltrennzeichen. „0,191“ wird also abgelehnt, obwohl eine Kultur fr-FR es akzeptiert hätte. Die Methode ist mit einem Ausdruckskörper [=>] geschrieben (C# 6).
6.3.4. Die Schicht [business]
Rufen wir uns die Schnittstelle dieser Schicht in Erinnerung:
Ihre Implementierung, [TaxBusiness], lautet wie folgt:
- Zeile 7: Die Klasse [TaxBusiness] implementiert die Schnittstelle [ITaxBusiness]. Die Schicht [business] muss mit der Schicht [dao] zusammenarbeiten: Sie erhält deshalb eine Referenz auf das Objekt, das die Schnittstelle [ITaxDao] implementiert. Diese Referenz ist der Parameter [dao] des primären Konstruktors der Klasse (C# 12): Die nach dem Klassennamen aufgeführten Parameter sind die ihres Konstruktors und können im gesamten Klassenrumpf verwendet werden;
- Zeile 10: Bei der Konstruktion des Objekts fordert die Schicht [business] die Steuerstufen einmalig von der Schicht [dao] an und speichert sie in einem schreibgeschützten Feld. Beachten Sie, dass die Schicht [business] die Schicht [dao] nur über deren Schnittstelle [ITaxDao] kennt: Sie weiß nicht, ob die Steuerstufen aus dem Code, aus einer Datei oder später aus einer Datenbank stammen;
- Zeilen 16–17: Die Schicht [business] vertraut ihren Aufrufern nicht. Die statischen Methoden [ThrowIfNegative] (.NET 8) lösen eine [ArgumentOutOfRangeException] aus, wenn ihr Parameter negativ ist; die Ausnahmemeldung enthält den Namen des Parameters;
- Zeilen 19–22: die Anzahl der Anteile. Die Division [nbChildren / 2M] ist eine Dezimaldivision, weil [2M] ein [decimal] ist: 3 Kinder entsprechen 1,5 Anteilen;
- Zeilen 25–26: das zu versteuernde Einkommen und der Familienquotient;
- Zeilen 29–35: Wir suchen die erste Stufe, deren Schwellenwert größer oder gleich dem Familienquotienten ist. Die letzte Stufe, [brackets[^1]] (der Index [^1] bezeichnet das letzte Element, C# 8), wird verwendet, wenn keine andere Stufe passt: Ihr Schwellenwert (0) wird nicht verwendet;
- Zeile 39: die Steuer, abgeschnitten auf ihren ganzzahligen Anteil.
Der Code des Kurses von 2008 schrieb [taxBrackets[taxBrackets.Length - 1].Limit = QF + 1] vor der Suche nach der Stufe, damit die Suchschleife immer endete. Diese Anweisung veränderte das von der [dao]-Schicht gelieferte Array: ein Seiteneffekt auf Daten, die von allen Schichten gemeinsam genutzt werden. Tatsächlich ließe sie sich so gar nicht mehr schreiben, da ein [TaxBracket] inzwischen schreibgeschützt ist. Der moderne Code nimmt einfach die letzte Stufe, wenn keine Grenze passt, ohne die empfangenen Daten zu verändern.
6.3.5. Die [ui]-Schicht
In den Versionen 2 und 3 war die Benutzeroberfläche im Hauptprogramm geschrieben, nach der Erstellung des Berechnungsobjekts. Der einzige Unterschied bestand in der Art, wie dieses Objekt erstellt wurde. Wir isolieren diese Interaktion nun in einer Klasse der [ui]-Schicht, die die [business]-Schicht nur über ihre Schnittstelle kennt:
- Zeile 6: Die Klasse [Dialog] ist statisch: Sie hat keinen eigenen Zustand und enthält ausschließlich statische Member;
- Zeilen 9–14: Die Hilfemeldung ist ein Raw-String-Literal (C# 11), das von drei Anführungszeichen begrenzt wird. Es kann sich über mehrere Zeilen erstrecken; die allen Zeilen gemeinsame Einrückung, die durch die Position der schließenden Anführungszeichen bestimmt wird, wird entfernt;
- Zeile 17: Die Methode [Run] erhält die [business]-Schicht in Form ihrer Schnittstelle [ITaxBusiness]. Sie weiß nichts über die Klasse, die diese implementiert, und nichts über die [dao]-Schicht;
- Zeile 23: [Console.ReadLine] liefert [null] am Ende des Eingabestroms; der Operator [?.] liefert dann [null] , ohne [Trim] aufzurufen, und der Operator [??] ersetzt [null] durch die leere Zeichenkette: Ein Ende des Stroms beendet den Dialog genauso wie eine leere Zeile;
- Zeile 30: Die eingegebene Zeile wird an den Leerzeichen aufgeteilt; die Option [StringSplitOptions.RemoveEmptyEntries] ignoriert mehrfache Leerzeichen;
- Zeilen 44–50: [int.TryParse(fields[1], out int nbChildren)] deklariert die Ausgabevariable direkt im Aufruf (C# 7);
- Zeile 56: Die Parameter sind korrekt: Die Berechnung wird bei der [business]-Schicht angefordert.
6.3.6. Integration der Schichten
Es bleibt nur noch, die Schichten zu erstellen und miteinander zu verbinden. Das ist die Aufgabe des Hauptprogramms [Program.cs]:
- Zeile 8: Das Programmargument wählt die Implementierung der Schicht [dao] aus: [hardwired] für die Klasse [HardwiredTax]; andernfalls der Name der Datei, die von der Klasse [FileTax] gelesen wird, mit [TaxData.txt] als Standardwert. Beachten Sie, dass die Befehlszeilenargumente bei Top-Level-Anweisungen im Array [args] abgelegt werden;
- Zeile 13: Erstellung der Schicht [dao]. Dies ist die einzige Stelle im Programm, an der die Klassen [HardwiredTax] und [FileTax] genannt werden;
- Zeile 15: Erstellung der Schicht [business], die die Schicht [dao] erhält;
- Zeilen 17–22: Die Erstellung der Schicht [dao] kann eine [TaxException] auslösen. Der Fehler wird dann zusammen mit der Meldung der ursprünglichen Ausnahme (falls vorhanden) angezeigt, und das Programm endet mit dem Exitcode 1. Wie in Version 3 wird der Code in [ErrorCode] umgewandelt, um im Klartext angezeigt zu werden;
- Zeile 26: Die Schichten sind bereit: Die [ui]-Schicht interagiert mit dem Benutzer.
6.3.7. Ausführungen
Mit der Datei [TaxData.txt] (Implementierung [FileTax]) und beim Testen der Eingabevalidierung:
Mit der Implementierung [HardwiredTax]:
Mit einer Datei, die nicht existiert:
Der Fehlercode ist [Access], und die Meldung der ursprünglichen Ausnahme, [FileNotFoundException], wird angezeigt.
Mit der folgenden Datei, [TaxDataInvalid.txt], in der Zeile 3 Dezimalkommas enthält:
das Ergebnis lautet:
Die Felder 2 und 3 der Zeile 3 sind fehlerhaft: Der Fehlercode kombiniert die Bits von [Field2] und [Field3], und die Methode [ToString] einer Enumeration [Flags] zeigt ihn als „Field2, Field3.“ an.
6.3.8. Fazit
Die Schichtenarchitektur und die Verwendung von Schnittstellen haben unserer Anwendung eine gewisse Flexibilität verliehen. Dies zeigt sich daran, wie das Hauptprogramm die Schichten [dao] und [business] erstellt:
Der Wechsel der Implementierung der Schicht [dao] ändert nur Zeile 1. Sobald die Schichten erstellt sind, ist der Code der [ui]-Schicht in beiden Fällen derselbe: Auf die [business]-Schicht wird über ihre Schnittstelle [ITaxBusiness] zugegriffen, nicht über ihre Implementierungsklasse.
Dieselbe Flexibilität zeigt sich in der [business]-Schicht: Sie wird anhand einer Referenz auf die Schnittstelle der [dao]-Schicht aufgebaut. Ein Wechsel der Implementierung der Letzteren hat daher keine Auswirkungen auf die [business]-Schicht. Deshalb konnte unsere einzige Klasse [TaxBusiness] ohne Änderung mit zwei verschiedenen Implementierungen der [dao]-Schicht arbeiten.
6.4. Beispielanwendung - Version 5

Diese neue Version basiert auf der vorherigen und enthält die folgenden Änderungen:
- Die Schichten [dao] und [business] werden jeweils in eine Klassenbibliothek (DLL) ausgelagert und mit dem Unit-Test-Framework MSTest getestet;
- Die [dao]-Schicht erhält eine dritte Implementierung, [JsonTax], die die Steuerstufen aus einer JSON-Datei liest;
- die Integration der Schichten übernimmt der Dependency-Injection-Container von .NET, und die Implementierung der [dao]-Schicht wird über eine Konfigurationsdatei ausgewählt.
In großen Projekten arbeiten mehrere Entwickler an derselben Anwendung. Schichtenarchitekturen erleichtern diese Arbeitsweise: Da die Schichten über klar definierte Schnittstellen miteinander kommunizieren, muss sich ein Entwickler, der an einer Schicht arbeitet, nicht um die Arbeit der anderen Entwickler an den anderen Schichten kümmern. Es genügt, dass alle die Schnittstellen einhalten.
Um also die [business]-Schicht zu testen, benötigt der Entwickler eine Implementierung der [dao]-Schicht. Solange diese Implementierung nicht fertig ist, kann er eine Dummy-Implementierung der [dao]-Schicht verwenden, sofern sie die Schnittstelle [ITaxDao] einhält. Das ist ein weiterer Vorteil der Schichtenarchitektur: Eine Verzögerung bei der [dao]-Schicht hindert nicht daran, die [business]-Schicht zu testen. Die Mock-Implementierung hat außerdem den Vorteil, dass sie sich wesentlich einfacher aufsetzen lässt als die tatsächliche [dao]-Schicht, die ein DBMS, Netzwerkverbindungen usw. erfordern kann.
Sobald die [dao]-Schicht fertiggestellt und getestet ist, wird sie den Entwicklern der [business]-Schicht in Form einer Bibliothek (eines Projekts oder einer DLL) bereitgestellt und nicht als zu kopierender Quellcode. Letztlich wird die Anwendung als ausführbare Datei (die der [ui]-Schicht) und als Klassenbibliotheken (die übrigen Schichten) ausgeliefert.
6.4.1. Die Lösung TaxV5
Version 5 ist eine Projektmappe (Solution) aus vier Projekten: eines pro Schicht, plus ein Unit-Test-Projekt. Sie wird mit den folgenden Befehlen erstellt, die im Ordner [TaxV5] eingegeben werden:
- [dotnet new classlib] erstellt ein Klassenbibliotheksprojekt: Seine Kompilierung erzeugt eine DLL-Datei, keine ausführbare Datei. Die Vorlage erzeugt eine Datei [Class1.cs], die wir löschen;
- [dotnet new mstest] erstellt ein Testprojekt, MSTest, das später beschrieben wird;
- [dotnet new sln --format slnx] erstellt die Solution-Datei [TaxV5.slnx] im XML-Format, das vom SDK in .NET 9 eingeführt wurde. Seit .NET 10 ist dies das Standardformat von [dotnet new sln] ; die Option [--format slnx] macht es daher lediglich explizit; [dotnet sln add] fügt die Projekte hinzu;
- [dotnet add reference] fügt eine Projekt-zu-Projekt-Referenz hinzu: Die [business]-Schicht verwendet die [dao]-Schicht, die [ui]-Schicht verwendet die beiden anderen, ebenso die Tests.
Daraus ergibt sich die folgende Baumstruktur:
Die Solution-Datei sieht wie folgt aus:
Der Befehl [dotnet build TaxV5.slnx] kompiliert die vier Projekte in der Reihenfolge, die durch ihre Referenzen vorgegeben ist: zuerst [Tax.Dao] , dann [Tax.Business], dann [Tax.Ui] und schließlich [Tax.Tests].
6.4.2. Die [dao]-Schicht
Das Projekt [Tax.Dao] enthält die [dao]-Schicht und die Entitäten der Anwendung. Seine Projektdatei sieht wie folgt aus:
- Zeilen 4–6: die von [dotnet new classlib] erzeugten Eigenschaften. Es gibt kein Tag [OutputType]: Das Projekt erzeugt eine Bibliothek [Tax.Dao.dll];
- Zeilen 12–13: Die Datendateien werden in den Build-Ordner kopiert. So gekennzeichnete Dateien werden auch in den Build-Ordner jedes Projekts kopiert, das [Tax.Dao] referenziert: Die Projekte [Tax.Ui] und [Tax.Tests] verfügen über die Datendateien, ohne sie deklarieren zu müssen.
Entitäten
Die Struktur [TaxBracket] und die Klasse [TaxException] stammen aus Version 4. Lediglich die Enumeration [ErrorCode] wird aus der Datei entfernt: [TaxException] wird dadurch allen Implementierungen der [dao]-Schicht gemeinsam, ohne an die Codes einer einzelnen von ihnen gebunden zu sein:
- Zeile 7: Der Fehlercode bleibt eine einfache Ganzzahl: Jede Implementierung der [dao]-Schicht definiert ihre eigenen Codes.
Die [FileTax]-Implementierung
Die Schnittstelle [ITaxDao] und die Klasse [HardwiredTax] stammen aus Version 4. Die Klasse [FileTax] unterscheidet sich nur durch den Ort ihrer Fehlercodes:
- Zeilen 11–12: Die Fehlercodes, die sich zuvor in der Enumeration [ErrorCode] im Namespace [Entities] befanden, wurden in die Klasse [FileTax] verschoben, und zwar in Form einer verschachtelten Enumeration [ErrorCodes]: Es handelt sich nämlich um Codes, die für diese Implementierung der Schnittstelle [ITaxDao] spezifisch sind ([JsonTax] hat eigene). Sie werden innerhalb der Klasse als [ErrorCodes.Field1] und außerhalb als [FileTax.ErrorCodes.Field1] geschrieben. Die Direktive [using static] aus Version 4 wird nicht mehr benötigt.
Weiter unten im Konstruktor:
- Zeilen 63, 72: Fehler werden in einer [TaxException] gekapselt. Der Fehlercode vom Typ [ErrorCodes] wird durch [(int)code] in eine Ganzzahl umgewandelt.
Die [JsonTax]-Implementierung
Im vorherigen Kapitel wurde gezeigt, wie Daten im JSON-Format mit [System.Text.Json] gelesen werden. Die dritte Implementierung der [dao]-Schicht liest die Steuerstufen aus der folgenden Datei [TaxData.json]:
Die Klasse [JsonTax] sieht wie folgt aus:
- Zeile 11: Fehlercodes für diese Implementierung: Dateizugriffsfehler oder fehlerhafter Inhalt;
- Zeilen 27–31: Die Datei wird vollständig in eine Zeichenkette gelesen, mit derselben E/A-Fehlerbehandlung wie in [FileTax];
- Zeile 43: Die JSON-Zeichenkette wird in ein Array [TaxBracket[]] umgewandelt. Der zweite Parameter, [BracketsJsonContext.Default.TaxBracketArray], liefert den Deserialisierungscode für diesen Typ;
- Zeile 44: [Deserialize] liefert [null] , wenn die Datei das JSON-Literal [null] enthält; der Ausdruck [?? throw] (C# 7) löst dann eine Ausnahme aus;
- Zeilen 46–50: Eine Datei, die kein JSON-Array von Stufen ist, verursacht eine [JsonException], die in eine [TaxException] mit dem Code [Format] gekapselt wird;
- Zeilen 58–60: Ohne einen Parameter dieses Typs ermittelt [JsonSerializer] die Eigenschaften von [TaxBracket] zur Laufzeit per Reflexion. Hier weist das Attribut [JsonSerializable] den Compiler an, innerhalb der partiellen Klasse [BracketsJsonContext] den (De-)Serialisierungscode für den Typ [TaxBracket[]] zu generieren. Dieser Code ist schneller und funktioniert auch in Anwendungen, die zu nativem Code kompiliert werden (AOT), in denen die Reflexion deaktiviert ist – das ist das Standardverhalten der Single-File-Anwendungen von .NET 10, die wir verwenden werden. Die Option [JsonSerializerDefaults.Web] ordnet die camelCase-JSON-Namen ([limit]) den C#-Eigenschaften ([Limit]) zu. Beachten Sie, dass [System.Text.Json] ein positionales [record struct] durch Aufruf seines Konstruktors erstellen kann.
Ein Testprogramm
Bevor wir automatisierte Tests schreiben, führen wir einen ersten visuellen Test der [dao]-Schicht durch. .NET 10 erlaubt es einer Single-File-Anwendung, mit der Direktive [#:project] auf ein Projekt zu verweisen. Das Programm [Trials/trial-dao.cs] zeigt die Stufen an, die von den drei Implementierungen geliefert werden:
- Zeile 1: Das Programm verwendet das Projekt [Tax.Dao]. Dieses Projekt wird zusammen mit dem Programm kompiliert, und seine Datendateien werden neben die ausführbare Datei des Testprogramms kopiert. Achtung: Wenn Sie das referenzierte Projekt anschließend ändern, ohne das Programm zu ändern, kann [dotnet run trial-dao.cs] die bereits erstellte ausführbare Datei wiederverwenden; die Option [--no-cache] erzwingt dann eine neue Kompilierung;
- Zeile 8: ein Array der drei Implementierungen der Schnittstelle [ITaxDao];
- Zeile 11: [GetType] liefert den tatsächlichen Typ des Objekts, dessen Klassenname [Name] lautet;
- Zeilen 18–22: Behandlung einer möglichen [TaxException].
Ergebnisse:
Alle drei Implementierungen liefern dieselben Stufen. Die Darstellung der Zahlen [decimal] folgt der Locale en-US des Benutzers: Dezimalpunkt.
6.4.3. Die [business]-Schicht
Die Projektdatei [Tax.Business.csproj] sieht wie folgt aus:
- Zeile 11: der Verweis auf das Projekt [Tax.Dao], der von [dotnet add reference] hinzugefügt wurde. Im Kurs von 2008 referenzierte man die kompilierte DLL der Schicht [dao], die aus einem Ordner namens [bin] geholt werden musste; eine Projekt-zu-Projekt-Referenz kompiliert [Tax.Dao] vor [Tax.Business] und verwendet immer die neueste Version.
Die Schnittstelle [ITaxBusiness] und die Klasse [TaxBusiness] stammen aus Version 4. Das Testprogramm [Trials/trial-business.cs] führt einige Steuerberechnungen durch:
- Zeile 1: Das Programm referenziert das Projekt [Tax.Business]; da dieses Projekt [Tax.Dao] referenziert, hat das Programm auch Zugriff auf die Schicht [dao] und ihre Funktionen;
- Zeile 9: Erstellung der Schichten [dao] und [business] . Die Schicht [dao] wird von der Klasse [FileTax] implementiert;
- Zeilen 10–13: wiederholte Aufrufe der einzigen Methode der Schnittstelle [ITaxBusiness].
Ergebnisse:
Ein Ehepaar mit 2 Kindern und eine alleinstehende Person mit 3 Kindern haben dieselbe Anzahl an Anteilen (3): Ihre Steuern sind gleich.
6.4.4. Unit-Tests mit MSTest
6.4.4.1. Das Prinzip
Die bisher durchgeführten Tests beruhten auf visueller Überprüfung: Wir haben kontrolliert, dass der Bildschirm die erwarteten Ergebnisse anzeigte. Diese Methode ist bei vielen auszuführenden Tests unpraktikabel: Menschen ermüden, und ihre Fähigkeit, Ergebnisse zu überprüfen, lässt im Laufe des Tages nach. Die Tests müssen daher automatisiert werden und ohne menschliches Eingreifen ablaufen.
Eine Anwendung entwickelt sich im Lauf der Zeit weiter. Bei jeder Änderung muss überprüft werden, dass sie nicht „regrediert“, das heißt, dass sie weiterhin die Funktionstests besteht, die bei ihrer ursprünglichen Entwicklung durchgeführt wurden. Diese Tests heißen Regressionstests. Eine mittelgroße Anwendung kann Hunderte von Tests erfordern: Tatsächlich wird jede Methode jeder Klasse der Anwendung getestet. Man spricht dann von Unit-Tests.
Für die Automatisierung dieser Tests wurden Frameworks entwickelt. Der Kurs von 2008 verwendete NUnit 2.4 und dessen grafische Benutzeroberfläche. Hier verwenden wir MSTest, das Test-Framework von Microsoft, in Version 4 (NUnit und xUnit sind zwei weitere weit verbreitete Frameworks, die nach demselben Prinzip arbeiten). Die Tests werden über die Befehlszeile mit dem Befehl [dotnet test] ausgeführt: So lassen sie sich automatisch starten, zum Beispiel bei jeder Bereitstellung von Codeänderungen auf einem Continuous-Integration-Server. Die integrierten Entwicklungsumgebungen (Visual Studio, VS Code, Rider) verfügen außerdem über einen Test-Explorer, der die Tests in einer Baumstruktur anzeigt.
6.4.4.2. Ein erstes Beispiel
Betrachten wir das Prinzip von MSTest-Tests anhand eines Beispiels. Wir erstellen ein Testprojekt mit dem Befehl:
Die Vorlage erstellt eine Projektdatei, die wir so ändern, dass Version 4.0.2 von MSTest verwendet wird:
- Zeile 11: Das Projekt verwendet das NuGet-Paket [MSTest]. Dieses Paket enthält das Framework (die Attribute und die Klasse [Assert]), den Adapter, der es [dotnet test] ermöglicht, die Tests zu finden und auszuführen, sowie Code-Analyzer, die bei schlecht geschriebenen Tests Warnungen ausgeben;
- Zeile 15: ein globales [using]: Der Namespace [Microsoft.VisualStudio.TestTools.UnitTesting] von MSTest wird in alle Dateien des Projekts importiert.
Die Vorlage erstellt außerdem eine Datei [MSTestSettings.cs], die festlegt, dass die Tests parallel ausgeführt werden. Wir ersetzen sie durch die folgende Datei, damit die Tests nacheinander laufen und ihre Ergebnisse in einer konsistenten Reihenfolge erscheinen:
- Zeile 2: ein Attribut, das für die gesamte Assembly (DLL) gilt und nicht für eine bestimmte Klasse.
Die Testklasse [Tests1] sieht wie folgt aus:
- Zeile 4: Das Attribut [TestClass] zeigt an, dass die Klasse Tests enthält. Sie muss öffentlich sein;
- Zeile 8: die zu testende Methode. In einem realen Projekt befände sie sich in einem anderen Projekt, das vom Testprojekt referenziert wird;
- Zeilen 11–13: der Konstruktor. Er dient nur dazu, eine Meldung auf dem Bildschirm auszugeben: Wir wollen sehen, wann er ausgeführt wird;
- Zeile 17: Das Attribut [TestInitialize] kennzeichnet eine Methode, die vor jedem Test ausgeführt wird;
- Zeile 24: Das Attribut [TestCleanup] kennzeichnet eine Methode, die nach jedem Test ausgeführt wird;
- Zeile 31: Das Attribut [TestMethod] kennzeichnet eine Testmethode. Eine Testmethode ist öffentlich, gibt nichts zurück (oder einen [Task] , wenn sie asynchron ist) und hat, bis auf eine Ausnahme, die wir noch besprechen, keine Parameter;
- Zeile 35: Die Methode [Assert.AreEqual(expected, actual)] überprüft, dass der erhaltene Wert dem erwarteten Wert entspricht. Ist das nicht der Fall, löst sie eine Ausnahme aus, und der Test schlägt fehl. Hier muss die Zusicherung erfüllt sein;
- Zeile 43: Diese Zusicherung muss fehlschlagen. Der dritte Parameter ist die Meldung, die im Fehlerfall angezeigt wird.
Die Tests werden mit dem Befehl [dotnet test] im Projektordner ausgeführt. Die Option [--logger "console;verbosity=detailed"] zeigt die Details jedes Tests an, einschließlich seiner Bildschirmausgaben:
- Zeile 8: Der Test [T1] wurde bestanden;
- Zeilen 10–13: seine Bildschirmausgaben: Der Konstruktor wurde ausgeführt, gefolgt von der Methode [Before], dem Test und schließlich der Methode [After];
- Zeile 16: Der Test [T2] ist fehlgeschlagen;
- Zeile 18: die Fehlermeldung: der erwartete Wert, der tatsächliche Wert, die Ausdrücke, die sie erzeugt haben, und die an [Assert.AreEqual] übergebene Meldung;
- Zeile 19: MSTest zeigt außerdem den Aufrufstapel zum Zeitpunkt des Fehlers an, der zur fehlerhaften Zeile führt. Wir haben ihn aus der Ausgabe entfernt;
- Zeilen 22–25: Die Ausgabe des Tests [T2]. Beachten Sie, dass der Konstruktor erneut ausgeführt wurde: MSTest erstellt für jeden Test eine neue Instanz der Testklasse. Die Tests sind somit voneinander unabhängig: Ein Test kann nicht vom Zustand beeinflusst werden, den ein anderer Test hinterlassen hat. NUnit hingegen führte den Konstruktor nur einmal aus;
- Zeilen 28–34: die Tests der Klasse [Tests2], die weiter unten gezeigt wird;
- Zeilen 36–39: die Ergebnisse: 8 Tests bestanden und 1 fehlgeschlagen. Der Befehl [dotnet test] endet dann mit einem Exitcode ungleich null, anhand dessen ein Skript den Fehlschlag erkennen kann.
Um nur eine Teilmenge der Tests auszuführen, verwenden Sie die Option [--filter]: [dotnet test --filter Name=T1] führt nur den Test [T1] aus, während [dotnet test --filter ClassName=DemoTests.Tests2] führt die Tests der Klasse [Tests2] aus.
6.4.4.3. Weitere Zusicherungen
Die Klasse [Assert] hat viele Methoden. Die Klasse [Tests2] enthält einige davon:
- Zeilen 12–13: prüfen, ob ein boolescher Ausdruck wahr oder falsch ist;
- Zeilen 16–17: prüfen, ob eine Referenz ungleich null oder gleich null ist;
- Zeilen 18–19: prüfen, ob zwei Referenzen auf dasselbe Objekt verweisen;
- Zeilen 27–28: Berechnungen mit reellen Zahlen vom Typ [double] sind ungenau: [0.1 + 0.2] ist nicht exakt gleich [0.3]. Wir vergleichen zwei reelle Zahlen daher mit einer gewissen Fehlertoleranz, hier einem Millionstel;
- Zeilen 36–40: Zusicherungen für Zeichenketten und Sammlungen, die von neueren MSTest-Versionen hinzugefügt wurden. Sie erzeugen präzisere Fehlermeldungen als [Assert.IsTrue(message.StartsWith("Line"))];
- Zeilen 48–49: [Assert.ThrowsExactly<T>(action)] führt die Aktion – eine anonyme Funktion [() => ...] – aus und überprüft, dass sie eine Ausnahme genau vom Typ [T] auslöst. Sie gibt die ausgelöste Ausnahme zurück, sodass sich anschließend deren Eigenschaften überprüfen lassen. Die Variante [Assert.Throws<T>] akzeptiert auch Ausnahmen von Typen, die von [T] abgeleitet sind;
- Zeilen 55–58: ein parametrisierter Test. Die Testmethode hat Parameter, und jedes Attribut [DataRow] liefert einen Satz von Werten für diese Parameter. Der Test wird einmal pro Attribut [DataRow] ausgeführt: Das zeigten die Zeilen [T7 (1,1,2)], [T7 (2,3,5)], und [T7 (-1,1,0)] der vorherigen Ergebnisse.
Fassen wir die wichtigsten Methoden der Klasse [Assert] zusammen:
Methode | Prüft, dass |
Assert.AreEqual(expected, actual) | die beiden Werte gleich sind (Methode Equals) |
Assert.AreEqual(actual1, actual2, delta) | die beiden tatsächlichen Werte bis auf delta gleich sind |
Assert.AreNotEqual(v1, v2) | die beiden Werte verschieden sind |
Assert.AreSame(o1, o2), Assert.AreNotSame(o1, o2) | die beiden Referenzen auf dasselbe Objekt verweisen bzw. nicht verweisen |
Assert.IsNull(o), Assert.IsNotNull(o) | die Referenz gleich null (bzw. nicht null) ist |
Assert.IsTrue(b), Assert.IsFalse(b) | der boolesche Ausdruck wahr (bzw. falsch) ist |
Assert.IsInstanceOfType<T>(o) | das Objekt vom Typ T oder von einem abgeleiteten Typ ist |
Assert.HasCount(n, collection) | die Sammlung n Elemente hat |
Assert.Contains(element, collection) | die Sammlung (oder Zeichenkette) das Element enthält |
Assert.StartsWith(start, string) | die Zeichenkette mit start beginnt |
Assert.ThrowsExactly<T>(action) | die Aktion genau eine Ausnahme vom Typ T auslöst |
CollectionAssert.AreEqual(c1, c2) | die beiden Sammlungen dieselben Elemente in derselben Reihenfolge enthalten |
Alle diese Methoden akzeptieren einen optionalen letzten Parameter: die Meldung, die im Fehlerfall angezeigt wird.
6.4.4.4. Tests für die [dao]-Schicht
Kehren wir zur Anwendung [Tax] zurück. Das Projekt [Tax.Tests] wurde mit [dotnet new mstest] erstellt. Seine Projektdatei sieht wie folgt aus:
- Zeilen 17–18: die getesteten Schichten;
- Zeile 27: eine fehlerhafte Datendatei, mit der Fehler getestet werden. Die Dateien [TaxData.txt] und [TaxData.json] werden über die Referenz auf das Projekt [Tax.Dao] kopiert.
Die Datei [MSTestSettings.cs] gehört zum Projekt [DemoTests]. Die Klasse [DaoTests] testet die Schicht [dao]:
- Zeilen 11–16: eine Methode, die anhand ihres Klassennamens eine [dao]-Schicht erstellt, mithilfe eines [switch]-Ausdrucks (C# 8);
- Zeilen 21–24: Derselbe Test wird für alle drei Implementierungen ausgeführt. Er überprüft, dass es 7 Stufen gibt, und kontrolliert den Wert der Stufe Nr. 2 (der dritten). Die erwarteten Werte werden mit dem Suffix [M] geschrieben: Es sind [decimal]-Werte, genau wie die verglichenen Eigenschaften;
- Zeilen 36–40: Alle drei Implementierungen liefern exakt dieselben Stufen. [CollectionAssert.AreEqual] vergleicht die Arrays Element für Element; der Vergleich zweier [TaxBracket] -Werte ist ein Wertvergleich, der vom Compiler für einen [record struct] generiert wird;
- Zeilen 45–49: Eine fehlende Datei löst eine [TaxException] mit dem Code [Access] aus, die eine [FileNotFoundException] kapselt;
- Zeilen 54–58: Die Datei [TaxDataInvalid.txt] führt zu einer [TaxException] , deren Code die Bits von [Field2] und [Field3] kombiniert;
- Zeilen 63–66: dieselbe Überprüfung für die Implementierung [JsonTax].
6.4.4.5. Tests für die [business]-Schicht
Die Klasse [BusinessTests] testet die [business]-Schicht:
- Zeilen 12–17: Die getestete [business]-Schicht ist auf der [dao]-Schicht [HardwiredTax] aufgebaut, die von keiner Datei abhängt. Da MSTest für jeden Test eine neue Instanz der Klasse erstellt, verfügt jeder Test über brandneue Schichten;
- Zeilen 22–28: Berechnungen, deren Ergebnisse bekannt sind. Dies sind die Kontrollwerte der Anwendung, die bereits mit früheren Versionen ermittelt wurden: Sie müssen in allen künftigen Versionen korrekt bleiben;
- Zeilen 35–39: Die Steuerberechnung verändert die von der [dao]-Schicht gelieferten Steuerstufen nicht. Vor einer Berechnung, die die letzte Stufe verwendet, wird eine Kopie ([.. dao.TaxBrackets]) angelegt, und anschließend werden die Ergebnisse verglichen. Der Test hält den Fehler der Version von 2008 fest: Würde jemand ihn wieder einführen, schlüge dieser Test Alarm;
- Zeilen 44–47: negative Parameter werden abgelehnt;
- Zeilen 51–53: eine Dummy-Schicht [dao], wie sie der Entwickler der Schicht [business] verwenden würde, bevor die echte Schicht [dao] fertig ist: eine einzige Steuerstufe, ein Steuersatz von 10 % des zu versteuernden Einkommens. Dies ist eine in der Testklasse verschachtelte Klasse;
- Zeilen 58–62: Die [business]-Schicht arbeitet mit der Dummy-Schicht [dao]. Die Schicht [business] wird somit für sich allein getestet, unabhängig von den tatsächlichen Implementierungen der [dao]-Schicht.
6.4.4.6. Ausführung der Tests
Im Ordner [Tax.Tests]:
Alle 16 Tests wurden bestanden: Jedes Attribut [DataRow] zählt als ein Test. Wir betrachten die Schichten [dao] und [business] nun als einsatzbereit. Anders als 2008 müssen die DLL-Schichten nicht neu erstellt werden, um die Testklassen auszuschließen: Die Tests befinden sich in einem separaten Projekt, und die Bibliotheken [Tax.Dao.dll] und [Tax.Business.dll] enthalten nur den Code der Schichten. Der Befehl [dotnet test TaxV5.slnx], im Solution-Ordner ausgeführt, startet die Tests aller Testprojekte der Solution.
6.4.5. Die [ui]-Schicht
Die Projektdatei [Tax.Ui.csproj] sieht wie folgt aus:
- Zeile 4: Das Projekt erzeugt eine ausführbare Datei;
- Zeilen 12–13: Die [ui]-Schicht verwendet die Schichten [business] und [dao];
- Zeilen 18–19: zwei NuGet-Pakete – der Dependency-Injection-Container und der Leser für JSON-Konfigurationsdateien. Sie wurden mit den Befehlen [dotnet add package Microsoft.Extensions.DependencyInjection --version 10.0.12] und [dotnet add package Microsoft.Extensions.Configuration.Json --version 10.0.12] hinzugefügt;
- Zeile 24: Die Konfigurationsdateien werden neben die ausführbare Datei kopiert.
Die Klasse [Dialog] stammt aus Version 4 und wurde um eine Methode ergänzt, die eine Ausnahme und alle von ihr gekapselten Ausnahmen anzeigt:
- Zeile 63: eine Zeichenkette aus 40 Bindestrichen, erzeugt durch den Konstruktor [string(char c, int count)];
- Zeile 65: Die Schleife durchläuft die Kette der Ausnahmen: Jede Ausnahme gibt über ihre Eigenschaft [InnerException] Zugriff auf die Ausnahme, die sie kapselt, bis zur letzten, bei der [InnerException] gleich [null] ist. Der Typ [Exception?] zeigt an, dass die Variable [e] gleich [null] sein kann;
- Zeile 67: Für jede Ausnahme werden der vollständige Name ihrer Klasse (einschließlich des Namespace) und ihre Meldung angezeigt.
Die Klasse [Dialog] ist öffentlich: Spätere Versionen der Anwendung, die die [dao]-Schicht ändern, werden die Schicht [ui] wiederverwenden, indem sie das Projekt [Tax.Ui] referenzieren und [Dialog.Run(business)] aufrufen.
6.4.6. Integration der Schichten per Dependency Injection
In Version 4 erstellte das Hauptprogramm die Schichten [dao] und [business] , indem es ihre Implementierungsklassen nannte:
Abgesehen von diesen Zeilen ändert sich in der Anwendung nichts, wenn sich die Implementierung einer Schicht ändert, da jede Schicht über eine Schnittstelle mit der nächsten kommuniziert. Wir können die Unabhängigkeit der Schichten noch weiter treiben, indem wir ihre Erstellung einem Dependency-Injection-Container überlassen und die Wahl der Implementierung der Schicht [dao] in eine Konfigurationsdatei verlagern. Der Wechsel der Implementierung dieser Schicht besteht dann lediglich darin, diese Datei zu ändern, ohne die Anwendung neu zu kompilieren.

Im obigen Beispiel fordert die [ui]-Schicht [0] die [business]-Schicht beim Dependency-Injection-Container an. Um sie zu erstellen, erzeugt der Container zunächst die Schicht [dao] [1], dann die Schicht [business] [2], der er die Schicht [dao] übergibt. Schließlich gibt er eine Referenz auf die Schicht [business] [3] an die Schicht [ui] zurück.
6.4.6.1. Die Konfigurationsdatei
Die Wahl der Implementierung der Schicht [dao] wird in der Datei [appsettings.json] festgelegt:
- Zeile 2: Ein Abschnitt [Dao] enthält die Konfiguration der Schicht [dao];
- Zeile 3: Die Klasse, die die Schicht [dao] implementiert: [HardwiredTax], [FileTax], oder [JsonTax];
- Zeile 4: die Datendatei, bei Implementierungen, die eine lesen.
[appsettings.json] ist der Standardname der Konfigurationsdatei von .NET-Anwendungen, insbesondere von ASP.NET-Core-Anwendungen. Sie ersetzt die XML-Dateien [App.config] des .NET Framework, die im Studienjahr 2008 von Spring.NET verwendet wurden. Das Projekt enthält drei weitere Konfigurationsdateien, die das Programm verwendet, wenn ihre Namen als Argumente übergeben werden:
6.4.6.2. Das Hauptprogramm
Das Hauptprogramm [Program.cs] des Projekts [Tax.Ui] sieht wie folgt aus:
- Zeile 9: der Name der Konfigurationsdatei: standardmäßig [appsettings.json] oder die als Argument übergebene;
- Zeilen 16–19: Lesen der Konfiguration. [ConfigurationBuilder] stellt eine Konfiguration aus Quellen zusammen: hier eine einzige JSON-Datei ([AddJsonFile]), die sich im Ordner der ausführbaren Datei befindet ([SetBasePath]). Der Parameter [optional: false] (ein benannter Parameter, C# 4) macht die Datei verpflichtend: Ihr Fehlen löst eine [FileNotFoundException] aus;
- Zeilen 20–21: Die Konfiguration wird als Dictionary gelesen. Der Schlüssel [Dao:Implementation] bezeichnet die Eigenschaft [Implementation] des Abschnitts [Dao]; das Trennzeichen zwischen den Ebenen ist der Doppelpunkt. Der Indexer liefert [null] , wenn der Schlüssel nicht existiert: Der Operator [??] liefert dann einen Standardwert;
- Zeile 24: die Service-Collection, das heißt die Liste der Typen, die der Container erstellen kann, und wie er sie erstellt;
- Zeilen 26–31: die Registrierung der [dao]-Schicht. [AddSingleton<ITaxDao>(factory)] bedeutet: Wenn ein [ITaxDao] angefordert wird, ruft der Container die Funktion [factory] auf, um es zu erstellen. „Singleton“ bedeutet, dass das Objekt nur ein einziges Mal beim ersten Anfordern erstellt wird und alle weiteren Anforderungen dasselbe Objekt zurückgeben: Es gibt in der Anwendung nur eine [dao]-Schicht. Die Factory wählt die Klasse anhand der Konfiguration mit dem Ausdruck [switch] aus; ihr Parameter, der Container selbst, wird hier nicht verwendet, daher der Name [_] („Discard“). Eine unbekannte Implementierung führt zu einer [TaxException];
- Zeile 34: die Registrierung der [business]-Schicht: Wenn ein [ITaxBusiness] angefordert wird, erstellt der Container ein Objekt [TaxBusiness]. Dazu untersucht er den Konstruktor der Klasse [TaxBusiness], stellt fest, dass dieser ein [ITaxDao] erwartet, und übergibt ihm die oben registrierte [dao]-Schicht: Das ist Dependency Injection. Die [dao]-Schicht ist eine Abhängigkeit der [business]-Schicht;
- Zeile 37: Erstellung des Containers aus der Service-Collection;
- Zeile 38: Beim Container wird die [business]-Schicht angefordert. Der Container erstellt die [dao]-Schicht und dann die [business]-Schicht. [GetRequiredService] löst eine Ausnahme aus, wenn der angeforderte Typ nicht registriert wurde. Beachten Sie, dass die Schicht [ui] die Schicht [business] erhält, ohne die Klasse anzugeben, die sie implementiert;
- Zeilen 40–44: Etwaige Konfigurations- oder Schichterstellungsfehler werden zusammen mit dem Stack Trace der Ausnahme angezeigt, und das Programm endet;
- Zeile 48: die Benutzeroberfläche, identisch mit der von Version 4.
Der Kurs von 2008 enthielt in der Konfigurationsdatei die vollständigen Namen der zu instanziierenden Klassen ([Dao.FileTax, TaxV5-dao]): Spring.NET erstellte sie per Reflexion. Wir haben uns stattdessen dafür entschieden, die möglichen Implementierungen in der Factory zu definieren: Die Konfigurationsdatei wählt lediglich unter ihnen aus, und der Compiler überprüft, dass die Klassen existieren und über die erforderlichen Konstruktoren verfügen. In beiden Fällen gibt der Code der Schichten [ui] und [business] niemals die Klasse an, die die Schicht [dao] implementiert.
6.4.6.3. Ausführungen
Mit der Datei [appsettings.json] (Implementierung [FileTax]):
Mit der Implementierung [JsonTax]:
Mit der Implementierung [HardwiredTax]:
Wir haben die Implementierung der Schicht [dao] gewechselt, ohne eine einzige Codezeile zu ändern oder die Anwendung neu zu kompilieren.
Mit der Datei [appsettings-error.json], die auf eine nicht vorhandene Datendatei verweist:
- Zeile 6: die ursprüngliche Ausnahme vom Typ [FileNotFoundException], ausgelöst von der Klasse [FileTax];
- Zeile 4: Die Schicht [dao] hat sie in eine [TaxException] gekapselt. Diese Ausnahme wurde über den Aufruf [GetRequiredService] bis zum Hauptprogramm weitergereicht.
Der .NET-Container reicht Ausnahmen, die bei der Objekterstellung ausgelöst werden, unverändert durch. Mit Spring.NET erzeugte derselbe Fehler eine Kette von acht Ausnahmen, von denen sechs vom Framework stammten ([ConfigurationErrorsException], [ObjectCreationException], [TargetInvocationException] usw.), gefolgt von den beiden oben genannten Ausnahmen. Die wichtigste Lehre aus dieser Kette ist, dass oft die tiefste Ausnahme – die zuletzt angezeigte – die aussagekräftigste ist.
Dependency Injection verdient allein schon ein eigenes Kapitel. Wir haben nur das Wesentliche verwendet: das Registrieren von Services ([AddSingleton]), das Erstellen des Containers ([BuildServiceProvider]) und das Abrufen eines Services ([GetRequiredService]). Der Container kann auch für jede Anforderung ein neues Objekt erstellen ([AddTransient]) oder ein Objekt pro „Scope“, etwa pro (HTTP-)Anfrage in einer Webanwendung ([AddScoped]). Wir werden ihm in den ASP.NET-Core-Anwendungen wiederbegegnen, wo er allgegenwärtig ist. Sie können dieses Thema in der Dokumentation von Microsoft vertiefen: Dependency Injection .NET.
6.5. Fazit
Dieses Kapitel hat der Anwendung [Tax] die Architektur gegeben, die sie bis zum Ende des Kurses behalten wird:
- eine [dao]-Schicht, die die Steuerstufen über die Schnittstelle [ITaxDao] bereitstellt;
- eine [business]-Schicht, die die Steuer berechnet und mit der Schicht [dao] nur über deren Schnittstelle interagiert;
- eine Schicht [ui] , die mit dem Benutzer interagiert und die Schicht [business] nur über ihre Schnittstelle [ITaxBusiness] kennt;
- ein Hauptprogramm – das einzige, das die Implementierungsklassen kennt –, das die Schichten erstellt und verbindet, in diesem Fall mithilfe eines Dependency-Injection-Containers und einer Konfigurationsdatei;
- automatisierte Unit-Tests, die jede Schicht unabhängig von den anderen überprüfen und die Regressionsfreiheit der Anwendung sicherstellen.
Die Vorteile dieser Architektur werden in den folgenden Kapiteln voll zur Geltung kommen, in denen die Bibliotheken [Tax.Dao], [Tax.Business] und [Tax.Ui] aus Version 5 über Projektreferenzen unverändert wiederverwendet werden:
- Version 6 (Kapitel ADO.NET): Eine neue Implementierung, [MySqlTax], der Schicht [dao] liest die Steuerstufen aus einer MySQL-Datenbank. Die Schichten [business] und [ui] bleiben unverändert;
- Version 7 (Kapitel Entity Framework Core): Eine Implementierung [EfTax] der Schicht [dao] verwendet den ORM Entity Framework Core, um auf dieselbe Datenbank zuzugreifen;
- Version 8 (Kapitel Internet): Die Schicht [business] wird auf einem TCP-Server installiert, der Steuern für entfernte Clients berechnet; dies ist somit eine „Three-Tier“-Architektur im strengen Sinne;
- Version 9 (Kapitel Webservices): Die Schicht [business] wird von einem mit ASP.NET Core geschriebenen REST/JSON-Webservice bereitgestellt, dessen Konsolenclient [HttpClient] verwendet.
Jedes Mal beschränkt sich die Arbeit darauf, die neue Schicht zu schreiben und das Programm zu ändern, das die Schichten integriert: Das ist der ganze Sinn einer Schichtenarchitektur.