Skip to content

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:

// Erzeugung eines ITax-Objekts aus einer Text- oder JSON-Datei
ITax tax;
try
{
    tax = Path.GetExtension(fileName).ToLower() switch
    {
        ".json" => new JsonTax(path),
        _ => new FileTax(path)
    };
}
catch (TaxException e)
{
    Console.WriteLine($"The following error occurred: [Code={(ErrorCode)e.Code}, Message={e.Message}]");
    return 1;
}
// Eingabeschleife
while (true)
{
    Console.Write("Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: ");
    string parameters = (Console.ReadLine() ?? "").Trim();
    ...
    // die Parameter sind korrekt: wir berechnen die Steuer
    Console.WriteLine($"Tax={tax.Calculate(married == "y", nbChildren, salary)} euros");
}

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:

Image

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:

Image

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:

Image

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:

1
2
3
B1 b1 = new B1(...);
...
b1.GetData(...);
  • 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:

Image

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:

1
2
3
IB ib = new B1(...);
...
ib.GetData(...);
  • 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:

Image

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:

1
2
3
4
5
6
7
8
9
// die Schicht [A] erhält die Schicht [B] über ihren Konstruktor
public class A(IB ib)
{
    public void Work()
    {
        ...
        ib.GetData(...);
    }
}
  • 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:

using Entities;

namespace Dao;

// die Schnittstelle der Schicht [dao]
public interface ITaxDao
{
    // die Steuerstufen
    TaxBracket[] TaxBrackets { get; }
}
  • 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:
1
2
3
4
namespace Entities;

// eine Steuerstufe: eine unveränderliche Struktur
public readonly record struct TaxBracket(decimal Limit, decimal CoeffR, decimal CoeffN);

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:

1
2
3
4
5
6
7
namespace Business;

// die Schnittstelle der Schicht [business]
public interface ITaxBusiness
{
    int CalculateTax(bool married, int nbChildren, int salary);
}
  • 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:

> dotnet new console -n TaxV4 -o TaxV4

Jede Schicht belegt einen eigenen Ordner:

TaxV4/
  TaxV4.csproj
  Program.cs                 integration of the layers
  TaxData.txt                the tax brackets
  TaxDataInvalid.txt         an incorrect brackets file
  Entities/
    TaxBracket.cs
    TaxException.cs
  Dao/
    ITaxDao.cs
    HardwiredTax.cs
    FileTax.cs
  Business/
    ITaxBusiness.cs
    TaxBusiness.cs
  Ui/
    Dialog.cs
  • 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:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <!-- die Datendateien werden neben die ausführbare Datei kopiert -->
    <None Update="TaxData*.txt" CopyToOutputDirectory="PreserveNewest" />
  </ItemGroup>

</Project>
  • 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

Image

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:

namespace Entities;

// die Fehlercodes der Schicht [dao]: Zweierpotenzen, die kombiniert werden können
[Flags]
public enum ErrorCode { Access = 1, Line = 2, Field1 = 4, Field2 = 8, Field3 = 16 }

// die von der Schicht [dao] ausgelöste Exception
public class TaxException : Exception
{
    // Fehlercode (eine Kombination von ErrorCode-Werten)
    public int Code { get; init; }

    // Konstruktoren
    public TaxException(string message) : base(message) { }
    public TaxException(string message, Exception inner) : base(message, inner) { }
}
  • 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:

using Entities;

namespace Dao;

// die Schnittstelle der Schicht [dao]
public interface ITaxDao
{
    // die Steuerstufen
    TaxBracket[] TaxBrackets { get; }
}

Wir implementieren diese Schnittstelle auf zwei verschiedene Weisen. Zunächst mit der Klasse [HardwiredTax]:

using Entities;

namespace Dao;

// eine Schicht [dao], deren Daten fest einprogrammiert sind
public class HardwiredTax : ITaxDao
{
    // Steuerstufen (Steuertarif 2004 auf Einkommen 2003)
    public TaxBracket[] TaxBrackets { get; } =
    [
        new(4962M, 0M, 0M),
        new(8382M, 0.068M, 291.09M),
        new(14753M, 0.191M, 1322.92M),
        new(23888M, 0.283M, 2668.39M),
        new(38868M, 0.374M, 4846.98M),
        new(47932M, 0.426M, 6883.66M),
        new(0M, 0.481M, 9505.54M),
    ];
}
  • 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:

1
2
3
4
5
6
7
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54

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:

using System.Globalization;
using Entities;
using static Entities.ErrorCode;

namespace Dao;

// eine Schicht [dao], die die Steuerstufen aus einer Textdatei liest
// eine Zeile pro Stufe: limit:coeffR:coeffN (Dezimalpunkt)
public class FileTax : ITaxDao
{
    // Datendatei, relativ zum Ordner der ausführbaren Datei
    public string FileName { get; }

    // Steuerstufen
    public TaxBracket[] TaxBrackets { get; }

    // Konstruktor
    public FileTax(string fileName)
    {
        // wir speichern den Namen der Datei
        FileName = fileName;
        // die gelesenen Stufen
        List<TaxBracket> brackets = [];
        // Lesen der Datei Zeile für Zeile
        string path = Path.Combine(AppContext.BaseDirectory, fileName);
        int lineNumber = 0;
        try
        {
            if (!File.Exists(path))
            {
                throw new FileNotFoundException($"The file [{fileName}] does not exist", fileName);
            }
            foreach (string lineRead in File.ReadLines(path))
            {
                lineNumber++;
                // leere Zeilen werden ignoriert
                string line = lineRead.Trim();
                if (line == "")
                {
                    continue;
                }
                // in drei durch : getrennte Felder zerlegte Zeile
                string[] fields = line.Split(':', StringSplitOptions.TrimEntries);
                ErrorCode code = 0;
                decimal limit = 0, coeffR = 0, coeffN = 0;
                if (fields.Length != 3)
                {
                    code = Line;
                }
                else
                {
                    // Konvertierungen der 3 Felder: jeder Fehler fügt seinen Code hinzu
                    if (!TryParse(fields[0], out limit)) code |= Field1;
                    if (!TryParse(fields[1], out coeffR)) code |= Field2;
                    if (!TryParse(fields[2], out coeffN)) code |= Field3;
                }
                // Fehler?
                if (code != 0)
                {
                    throw new TaxException($"Line no. {lineNumber} is incorrect: [{line}]") { Code = (int)code };
                }
                // wir speichern die neue Steuerstufe
                brackets.Add(new TaxBracket(limit, coeffR, coeffN));
            }
        }
        catch (Exception e) when (e is IOException or UnauthorizedAccessException)
        {
            // Dateizugriffsfehler: wir verpacken ihn in eine TaxException
            throw new TaxException($"Error while reading the file {fileName}", e)
            {
                Code = (int)Access
            };
        }
        // wir geben die Liste als Array zurück
        TaxBrackets = [.. brackets];
    }

    // eine Zahl im invarianten Format: Ziffern und Dezimalpunkt
    private static bool TryParse(string field, out decimal result) =>
        decimal.TryParse(field, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out result);
}
  • 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:

1
2
3
4
5
6
7
namespace Business;

// die Schnittstelle der Schicht [business]
public interface ITaxBusiness
{
    int CalculateTax(bool married, int nbChildren, int salary);
}

Ihre Implementierung, [TaxBusiness], lautet wie folgt:

using Dao;
using Entities;

namespace Business;

// die Schicht [business] erhält die Schicht [dao] über ihren Konstruktor (Primärkonstruktor)
public class TaxBusiness(ITaxDao dao) : ITaxBusiness
{
    // die Steuerstufen, ein für alle Mal von der Schicht [dao] angefordert
    private readonly TaxBracket[] brackets = dao.TaxBrackets;

    // Steuerberechnung
    public int CalculateTax(bool married, int nbChildren, int salary)
    {
        // Prüfung der Parameter
        ArgumentOutOfRangeException.ThrowIfNegative(nbChildren);
        ArgumentOutOfRangeException.ThrowIfNegative(salary);
        // Anzahl der Anteile
        decimal shares = nbChildren / 2M + (married ? 2 : 1);
        if (nbChildren >= 3)
        {
            shares += 0.5M;
        }
        // zu versteuerndes Einkommen und Familienquotient
        decimal income = 0.72M * salary;
        decimal qf = income / shares;
        // die Stufe: die erste, deren Grenze größer oder gleich QF ist,
        // die letzte, wenn keine passt (ihre Grenze wird nicht verwendet)
        TaxBracket bracket = brackets[^1];
        for (int i = 0; i < brackets.Length - 1; i++)
        {
            if (qf <= brackets[i].Limit)
            {
                bracket = brackets[i];
                break;
            }
        }
        // Steuer (ganzzahliger Anteil)
        return (int)(income * bracket.CoeffR - shares * bracket.CoeffN);
    }
}
  • 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:

using Business;

namespace Ui;

// der Konsolendialog mit dem Benutzer: er kennt nur die Schnittstelle der Schicht [business]
public static class Dialog
{
    // bei fehlerhafter Eingabe angezeigte Hilfe
    private const string Syntax = """
        syntax: Married NbChildren Salary
        Married: y for married, n for not married
        NbChildren: number of children
        Salary: annual salary in euros
        """;

    // Dialogschleife: Eingabe der Parameter, Berechnung, Anzeige
    public static void Run(ITaxBusiness business)
    {
        while (true)
        {
            // wir fragen nach den Parametern der Steuerberechnung
            Console.Write("Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: ");
            string parameters = Console.ReadLine()?.Trim() ?? "";
            // etwas zu tun?
            if (parameters == "")
            {
                break;
            }
            // Prüfung der Anzahl der Parameter
            string[] fields = parameters.Split(' ', StringSplitOptions.RemoveEmptyEntries);
            if (fields.Length != 3)
            {
                Console.WriteLine(Syntax);
                continue;
            }
            // married
            string married = fields[0].ToLower();
            if (married != "y" && married != "n")
            {
                Console.WriteLine($"{Syntax}\nIncorrect Married argument: type y or n");
                continue;
            }
            // Anzahl der Kinder
            if (!int.TryParse(fields[1], out int nbChildren) || nbChildren < 0)
            {
                Console.WriteLine($"{Syntax}\nIncorrect NbChildren argument: type a positive or zero integer");
                continue;
            }
            // salary
            if (!int.TryParse(fields[2], out int salary) || salary < 0)
            {
                Console.WriteLine($"{Syntax}\nIncorrect Salary argument: type a positive or zero integer");
                continue;
            }
            // die Parameter sind korrekt: wir lassen die Berechnung von der Schicht [business] durchführen
            Console.WriteLine($"Tax={business.CalculateTax(married == "y", nbChildren, salary)} euros");
        }
    }
}
  • 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]:

using Dao;
using Entities;
using Business;
using Ui;

// Integration der Schichten: dies ist die einzige Stelle, an der die Implementierungsklassen benannt werden
// Argument: "hardwired" für HardwiredTax, andernfalls die von FileTax gelesene Datei (standardmäßig TaxData.txt)
string source = args.Length > 0 ? args[0] : "TaxData.txt";
ITaxBusiness business;
try
{
    // Erzeugung der Schicht [dao]
    ITaxDao dao = source == "hardwired" ? new HardwiredTax() : new FileTax(source);
    // Erzeugung der Schicht [business], die die Schicht [dao] erhält
    business = new TaxBusiness(dao);
}
catch (TaxException e)
{
    // Anzeige des Fehlers und Beenden des Programms
    string origin = e.InnerException is null ? "" : $", original exception: {e.InnerException.Message}";
    Console.WriteLine($"The following error occurred: [Code={(ErrorCode)e.Code}, Message={e.Message}{origin}]");
    return 1;
}

// die Schicht [ui]: der Dialog mit dem Benutzer
Dialog.Run(business);
return 0;
  • 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:

> dotnet run
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 3 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: x 2 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect Married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y -2 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000€
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect Salary argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Mit der Implementierung [HardwiredTax]:

1
2
3
4
5
6
> dotnet run -- hardwired
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Mit einer Datei, die nicht existiert:

> dotnet run -- TaxDataMissing.txt
The following error occurred: [Code=Access, Message=Error while reading the file TaxDataMissing.txt, original exception: The file [TaxDataMissing.txt] does not exist]

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:

1
2
3
4
4962:0:0
8382:0.068:291.09
14753:0,191:1322,92
23888:0.283:2668.39

das Ergebnis lautet:

> dotnet run -- TaxDataInvalid.txt
The following error occurred: [Code=Field2, Field3, Message=Line no. 3 is incorrect: [14753:0,191:1322,92]]

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:

ITaxDao dao = source == "hardwired" ? new HardwiredTax() : new FileTax(source);
business = new TaxBusiness(dao);

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

Image

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:

1
2
3
4
5
6
7
8
9
> dotnet new classlib -n Tax.Dao -o Tax.Dao
> dotnet new classlib -n Tax.Business -o Tax.Business
> dotnet new console -n Tax.Ui -o Tax.Ui
> dotnet new mstest -n Tax.Tests -o Tax.Tests
> dotnet new sln --format slnx -n TaxV5
> dotnet sln TaxV5.slnx add Tax.Dao Tax.Business Tax.Ui Tax.Tests
> dotnet add Tax.Business reference Tax.Dao
> dotnet add Tax.Ui reference Tax.Business Tax.Dao
> dotnet add Tax.Tests reference Tax.Business Tax.Dao
  • [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:

TaxV5/
  TaxV5.slnx
  Tax.Dao/                       library: entities and [dao] layer
    Tax.Dao.csproj
    TaxData.txt
    TaxData.json
    Entities/
      TaxBracket.cs
      TaxException.cs
    Dao/
      ITaxDao.cs
      HardwiredTax.cs
      FileTax.cs
      JsonTax.cs
  Tax.Business/                  library: [business] layer
    Tax.Business.csproj
    ITaxBusiness.cs
    TaxBusiness.cs
  Tax.Ui/                        executable: [ui] layer and integration of the layers
    Tax.Ui.csproj
    Dialog.cs
    Program.cs
    appsettings.json
    appsettings-json.json
    appsettings-hardwired.json
    appsettings-error.json
  Tax.Tests/                     MSTest unit tests
    Tax.Tests.csproj
    MSTestSettings.cs
    DaoTests.cs
    BusinessTests.cs
    TaxDataInvalid.txt
  Trials/                        two trial programs
    trial-dao.cs
    trial-business.cs

Die Solution-Datei sieht wie folgt aus:

1
2
3
4
5
6
<Solution>
  <Project Path="Tax.Dao/Tax.Dao.csproj" />
  <Project Path="Tax.Business/Tax.Business.csproj" />
  <Project Path="Tax.Tests/Tax.Tests.csproj" />
  <Project Path="Tax.Ui/Tax.Ui.csproj" />
</Solution>

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:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <!-- die Datendateien werden neben die ausführbare Datei kopiert
         (und neben die jedes Projekts, das dieses referenziert) -->
    <None Update="TaxData.txt" CopyToOutputDirectory="PreserveNewest" />
    <None Update="TaxData.json" CopyToOutputDirectory="PreserveNewest" />
  </ItemGroup>

</Project>
  • 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:

namespace Entities;

// die Exception der Anwendung [Tax], unabhängig von der Schicht, die sie auslöst
public class TaxException : Exception
{
    // Fehlercode
    public int Code { get; init; }

    // Konstruktoren
    public TaxException(string message) : base(message) { }
    public TaxException(string message, Exception inner) : base(message, inner) { }
}
  • 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:

using System.Globalization;
using Entities;

namespace Dao;

// eine Schicht [dao], die die Steuerstufen aus einer Textdatei liest
// eine Zeile pro Stufe: limit:coeffR:coeffN (Dezimalpunkt)
public class FileTax : ITaxDao
{
    // für diese Implementierung spezifische Fehlercodes: sie können kombiniert werden
    [Flags]
    public enum ErrorCodes { Access = 1, Line = 2, Field1 = 4, Field2 = 8, Field3 = 16 }

    // Datendatei, relativ zum Ordner der ausführbaren Datei
    public string FileName { get; }
  • 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:

                // Fehler?
                if (code != 0)
                {
                    throw new TaxException($"Line no. {lineNumber} is incorrect: [{line}]") { Code = (int)code };
                }
                // wir speichern die neue Steuerstufe
                brackets.Add(new TaxBracket(limit, coeffR, coeffN));
            }
        }
        catch (Exception e) when (e is IOException or UnauthorizedAccessException)
        {
            // Dateizugriffsfehler: wir verpacken ihn in eine TaxException
            throw new TaxException($"Error while reading the file {fileName}", e)
            {
                Code = (int)ErrorCodes.Access
            };
        }
        // wir geben die Liste als Array zurück
        TaxBrackets = [.. brackets];
    }
  • 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]:

1
2
3
4
5
6
7
8
9
[
  { "limit": 4962, "coeffR": 0, "coeffN": 0 },
  { "limit": 8382, "coeffR": 0.068, "coeffN": 291.09 },
  { "limit": 14753, "coeffR": 0.191, "coeffN": 1322.92 },
  { "limit": 23888, "coeffR": 0.283, "coeffN": 2668.39 },
  { "limit": 38868, "coeffR": 0.374, "coeffN": 4846.98 },
  { "limit": 47932, "coeffR": 0.426, "coeffN": 6883.66 },
  { "limit": 0, "coeffR": 0.481, "coeffN": 9505.54 }
]

Die Klasse [JsonTax] sieht wie folgt aus:

using System.Text.Json;
using System.Text.Json.Serialization;
using Entities;

namespace Dao;

// eine Schicht [dao], die die Steuerstufen aus einer JSON-Datei liest
public class JsonTax : ITaxDao
{
    // für diese Implementierung spezifische Fehlercodes
    public enum ErrorCodes { Access = 1, Format = 2 }

    // Datendatei, relativ zum Ordner der ausführbaren Datei
    public string FileName { get; }

    // Steuerstufen
    public TaxBracket[] TaxBrackets { get; }

    // Konstruktor
    public JsonTax(string fileName)
    {
        FileName = fileName;
        string path = Path.Combine(AppContext.BaseDirectory, fileName);
        string json;
        try
        {
            if (!File.Exists(path))
            {
                throw new FileNotFoundException($"The file [{fileName}] does not exist", fileName);
            }
            json = File.ReadAllText(path);
        }
        catch (Exception e) when (e is IOException or UnauthorizedAccessException)
        {
            throw new TaxException($"Error while reading the file {fileName}", e)
            {
                Code = (int)ErrorCodes.Access
            };
        }
        try
        {
            // Deserialisierung mit dem zur Kompilierzeit erzeugten Code (siehe BracketsJsonContext)
            TaxBrackets = JsonSerializer.Deserialize(json, BracketsJsonContext.Default.TaxBracketArray)
                ?? throw new JsonException("the file does not contain an array");
        }
        catch (JsonException e)
        {
            throw new TaxException($"The file {fileName} is not a valid JSON file of tax brackets", e)
            {
                Code = (int)ErrorCodes.Format
            };
        }
    }
}

// der JSON-(De-)Serialisierungscode des Typs TaxBracket[] wird zur Kompilierzeit erzeugt
// "Web"-Optionen: Eigenschaftsnamen in camelCase, beim Lesen Groß-/Kleinschreibung ignoriert
[JsonSourceGenerationOptions(JsonSerializerDefaults.Web)]
[JsonSerializable(typeof(TaxBracket[]))]
internal partial class BracketsJsonContext : JsonSerializerContext;
  • 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:

#:project ../Tax.Dao/Tax.Dao.csproj
using Dao;
using Entities;

// die von den drei Implementierungen der Schicht [dao] gelieferten Steuerstufen
try
{
    ITaxDao[] daos = [new HardwiredTax(), new FileTax("TaxData.txt"), new JsonTax("TaxData.json")];
    foreach (ITaxDao dao in daos)
    {
        Console.WriteLine($"--- {dao.GetType().Name}");
        foreach (TaxBracket t in dao.TaxBrackets)
        {
            Console.WriteLine($"{t.Limit}:{t.CoeffR}:{t.CoeffN}");
        }
    }
}
catch (TaxException e)
{
    // Anzeige des Fehlers
    string origin = e.InnerException is null ? "" : $", original exception: {e.InnerException.Message}";
    Console.WriteLine($"The following error occurred: [Code={e.Code}, Message={e.Message}{origin}]");
}
  • 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:

> dotnet run trial-dao.cs
--- HardwiredTax
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54
--- FileTax
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54
--- JsonTax
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54

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:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <!-- die Schicht [business] verwendet die Schicht [dao] -->
    <ProjectReference Include="../Tax.Dao/Tax.Dao.csproj" />
  </ItemGroup>

</Project>
  • 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:

#:project ../Tax.Business/Tax.Business.csproj
using Dao;
using Entities;
using Business;

// einige Steuerberechnungen mit der Schicht [dao] FileTax
try
{
    ITaxBusiness business = new TaxBusiness(new FileTax("TaxData.txt"));
    Console.WriteLine($"Tax(true,2,60000)={business.CalculateTax(true, 2, 60000)} euros");
    Console.WriteLine($"Tax(false,3,60000)={business.CalculateTax(false, 3, 60000)} euros");
    Console.WriteLine($"Tax(false,3,6000)={business.CalculateTax(false, 3, 6000)} euros");
    Console.WriteLine($"Tax(false,3,600000)={business.CalculateTax(false, 3, 600000)} euros");
}
catch (TaxException e)
{
    // Anzeige des Fehlers
    string origin = e.InnerException is null ? "" : $", original exception: {e.InnerException.Message}";
    Console.WriteLine($"The following error occurred: [Code={e.Code}, Message={e.Message}{origin}]");
}
  • 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:

1
2
3
4
5
> dotnet run trial-business.cs
Tax(true,2,60000)=4282 euros
Tax(false,3,60000)=4282 euros
Tax(false,3,6000)=0 euros
Tax(false,3,600000)=179275 euros

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:

> dotnet new mstest -n DemoTests -o DemoTests

Die Vorlage erstellt eine Projektdatei, die wir so ändern, dass Version 4.0.2 von MSTest verwendet wird:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <LangVersion>latest</LangVersion>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="MSTest" Version="4.0.2" />
  </ItemGroup>

  <ItemGroup>
    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
  </ItemGroup>

</Project>
  • 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:

// die Tests werden nacheinander ausgeführt (Anzeige in stabiler Reihenfolge)
[assembly: DoNotParallelize]
  • 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:

namespace DemoTests;

// eine Testklasse
[TestClass]
public class Tests1
{
    // die getestete Methode
    private static int Sum(int a, int b) => a + b;

    // Konstruktor
    public Tests1()
    {
        Console.WriteLine("constructor");
    }

    // vor jedem Test ausgeführt
    [TestInitialize]
    public void Before()
    {
        Console.WriteLine("before");
    }

    // nach jedem Test ausgeführt
    [TestCleanup]
    public void After()
    {
        Console.WriteLine("after");
    }

    // ein erfolgreicher Test
    [TestMethod]
    public void T1()
    {
        Console.WriteLine("test1");
        Assert.AreEqual(4, Sum(2, 2));
    }

    // ein fehlschlagender Test
    [TestMethod]
    public void T2()
    {
        Console.WriteLine("test2");
        Assert.AreEqual(5, Sum(2, 2), "2 + 2 is not equal to 5");
    }
}
  • 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:

> dotnet test --logger "console;verbosity=detailed"
Test run for bin/Debug/net10.0/DemoTests.dll (.NETCoreApp,Version=v10.0)
VSTest version 18.0.2 (x64)

Starting test execution, please wait...
A total of 1 test files matched the specified pattern.
bin/Debug/net10.0/DemoTests.dll
  Passed T1 [14 ms]
  Standard Output Messages:
 constructor
 before
 test1
 after


  Failed T2 [13 ms]
  Error Message:
   Assert.AreEqual failed. Expected:<5>. Actual:<4>. 'expected' expression: '5', 'actual' expression: 'Sum(2, 2)'. 2 + 2 is not equal to 5
  Stack Trace:
     (stack trace removed)
  Standard Output Messages:
 constructor
 before
 test2
 after


  Passed T3 [1 ms]
  Passed T4 [1 ms]
  Passed T5 [1 ms]
  Passed T6 [1 ms]
  Passed T7 (1,1,2) [< 1 ms]
  Passed T7 (2,3,5) [< 1 ms]
  Passed T7 (-1,1,0) [< 1 ms]

Test Run Failed.
Total tests: 9
     Passed: 8
     Failed: 1
 Total time: 0.8964 Seconds
  • 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:

namespace DemoTests;

// einige weitere MSTest-Assertions
[TestClass]
public class Tests2
{
    // boolesche Werte, null, Referenzen
    [TestMethod]
    public void T3()
    {
        bool isTrue = 1 < 2, isFalse = 1 > 2;
        Assert.IsTrue(isTrue);
        Assert.IsFalse(isFalse);
        object obj1 = new(), obj3 = obj1;
        object? obj2 = null;
        Assert.IsNotNull(obj1);
        Assert.IsNull(obj2);
        Assert.AreSame(obj1, obj3);
        Assert.AreNotSame(obj1, new object());
    }

    // Gleitkommazahlen: Gleichheit innerhalb eines Deltas
    [TestMethod]
    public void T4()
    {
        double d1 = 0.1 + 0.2, d2 = 0.3;
        Assert.AreNotEqual(d2, d1);
        Assert.AreEqual(d2, d1, 1e-6);
    }

    // Zeichenketten und Collections
    [TestMethod]
    public void T5()
    {
        string message = "Line no. 3 is incorrect";
        Assert.StartsWith("Line", message);
        Assert.Contains("incorrect", message);
        int[] numbers = [1, 2, 3];
        Assert.HasCount(3, numbers);
        Assert.Contains(2, numbers);
    }

    // Exceptions: der Test ist erfolgreich, wenn die erwartete Exception ausgelöst wird
    [TestMethod]
    public void T6()
    {
        int[] numbers = [1, 2, 3];
        Assert.ThrowsExactly<IndexOutOfRangeException>(() => numbers[3]);
        FormatException e = Assert.ThrowsExactly<FormatException>(() => int.Parse("x"));
        Assert.IsNotNull(e.Message);
    }

    // ein parametrisierter Test: eine Ausführung pro Attribut [DataRow]
    [TestMethod]
    [DataRow(1, 1, 2)]
    [DataRow(2, 3, 5)]
    [DataRow(-1, 1, 0)]
    public void T7(int a, int b, int sum)
    {
        Assert.AreEqual(sum, a + b);
    }
}
  • 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:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <LangVersion>latest</LangVersion>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <!-- das Test-Framework MSTest -->
    <PackageReference Include="MSTest" Version="4.0.2" />
  </ItemGroup>

  <ItemGroup>
    <!-- die getesteten Schichten -->
    <ProjectReference Include="../Tax.Dao/Tax.Dao.csproj" />
    <ProjectReference Include="../Tax.Business/Tax.Business.csproj" />
  </ItemGroup>

  <ItemGroup>
    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
  </ItemGroup>

  <ItemGroup>
    <!-- eine fehlerhafte Datendatei, um die Fehler zu testen -->
    <None Update="TaxDataInvalid.txt" CopyToOutputDirectory="PreserveNewest" />
  </ItemGroup>

</Project>
  • 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]:

using Dao;
using Entities;

namespace Tests;

// Tests der Schicht [dao]
[TestClass]
public class DaoTests
{
    // Factory einer Schicht [dao] anhand des Namens ihrer Klasse
    private static ITaxDao CreateDao(string implementation) => implementation switch
    {
        "HardwiredTax" => new HardwiredTax(),
        "FileTax" => new FileTax("TaxData.txt"),
        "JsonTax" => new JsonTax("TaxData.json"),
        _ => throw new ArgumentException($"unknown implementation: {implementation}")
    };

    // derselbe Test für die drei Implementierungen
    [TestMethod]
    [DataRow("HardwiredTax")]
    [DataRow("FileTax")]
    [DataRow("JsonTax")]
    public void TaxBrackets(string implementation)
    {
        TaxBracket[] brackets = CreateDao(implementation).TaxBrackets;
        // einige Prüfungen
        Assert.HasCount(7, brackets);
        Assert.AreEqual(14753M, brackets[2].Limit);
        Assert.AreEqual(0.191M, brackets[2].CoeffR);
        Assert.AreEqual(1322.92M, brackets[2].CoeffN);
    }

    // die drei Implementierungen liefern dieselben Stufen
    [TestMethod]
    public void SameBrackets()
    {
        TaxBracket[] reference = new HardwiredTax().TaxBrackets;
        CollectionAssert.AreEqual(reference, new FileTax("TaxData.txt").TaxBrackets);
        CollectionAssert.AreEqual(reference, new JsonTax("TaxData.json").TaxBrackets);
    }

    // fehlende Datei
    [TestMethod]
    public void MissingFile()
    {
        TaxException e = Assert.ThrowsExactly<TaxException>(() => new FileTax("TaxDataMissing.txt"));
        Assert.AreEqual((int)FileTax.ErrorCodes.Access, e.Code);
        Assert.IsInstanceOfType<FileNotFoundException>(e.InnerException);
    }

    // Datei, deren Zeile 3 fehlerhaft ist (Dezimalkommas)
    [TestMethod]
    public void IncorrectLine()
    {
        TaxException e = Assert.ThrowsExactly<TaxException>(() => new FileTax("TaxDataInvalid.txt"));
        Assert.AreEqual((int)(FileTax.ErrorCodes.Field2 | FileTax.ErrorCodes.Field3), e.Code);
        Assert.StartsWith("Line no. 3", e.Message);
    }

    // fehlende JSON-Datei
    [TestMethod]
    public void MissingJsonFile()
    {
        TaxException e = Assert.ThrowsExactly<TaxException>(() => new JsonTax("TaxDataMissing.json"));
        Assert.AreEqual((int)JsonTax.ErrorCodes.Access, e.Code);
    }
}
  • 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:

using Dao;
using Entities;
using Business;

namespace Tests;

// Tests der Schicht [business]
[TestClass]
public class BusinessTests
{
    // die Schicht [dao] und die getestete Schicht [business]: MSTest erzeugt pro Test eine Instanz der Klasse
    private readonly HardwiredTax dao = new();
    private readonly ITaxBusiness business;

    public BusinessTests()
    {
        business = new TaxBusiness(dao);
    }

    // Berechnungen mit bekanntem Ergebnis
    [TestMethod]
    [DataRow(true, 2, 60000, 4282)]
    [DataRow(false, 3, 60000, 4282)]
    [DataRow(true, 3, 60000, 2959)]
    [DataRow(false, 0, 60000, 11519)]
    [DataRow(false, 3, 6000, 0)]
    [DataRow(false, 3, 600000, 179275)]
    public void CalculateTax(bool married, int nbChildren, int salary, int tax)
    {
        Assert.AreEqual(tax, business.CalculateTax(married, nbChildren, salary));
    }

    // die Berechnung verändert die von der Schicht [dao] gelieferten Stufen nicht
    [TestMethod]
    public void UnchangedBrackets()
    {
        TaxBracket[] before = [.. dao.TaxBrackets];
        business.CalculateTax(true, 2, 600000);
        CollectionAssert.AreEqual(before, dao.TaxBrackets);
    }

    // negative Parameter werden abgelehnt
    [TestMethod]
    public void NegativeParameters()
    {
        Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => business.CalculateTax(true, -1, 60000));
        Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => business.CalculateTax(true, 2, -60000));
    }

    // eine Fake-Schicht [dao]: eine einzige Stufe, 10 % Steuer
    private class FakeDao : ITaxDao
    {
        public TaxBracket[] TaxBrackets { get; } = [new(0M, 0.1M, 0M)];
    }

    // die mit der Fake-Schicht [dao] getestete Schicht [business]
    [TestMethod]
    public void WithFakeDao()
    {
        ITaxBusiness fakeBusiness = new TaxBusiness(new FakeDao());
        // zu versteuerndes Einkommen = 0,72 x 100000 = 72000; Steuer = 10 % von 72000
        Assert.AreEqual(7200, fakeBusiness.CalculateTax(false, 0, 100000));
    }
}
  • 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]:

> dotnet test --logger "console;verbosity=normal"
Test run for bin/Debug/net10.0/Tax.Tests.dll (.NETCoreApp,Version=v10.0)
VSTest version 18.0.2 (x64)

Starting test execution, please wait...
A total of 1 test files matched the specified pattern.
  Passed CalculateTax (True,2,60000,4282) [1 ms]
  Passed CalculateTax (False,3,60000,4282) [< 1 ms]
  Passed CalculateTax (True,3,60000,2959) [< 1 ms]
  Passed CalculateTax (False,0,60000,11519) [< 1 ms]
  Passed CalculateTax (False,3,6000,0) [< 1 ms]
  Passed CalculateTax (False,3,600000,179275) [< 1 ms]
  Passed UnchangedBrackets [< 1 ms]
  Passed NegativeParameters [< 1 ms]
  Passed WithFakeDao [< 1 ms]
  Passed TaxBrackets ("HardwiredTax") [9 ms]
  Passed TaxBrackets ("FileTax") [2 ms]
  Passed TaxBrackets ("JsonTax") [36 ms]
  Passed SameBrackets [1 ms]
  Passed MissingFile [2 ms]
  Passed IncorrectLine [< 1 ms]
  Passed MissingJsonFile [< 1 ms]

Test Run Successful.
Total tests: 16
     Passed: 16
 Total time: 0.8513 Seconds

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:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <!-- die verwendeten Schichten -->
    <ProjectReference Include="../Tax.Dao/Tax.Dao.csproj" />
    <ProjectReference Include="../Tax.Business/Tax.Business.csproj" />
  </ItemGroup>

  <ItemGroup>
    <!-- Dependency-Injection-Container und Lesen einer JSON-Konfigurationsdatei -->
    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.12" />
    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.12" />
  </ItemGroup>

  <ItemGroup>
    <!-- die Konfigurationsdateien werden neben die ausführbare Datei kopiert -->
    <None Update="appsettings*.json" CopyToOutputDirectory="PreserveNewest" />
  </ItemGroup>

</Project>
  • 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:

    // Anzeige einer Exception und aller Exceptions, die sie umschließt
    public static void DisplayError(Exception exception)
    {
        string separator = new('-', 40);
        Console.WriteLine($"Exception chain:\n{separator}");
        for (Exception? e = exception; e != null; e = e.InnerException)
        {
            Console.WriteLine($"{e.GetType().FullName}: {e.Message}");
            Console.WriteLine(separator);
        }
    }
}
  • 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:

ITaxDao dao = source == "hardwired" ? new HardwiredTax() : new FileTax(source);
business = new TaxBusiness(dao);

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.

Image

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:

1
2
3
4
5
6
{
  "Dao": {
    "Implementation": "FileTax",
    "File": "TaxData.txt"
  }
}
  • 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:

1
2
3
appsettings-json.json      : "Implementation": "JsonTax", "File": "TaxData.json"
appsettings-hardwired.json : "Implementation": "HardwiredTax"
appsettings-error.json     : "Implementation": "FileTax", "File": "TaxDataMissing.txt"

6.4.6.2. Das Hauptprogramm

Das Hauptprogramm [Program.cs] des Projekts [Tax.Ui] sieht wie folgt aus:

using Dao;
using Entities;
using Business;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Ui;

// die Konfigurationsdatei: standardmäßig appsettings.json oder die als Argument übergebene
string configFile = args.Length > 0 ? args[0] : "appsettings.json";

// Integration der Schichten
ITaxBusiness business;
try
{
    // Lesen der Konfiguration, neben der ausführbaren Datei
    IConfiguration config = new ConfigurationBuilder()
        .SetBasePath(AppContext.BaseDirectory)
        .AddJsonFile(configFile, optional: false)
        .Build();
    string implementation = config["Dao:Implementation"] ?? "HardwiredTax";
    string file = config["Dao:File"] ?? "";

    // Registrierung der Schichten im Container
    var services = new ServiceCollection();
    // die Schicht [dao]: die Implementierung wird durch die Konfiguration gewählt
    services.AddSingleton<ITaxDao>(_ => implementation switch
    {
        "HardwiredTax" => new HardwiredTax(),
        "FileTax" => new FileTax(file),
        "JsonTax" => new JsonTax(file),
        _ => throw new TaxException($"Unknown implementation [{implementation}] of the [dao] layer")
    });
    // die Schicht [business]: der Container übergibt ihr die Schicht [dao]
    services.AddSingleton<ITaxBusiness, TaxBusiness>();

    // Erzeugung des Containers, dann der Schicht [business] (und damit der Schicht [dao])
    ServiceProvider provider = services.BuildServiceProvider();
    business = provider.GetRequiredService<ITaxBusiness>();
}
catch (Exception e)
{
    // Anzeige des Fehlers und Beenden des Programms
    Dialog.DisplayError(e);
    return 1;
}

// der Dialog mit dem Benutzer
Dialog.Run(business);
return 0;
  • 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]):

1
2
3
4
5
6
7
8
> dotnet run
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Mit der Implementierung [JsonTax]:

1
2
3
4
> dotnet run -- appsettings-json.json
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Mit der Implementierung [HardwiredTax]:

1
2
3
4
> dotnet run -- appsettings-hardwired.json
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

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:

1
2
3
4
5
6
7
> dotnet run -- appsettings-error.json
Exception chain:
----------------------------------------
Entities.TaxException: Error while reading the file TaxDataMissing.txt
----------------------------------------
System.IO.FileNotFoundException: The file [TaxDataMissing.txt] does not exist
----------------------------------------
  • 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.