Skip to content

5. Häufig verwendete .NET-Klassen

Hier stellen wir einige häufig verwendete Klassen der .NET-Plattform vor: Zeichenketten, Arrays, Sammlungen, Dateien und reguläre Ausdrücke. Außerdem behandeln wir LINQ (Language Integrated Query), das der Kurs von 2008 ausgelassen hat, obwohl es seit C# 3 verfügbar war: Es ist heute die gebräuchlichste Art, Sammlungen in C# zu bearbeiten. Zuvor zeigen wir Ihnen, wie Sie Informationen zu den Tausenden verfügbaren Klassen finden. Diese Anleitung ist für jeden C#-Entwickler unverzichtbar, auch für erfahrene.

Die Beispiele dieses Kapitels – mit Ausnahme der Beispielanwendung am Ende – sind Single-File-Anwendungen , die mit [dotnet run file.cs] ausgeführt werden. Sie befinden sich im Ordner [05-classes-dotnet] des Kurscodes und laufen in der französischen Locale (fr-FR), mit Ausnahme der LINQ- und der Beispiele mit regulären Ausdrücken, die in der amerikanisch-englischen Locale (en-US) laufen.

5.1. Hilfe zu .NET-Klassen finden

Der Kurs von 2008 enthielt eine ausführliche Beschreibung der mit Visual Studio 2008 installierten MSDN-Hilfe samt Screenshots. Diese lokale Hilfe gibt es nicht mehr: Die .NET-Dokumentation ist heute online, kostenlos und wird mit jeder neuen Version aktualisiert.

5.1.1. Online-Dokumentation

Ausgangspunkt ist die Website learn.microsoft.com von Microsoft. Dort finden Sie:

  • die Dokumentation der Sprache C#: https://learn.microsoft.com/en-us/dotnet/csharp/. Sie enthält einen Überblick über die Sprache, Tutorials, die Sprachreferenz (Schlüsselwörter, Operatoren, Anweisungen) und einen Abschnitt „Neuigkeiten“, der jede Version von C# beschreibt;
  • die .NET-API-Referenz: https://learn.microsoft.com/en-us/dotnet/api/. Sie beschreibt, Namespace für Namespace, alle Klassen von .NET: ihre Konstruktoren, Eigenschaften und Methoden, mit Beispielen;
  • den API-Browser auf derselben Seite: ein Suchfeld, in das Sie den Namen einer Klasse oder Methode eingeben können ([StringBuilder], [Regex.Match] …). Über eine Dropdown-Liste wählen Sie die .NET-Version aus (hier .NET 10).

Die Seite zu einer Klasse, etwa System.String, zeigt:

  • den Namespace der Klasse und die Assembly, die sie enthält;
  • ihre Deklaration, ihre Elternklasse und die Schnittstellen, die sie implementiert;
  • eine Liste ihrer Konstruktoren, Eigenschaften und Methoden, jeweils mit einem Link zu einer Detailseite, die die verschiedenen Überladungen, Parameter, Rückgabewerte, möglichen Ausnahmen und oft ein Beispiel zeigt;
  • Hinweise zur Verwendung.

Die Seiten sind auf Französisch (maschinelle Übersetzung) und auf Englisch (Originaltext, der manchmal präziser ist) verfügbar. Sie können zwischen beiden wechseln, indem Sie in der URL [en-us] durch [fr-fr] ersetzen. Eine Suche mit einer Suchmaschine über den vollständigen Namen der Klasse („System.Text.StringBuilder“) führt meist direkt zur richtigen Seite.

5.1.2. Hilfe im Editor

Der Code-Editor (Visual Studio, Visual Studio Code mit der Erweiterung C# Dev Kit, Rider) bietet sofortige Hilfe, ohne dass Sie den Code verlassen müssen:

  • Autovervollständigung (IntelliSense): Nach der Eingabe von [aString.] schlägt der Editor eine Liste der Eigenschaften und Methoden des Objekts samt einer Kurzbeschreibung vor;
  • Tooltips: Wenn Sie den Mauszeiger über den Namen einer Klasse, Methode oder Variablen bewegen, werden ihre Deklaration und eine Zusammenfassung ihrer Dokumentation angezeigt;
  • Parameterhilfe: Wenn Sie die öffnende Klammer eines Aufrufs eingeben, zeigt der Editor die verschiedenen Überladungen der Methode und die Rolle jedes Parameters an;
  • Gehe zu Definition (Taste F12): Zeigt die Deklaration der Klasse oder Methode an. Bei einer .NET-Klasse zeigt der Editor die aus der Assembly rekonstruierten öffentlichen Deklarationen samt ihren Dokumentationskommentaren an;
  • In Visual Studio öffnet ein Druck auf die Taste F1 auf dem Namen einer Klasse oder Methode die entsprechende Seite der Online-Dokumentation.

Diese Dokumentationskommentare, die sichtbar sind, wenn Sie den Mauszeiger über ein Element bewegen, werden auch zur Erzeugung der Online-Referenz verwendet. Ähnliche Kommentare können Sie in Ihrem eigenen Code mit der Syntax [/// <summary> ... </summary>] schreiben, die über einer Klasse oder Methode steht: Der Editor zeigt sie auf dieselbe Weise an.

5.2. Zeichenketten

5.2.1. Die Klasse System.String

Der C#-Typ [string] ist ein Alias für die Klasse [System.String]. Sie hat zahlreiche Eigenschaften und Methoden. Hier sind einige davon:

Mitglied
Aufgabe
[public int Length { get; }]
Anzahl der Zeichen der Zeichenkette
[public char this[int index] { get; }]
Zeichen Nr. [index]: [aString[i]]
[public bool StartsWith(string value)]
liefert [true] , wenn die Zeichenkette mit [value] beginnt
[public bool EndsWith(string value)]
liefert [true] , wenn die Zeichenkette mit [value] endet
[public bool Contains(string value)]
liefert [true] , wenn die Zeichenkette [value] enthält
[public bool Equals(string? value)]
liefert [true] , wenn die Zeichenkette gleich [value] ist; entspricht [aString == value]
[public int IndexOf(string value)]
das erste Vorkommen von [value] in der Zeichenkette oder -1. Eine weitere Überladung beginnt die Suche an der Position [startIndex]
[public int IndexOf(char value)]
dasselbe für das Zeichen [value]
[public int LastIndexOf(char value)]
wie [IndexOf] , liefert aber die letzte statt der ersten Position
[public string Insert(int startIndex, string value)]
fügt die Zeichenkette [value] an der Position [startIndex] in die Zeichenkette ein
[public static string Join(string separator, params string[] value)]
Klassenmethode: verkettet die Elemente von [value] und trennt sie durch [separator]
[public string Replace(char oldChar, char newChar)]
liefert eine Kopie der Zeichenkette, in der das Zeichen [oldChar] durch [newChar] ersetzt wurde; eine überladene Methode ersetzt eine Zeichenkette durch eine andere
[public string[] Split(params char[] separator)]
die Zeichenkette wird als Folge von Feldern behandelt, die durch die Zeichen in [separator] getrennt sind; das Ergebnis ist ein Array dieser Felder
[public string Substring(int startIndex, int length)]
eine Teilzeichenkette der Länge [length] ab der Position [startIndex]
[public string ToLower()], [public string ToUpper()]
wandelt die Zeichenkette in Klein- bzw. Großbuchstaben um
[public string Trim()]
entfernt führende und nachgestellte Leerzeichen der Zeichenkette ([TrimStart], [TrimEnd]: nur auf einer Seite)

Wichtig ist, dass eine Zeichenkette vom Typ [string] ist unveränderlich; sie kann nach ihrer Erzeugung nicht mehr geändert werden. Wenn eine Methode eine Zeichenkette liefert, unterscheidet sich diese von der Zeichenkette, auf die die Methode angewendet wurde. So liefert [s1.Trim()] die Zeichenkette [s2], und [s1] und [s2] sind zwei verschiedene Zeichenketten: [s1] hat sich nicht geändert.

Eine Zeichenkette [c] kann als schreibgeschütztes Array von Zeichen betrachtet werden:

  • [c[i]] ist das i-te Zeichen von [c] (das erste Zeichen hat die Nummer 0);
  • [c.Length] ist die Anzahl der Zeichen von [c].

Das Programm [strings-01.cs] sieht wie folgt aus:

// einige Methoden der Klasse String
string aString = "the bird flies above clouds";
Display("aString=" + aString);
Display("aString.Length=" + aString.Length);
Display("aString[10]=" + aString[10]);
Display("aString.IndexOf(\"flies\")=" + aString.IndexOf("flies"));
Display("aString.IndexOf(\"x\")=" + aString.IndexOf("x"));
Display("aString.LastIndexOf('a')=" + aString.LastIndexOf('a'));
Display("aString.LastIndexOf('x')=" + aString.LastIndexOf('x'));
Display("aString.Substring(4, 7)=" + aString.Substring(4, 7));
Display("aString.ToUpper()=" + aString.ToUpper());
Display("aString.ToLower()=" + aString.ToLower());
Display("aString.Replace('a', 'A')=" + aString.Replace('a', 'A'));
Display("aString.Insert(9, \"never \")=" + aString.Insert(9, "never "));
// Zerlegen der Zeichenkette in Wörter (Trennzeichen: Leerzeichen)
string[] fields = aString.Split();
for (int i = 0; i < fields.Length; i++)
{
    Display("fields[" + i + "]=[" + fields[i] + "]");
}
Display("string.Join(\":\", fields)=" + string.Join(":", fields));
Display("\"  abc  \".Trim()=[" + "  abc  ".Trim() + "]");
// die ursprüngliche Zeichenkette wurde nicht verändert
Display("aString=" + aString);

// eine lokale Anzeigemethode
static void Display(string msg)
{
    Console.WriteLine(msg);
}

Ergebnisse:

> dotnet run strings-01.cs
aString=the bird flies above clouds
aString.Length=27
aString[10]=l
aString.IndexOf("flies")=9
aString.IndexOf("x")=-1
aString.LastIndexOf('a')=15
aString.LastIndexOf('x')=-1
aString.Substring(4, 7)=bird fl
aString.ToUpper()=THE BIRD FLIES ABOVE CLOUDS
aString.ToLower()=the bird flies above clouds
aString.Replace('a', 'A')=the bird flies Above clouds
aString.Insert(9, "never ")=the bird never flies above clouds
fields[0]=[the]
fields[1]=[bird]
fields[2]=[flies]
fields[3]=[above]
fields[4]=[clouds]
string.Join(":", fields)=the:bird:flies:above:clouds
"  abc  ".Trim()=[abc]
aString=the bird flies above clouds

Kommentare:

  • Zeile 5: Zeichen Nr. 10, also das 11. Zeichen der Zeichenkette;
  • Zeilen 7, 9: Eine erfolglose Suche liefert -1;
  • Zeile 10: die 7 Zeichen ab Position 4;
  • Zeile 14: ein Einfügen an Position 9, vor dem Wort „flies“;
  • Zeile 16: [Split] ohne Parameter zerlegt die Zeichenkette an Leerraumzeichen (Leerzeichen, Tabulator, Zeilenumbruch usw.). Der Kurs von 2008 verwendete [Split(null)], was auf dasselbe hinausläuft;
  • Zeile 21: Die statische Methode [Join] bewirkt das Gegenteil von [Split];
  • Zeile 23: Alle vorherigen Methoden lieferten neue Zeichenketten: [aString] blieb unverändert (Zeile 21 der Ergebnisse);
  • Zeilen 27–29: eine lokale Funktion, wie in Kapitel 3.

5.2.2. Die Methoden Split und Join

Das Programm [strings-02.cs] vertieft die Zerlegung einer Zeichenkette in Felder:

// Split und Join
string line = "one:two::three:";
// Zerlegen mit dem Trennzeichen ':'
string[] fields = line.Split(':');
for (int i = 0; i < fields.Length; i++)
{
    Console.WriteLine($"fields[{i}]=[{fields[i]}]");
}
// die Umkehroperation
Console.WriteLine($"join=[{string.Join(":", fields)}]");

// die Optionen von Split: Entfernen leerer Felder
fields = line.Split(':', StringSplitOptions.RemoveEmptyEntries);
Console.WriteLine($"RemoveEmptyEntries : {fields.Length} fields [{string.Join("|", fields)}]");

// mehrere Trennzeichen und Entfernen der Leerzeichen um die Felder
string person = " dupont , jean ;  45 ";
fields = person.Split([',', ';'], StringSplitOptions.TrimEntries);
Console.WriteLine($"TrimEntries : {fields.Length} fields [{string.Join("|", fields)}]");

// beide Optionen kombiniert
string list = "  red ,, green ,  , blue ";
fields = list.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Console.WriteLine($"both options: {fields.Length} fields [{string.Join("|", fields)}]");

// ein Trennzeichen, das eine Zeichenkette ist
string text = "apple -> pear -> apricot";
fields = text.Split(" -> ");
Console.WriteLine($"string separator: [{string.Join("|", fields)}]");

// Join akzeptiert jede Collection, nicht nur Zeichenketten
int[] numbers = [1, 2, 3, 4];
Console.WriteLine($"Join on integers: {string.Join(" + ", numbers)}");

Ergebnisse:

> dotnet run strings-02.cs
fields[0]=[one]
fields[1]=[two]
fields[2]=[]
fields[3]=[three]
fields[4]=[]
join=[one:two::three:]
RemoveEmptyEntries : 3 fields [one|two|three]
TrimEntries : 3 fields [dupont|jean|45]
both options: 3 fields [red|green|blue]
string separator: [apple|pear|apricot]
Join on integers: 1 + 2 + 3 + 4

Kommentare:

  • Zeile 4: Die Felder sind durch das Zeichen [:] getrennt. Zwei aufeinanderfolgende [:]-Zeichen oder ein einzelnes [:] am Ende der Zeichenkette begrenzen ein leeres Feld: Das ergibt 5 Felder, davon 2 leere (Zeilen 4 und 6 der Ergebnisse). [Join] stellt die ursprüngliche Zeichenkette wieder her;
  • Die Methode [Split] hat zahlreiche Überladungen. Die Variante von 2008, [Split(char[] separator)], wird heute als [Split(params char[] separator)] geschrieben: Das Schlüsselwort [params] erlaubt es, die Trennzeichen einzeln anzugeben – [Split(':')] oder [Split(',', ';')] –, ohne ein Array zu erzeugen;
  • Zeile 13: Die Aufzählung [StringSplitOptions] verändert die Zerlegung in Felder. [RemoveEmptyEntries] entfernt leere Felder;
  • Zeile 18: [TrimEntries] (.NET 5) entfernt die Leerzeichen um jedes Feld. Die Trennzeichen werden hier als Collection-Ausdruck übergeben: [',', ';'];
  • Zeile 23: Die beiden Optionen werden mit dem Operator [|] kombiniert. Die Leerzeichen werden vor der Prüfung auf leere Felder entfernt: Das Feld, das aus zwei Leerzeichen zwischen zwei Kommas besteht, wird entfernt;
  • Zeile 28: Das Trennzeichen kann eine Zeichenkette aus mehreren Zeichen sein;
  • Zeile 33: [Join] akzeptiert eine Sammlung von Elementen beliebigen Typs; jedes Element wird mit seiner Methode [ToString] in eine Zeichenkette umgewandelt.

5.2.3. Zeichenketten suchen und vergleichen

Der Vergleich von Zeichenketten ist subtiler, als es scheint: Soll zwischen Groß- und Kleinbuchstaben unterschieden werden? Wie ist „éclair“ im Verhältnis zu „essay“ einzuordnen? Das Programm [strings-03.cs] stellt die Such- und Vergleichsmethoden vor:

// Suchen und Vergleichen von Zeichenketten
string title = "Learning the C# language with .NET";

// Contains, StartsWith, EndsWith: standardmäßig exakter Vergleich
Console.WriteLine($"Contains(\"language\") : {title.Contains("language")}");
Console.WriteLine($"Contains(\"LANGUAGE\") : {title.Contains("LANGUAGE")}");
Console.WriteLine($"StartsWith(\"Learning\") : {title.StartsWith("Learning")}");
Console.WriteLine($"EndsWith('T') : {title.EndsWith('T')}");

// der Vergleichsmodus wird mit der Aufzählung StringComparison angegeben
Console.WriteLine($"Contains(\"LANGUAGE\", OrdinalIgnoreCase) : {title.Contains("LANGUAGE", StringComparison.OrdinalIgnoreCase)}");
Console.WriteLine($"StartsWith(\"learning\", OrdinalIgnoreCase) : {title.StartsWith("learning", StringComparison.OrdinalIgnoreCase)}");

// Gleichheit: der Operator == vergleicht den Inhalt der Zeichenketten
string answer = "YES";
Console.WriteLine($"answer == \"yes\" : {answer == "yes"}");
Console.WriteLine($"string.Equals(answer, \"yes\", OrdinalIgnoreCase) : {string.Equals(answer, "yes", StringComparison.OrdinalIgnoreCase)}");

// alphabetische Reihenfolge: Vergleich nach Kultur oder nach Zeichencodes
string a = "éclair", b = "essay";
Console.WriteLine($"Compare(\"{a}\", \"{b}\", CurrentCulture) : {string.Compare(a, b, StringComparison.CurrentCulture)}");
Console.WriteLine($"Compare(\"{a}\", \"{b}\", Ordinal) : {string.Compare(a, b, StringComparison.Ordinal)}");

// leere Zeichenketten oder solche aus Leerraum
string? empty = null;
string blank = "   ";
Console.WriteLine($"IsNullOrEmpty(null) : {string.IsNullOrEmpty(empty)}");
Console.WriteLine($"IsNullOrEmpty(\"   \") : {string.IsNullOrEmpty(blank)}");
Console.WriteLine($"IsNullOrWhiteSpace(\"   \") : {string.IsNullOrWhiteSpace(blank)}");

// Auffüllen
Console.WriteLine($"[{"abc".PadLeft(8)}] [{"abc".PadRight(8, '.')}] [{new string('-', 8)}]");

Ergebnisse:

> dotnet run strings-03.cs
Contains("language") : True
Contains("LANGUAGE") : False
StartsWith("Learning") : True
EndsWith('T') : True
Contains("LANGUAGE", OrdinalIgnoreCase) : True
StartsWith("learning", OrdinalIgnoreCase) : True
answer == "yes" : False
string.Equals(answer, "yes", OrdinalIgnoreCase) : True
Compare("éclair", "essay", CurrentCulture) : -1
Compare("éclair", "essay", Ordinal) : 132
IsNullOrEmpty(null) : True
IsNullOrEmpty("   ") : False
IsNullOrWhiteSpace("   ") : True
[     abc] [abc.....] [--------]

Kommentare:

  • Zeilen 5–8: [Contains], [StartsWith] und [EndsWith] führen standardmäßig einen exakten, zeichenweisen Vergleich durch: „LANGUAGE“ wird nicht gefunden;
  • Zeilen 11–12: Ein Parameter vom Typ [StringComparison] legt den Vergleichsmodus fest. Die nützlichsten Werte sind:
    • [Ordinal]: Vergleich der Zeichencodes;
    • [OrdinalIgnoreCase]: wie oben, jedoch ohne Beachtung der Groß- und Kleinschreibung;
    • [CurrentCulture], [CurrentCultureIgnoreCase]: Vergleich nach den Regeln der Sprache des Rechners;
    • [InvariantCulture]: Vergleich nach rechnerunabhängigen Regeln;
  • Zeile 16: Der Operator [] vergleicht wie die Methode [Equals] den Inhalt der Zeichenketten. Das ist ein wichtiger Unterschied zu Java, wo [] Referenzen vergleicht;
  • Zeile 17: Die statische Form von [Equals] akzeptiert ebenfalls einen [StringComparison]. So prüft man richtig, ob über die Tastatur ein „yes“ in Groß- oder Kleinschreibung eingegeben wurde;
  • Zeilen 21–22: [string.Compare] liefert eine negative Zahl, null oder eine positive Zahl, je nachdem, ob die erste Zeichenkette vor der zweiten steht, ihr gleicht oder nach ihr steht. Im Französischen steht „éclair“ vor „essay“ (der Buchstabe „é“ wird bei „e“ eingeordnet, Zeile 10 der Ergebnisse). Beim ordinalen Vergleich steht „éclair“ nach „essay“, weil der Code des ersten Zeichens „é“ (233) größer ist als der des Zeichens „e“ (101): Der ordinale Vergleich liefert hier die Differenz der beiden Codes, 132. Wir verwenden die kulturabhängige Reihenfolge, um Wörter zu sortieren, die für einen Benutzer bestimmt sind, und die ordinale Reihenfolge, um technische Bezeichner (Dateinamen, Schlüssel usw.) zu vergleichen;
  • Zeilen 27–29: zwei statische Methoden, um eine Zeichenkette zu prüfen, die fehlt ([null]), leer ist oder nur Leerzeichen enthält;
  • Zeile 32: [PadLeft] und [PadRight] füllen eine Zeichenkette auf eine bestimmte Länge auf; der Konstruktor [new string('-', 8)] wiederholt ein Zeichen.

5.2.4. Interpolation und Formate

Die Zeichenketteninterpolation [$"..."] (C# 6) wird seit Beginn dieses Kurses verwendet. Wie die Methode [string.Format] akzeptiert sie für jeden Ausdruck eine Breite und ein Format: [{expression,width:format}]. Das Programm [strings-04.cs] liefert dazu Beispiele sowie für die Raw-Zeichenketten von C# 11:

// Interpolation, Formate und Raw-Strings
string name = "dupont";
int age = 45;
decimal salary = 2345.678m;
double rate = 0.0525;
DateTime date = new(2026, 10, 3, 14, 5, 9);

// einfache Interpolation
Console.WriteLine($"{name} is {age} years old");
// {Ausdruck,Breite:Format}: Breite > 0 richtet rechts aus, < 0 links
Console.WriteLine($"[{name,10}] [{name,-10}] [{age,5}]");
Console.WriteLine($"[{salary,12:F2}] [{salary,-12:F1}] [{salary:N2}] [{salary:C}]");
Console.WriteLine($"[{rate:P2}] [{age:D5}] [{age:X}] [{1234567:N0}]");
Console.WriteLine($"[{date:dd/MM/yyyy}] [{date:HH:mm:ss}] [{date:dddd d MMMM yyyy}]");
// ein beliebiger Ausdruck, hier ein bedingter Ausdruck in Klammern
Console.WriteLine($"{name} is {(age >= 18 ? "an adult" : "a minor")}");

// die Methode string.Format und die Notation {n} früherer C#-Versionen
Console.WriteLine(string.Format("{0} is {1} years old and earns {2:F2} euros", name, age, salary));

// eine ausgerichtete Tabelle
string[] products = ["apple", "pear", "apricot"];
decimal[] prices = [2.5m, 3.15m, 12m];
for (int i = 0; i < products.Length; i++)
{
    Console.WriteLine($"{products[i],-10}|{prices[i],8:F2} €");
}

// Verbatim-Zeichenkette: \ ist kein Escape-Zeichen
string path = @"C:\data\course\infos.txt";
Console.WriteLine(path);

// Raw-String (C# 11): von mindestens drei doppelten Anführungszeichen begrenzt, über mehrere Zeilen
string json = """
    {
      "name": "dupont",
      "path": "C:\data"
    }
    """;
Console.WriteLine(json);
// interpolierter Raw-String: mit $$ bleiben einfache geschweifte Klammern literal
string json2 = $$"""{ "name": "{{name}}", "age": {{age}} }""";
Console.WriteLine(json2);

Ergebnisse:

> dotnet run strings-04.cs
dupont is 45 years old
[    dupont] [dupont    ] [   45]
[     2345,68] [2345,7      ] [2 345,68] [2 345,68 €]
[5,25 %] [00045] [2D] [1 234 567]
[03/10/2026] [14:05:09] [samedi 3 octobre 2026]
dupont is an adult
dupont is 45 years old and earns 2345,68 euros
apple     |    2,50 €
pear      |    3,15 €
apricot   |   12,00 €
C:\data\course\infos.txt
{
  "name": "dupont",
  "path": "C:\data"
}
{ "name": "dupont", "age": 45 }

Kommentare:

  • Zeile 11: Eine positive Breite richtet den Wert rechtsbündig in einem Feld von 10 Zeichen aus; eine negative Breite richtet ihn linksbündig aus;
  • Zeilen 12–14: Die gebräuchlichsten Formate:
Format
Bedeutung
Beispiel (fr-FR)
[F2]
Festkommazahl mit 2 Nachkommastellen
2345,68
[N2]
wie oben, mit Tausendertrennzeichen
2 345,68
[C]
Geldbetrag für die aktuelle Kultur
2 345,68 €
[P2]
Prozentwert (der Wert wird mit 100 multipliziert)
5,25 %
[D5]
ganze Zahl mit mindestens 5 Stellen, mit Nullen aufgefüllt
00045
[X]
hexadezimale ganze Zahl
2D
[dd/MM/yyyy], [HH:mm:ss]
Datum und Uhrzeit (MM: Monat, mm: Minuten)
03/10/2026, 14:05:09
[dddd d MMMM yyyy]
Tag und Monat ausgeschrieben
samedi 3 octobre 2026
  • Zahlen und Datumsangaben werden gemäß der aktuellen Ländereinstellung formatiert, hier fr-FR: Dezimalkomma, Leerzeichen als Tausendertrennzeichen, französische Tages- und Monatsnamen;
  • Zeile 16: Ein bedingter Ausdruck innerhalb einer Interpolation muss in Klammern gesetzt werden, weil das Zeichen [:] dort ein Format einleiten würde;
  • Zeile 19: Die Schreibweise [{0}], [{1}] … für [string.Format] ist die im Kurs von 2008 verwendete (und für [Console.WriteLine], das dieselben Parameter akzeptiert). Sie begegnet einem noch häufig; die Interpolation ist besser lesbar;
  • Zeilen 24–26: Die Breiten ermöglichen es, Daten in Spalten anzuzeigen;
  • Zeile 30: Eine wörtliche Zeichenkette [@"..."] behandelt [\] nicht als Escape-Zeichen. Das ist nützlich für Windows-Pfade und reguläre Ausdrücke;
  • Zeilen 34–39: Eine Raw-Zeichenkette (C# 11) wird von mindestens drei Anführungszeichen begrenzt. Sie kann sich über mehrere Zeilen erstrecken und Anführungszeichen sowie [\] ohne Escape-Sequenz enthalten. Die Einrückung des schließenden Anführungszeichens wird von jeder Zeile entfernt: Der JSON-Text wird ohne die 4 Leerzeichen des Code-Randes angezeigt;
  • Zeile 42: Eine Raw-Zeichenkette kann interpoliert werden. Mit [$$] wird ein interpolierter Ausdruck zwischen doppelten geschweiften Klammern geschrieben [{{name}}], und einfache geschweifte Klammern – die in einem Text wie JSON häufig vorkommen – bleiben gewöhnliche Zeichen.

5.2.5. Die Klasse System.Text.StringBuilder

Wir haben erwähnt, dass die Methoden der Klasse [String], die auf eine Zeichenkette [s1] wirken, eine andere Zeichenkette [s2] zurückgeben. Die Klasse [System.Text.StringBuilder] erlaubt es, eine Zeichenkette zu verändern, ohne für jede Operation eine neue Zeichenkette zu erzeugen. Das verbessert die Leistung, wenn eine Zeichenkette durch viele aufeinanderfolgende Anfügungen aufgebaut wird, da die Vielzahl kurzlebiger Zeichenketten vermieden wird.

Die Klasse unterstützt mehrere Konstruktoren:

Konstruktor
Funktion
[StringBuilder()]
Standardkonstruktor
[StringBuilder(string value)]
Erstellung und Initialisierung mit [value]
[StringBuilder(string value, int capacity)]
Erstellung und Initialisierung mit [value], mit einer anfänglichen Kapazität von [capacity] Zeichen

Ein [StringBuilder]-Objekt speichert seine Zeichen in einem Speicherbereich, dessen Größe – seine Kapazität – automatisch angepasst wird, wenn der Text wächst. Standardmäßig beträgt die anfängliche Kapazität 16 Zeichen. Der dritte Konstruktor erlaubt es, sie festzulegen. Das Programm [strings-05.cs] veranschaulicht dieses Konzept der Kapazität:

using System.Text;

// Größe und Kapazität eines StringBuilder
var str = new StringBuilder("test");
Console.WriteLine($"size={str.Length}, capacity={str.Capacity}");
for (int i = 0; i < 10; i++)
{
    str.Append("test");
    Console.WriteLine($"size={str.Length}, capacity={str.Capacity}");
}
// ein StringBuilder mit Anfangskapazität 10
var str2 = new StringBuilder("test", 10);
Console.WriteLine($"size={str2.Length}, capacity={str2.Capacity}");
for (int i = 0; i < 10; i++)
{
    str2.Append("test");
    Console.WriteLine($"size={str2.Length}, capacity={str2.Capacity}");
}

Ergebnisse:

> dotnet run strings-05.cs
size=4, capacity=16
size=8, capacity=16
size=12, capacity=16
size=16, capacity=16
size=20, capacity=32
size=24, capacity=32
size=28, capacity=32
size=32, capacity=32
size=36, capacity=64
size=40, capacity=64
size=44, capacity=64
size=4, capacity=10
size=8, capacity=10
size=12, capacity=20
size=16, capacity=20
size=20, capacity=20
size=24, capacity=40
size=28, capacity=40
size=32, capacity=40
size=36, capacity=40
size=40, capacity=40
size=44, capacity=80

Kommentare:

  • Zeile 4: Erstellung eines [StringBuilder]-Objekts mit einer anfänglichen Kapazität von 16;
  • Zeile 5: [Length] ist die aktuelle Anzahl der Zeichen; [Capacity] ist die Anzahl der Zeichen, die das Objekt aufnehmen kann, bevor es seinen Speicherbereich vergrößern muss;
  • Zeile 8: [Append] fügt am Ende des Textes eine Zeichenkette an;
  • Zeile 12: Erstellung eines Objekts [StringBuilder] mit einer anfänglichen Kapazität von 10.

Die Ergebnisse zeigen, dass sich die Kapazität verdoppelt, wenn sie nicht ausreicht: 16, 32, 64 (Zeilen 6 und 10 der Ergebnisse) sowie 10, 20, 40, 80 beim zweiten Objekt. Das sind dieselben Ergebnisse wie 2008. Wenn die ungefähre Größe des Textes im Voraus bekannt ist, vermeidet man durch ihre Festlegung bei der Erstellung aufeinanderfolgende Vergrößerungen.

Hier einige Methoden der Klasse:

Methode
Funktion
[StringBuilder Append(string value)]
Fügt [value] am Ende des Textes an. Überladen, um die Typen [int], [double], [decimal], [char] … sowie eine interpolierte Zeichenkette zu akzeptieren
[StringBuilder AppendLine()]
fügt einen Zeilenumbruch an (eine überladene Methode fügt eine Zeichenkette gefolgt von einem Zeilenumbruch an)
[StringBuilder AppendJoin(string separator, params string[] values)]
fügt die Elemente von [values] getrennt durch [separator] an
[StringBuilder Insert(int index, string value)]
fügt [value] an der Position [index] ein; überladen wie [Append]
[StringBuilder Remove(int index, int length)]
löscht [length] Zeichen ab der Position [index]
[StringBuilder Replace(string oldValue, string newValue)]
ersetzt [oldValue] durch [newValue]; eine überladene Variante ersetzt ein Zeichen
[string ToString()]
wandelt den Text in eine Zeichenkette [string] um

Das Programm [strings-06.cs] verwendet sie:

using System.Text;

// die Methoden von StringBuilder geben das Objekt StringBuilder selbst zurück: sie können verkettet werden
var str3 = new StringBuilder("test");
Console.WriteLine(str3.Append("abCD").Insert(2, "xyZT").Remove(0, 2).Replace("xy", "XY"));

// eine Zeichenkette Stück für Stück aufbauen
var lines = new StringBuilder();
for (int i = 1; i <= 3; i++)
{
    lines.Append("line ").Append(i).AppendLine();
}
// AppendJoin: das Äquivalent von string.Join
lines.AppendJoin(", ", "a", "b", "c").AppendLine();
// Append akzeptiert auch eine interpolierte Zeichenkette
int total = 42;
lines.Append($"total={total,6:F1}");
// die endgültige Zeichenkette
string result = lines.ToString();
Console.WriteLine(result);
Console.WriteLine($"{result.Length} characters");

Ergebnisse:

1
2
3
4
5
6
7
8
> dotnet run strings-06.cs
XYZTstabCD
line 1
line 2
line 3
a, b, c
total=  42,0
41 characters

Kommentare:

  • Zeile 5: Die Änderungsmethoden geben das Objekt [StringBuilder] selbst zurück, sodass sie verkettet werden können. Verfolgen wir die Schritte: „test“ wird zu „testabCD“ ([Append]), dann zu „texyZTstabCD“ ([Insert] an Position 2), dann zu „xyZTstabCD“ ([Remove] der ersten 2 Zeichen) und schließlich zu „XYZTstabCD“ ([Replace]). [Console.WriteLine] zeigt das Objekt an, indem es seine Methode [ToString] aufruft;
  • Zeilen 9–11: Aufbau eines mehrzeiligen Textes durch aufeinanderfolgende Anfügungen: Das ist die typische Verwendung von [StringBuilder];
  • Zeile 17: [Append] akzeptiert eine interpolierte Zeichenkette einschließlich Breite und Format;
  • Zeile 19: Der endgültige Text wird als Zeichenkette vom Typ [string] gewonnen.

Für einige wenige Verkettungen genügt der Operator [+] oder die Interpolation: Der Compiler optimiert sie. [StringBuilder] ist notwendig, wenn die Zahl der Anfügungen groß oder unbekannt ist, typischerweise in einer Schleife.

5.2.6. Sichten auf eine Zeichenkette: Span<char>

.NET Core 2.1 (2018) führte die Typen [Span<T>] und [ReadOnlySpan<T>] ein. Ein Objekt [ReadOnlySpan<char>] ist eine Sicht auf eine bestehende Zeichenfolge, etwa auf einen Teil einer Zeichenkette: Es enthält keine Kopie der Zeichen, sondern nur eine Möglichkeit, auf sie zuzugreifen. Das Herausschneiden eines Teils einer Zeichenkette über eine Sicht erzeugt daher keine neue Zeichenkette. Das Programm [strings-07.cs] vergleicht die beiden Arten, eine Zeile im Format „Nachname:Vorname:Alter“ zu zerlegen:

// ReadOnlySpan<char>: eine „Sicht" auf einen Teil einer Zeichenkette, ohne Kopie
string line = "dupont:jean:45";

// mit Substring: jedes Feld ist eine neue, im Speicher angelegte Zeichenkette
int p1 = line.IndexOf(':');
int p2 = line.LastIndexOf(':');
string lastName = line.Substring(0, p1);
int age = int.Parse(line.Substring(p2 + 1));
Console.WriteLine($"Substring : last name={lastName}, age={age}");

// mit einer Sicht: es wird keine Zwischenzeichenkette erzeugt
ReadOnlySpan<char> view = line.AsSpan();
ReadOnlySpan<char> lastNameView = view[..p1];     // Zeichen 0 bis p1-1
ReadOnlySpan<char> ageView = view[(p2 + 1)..];    // von p2+1 bis zum Ende
// int.Parse akzeptiert eine Sicht
age = int.Parse(ageView);
Console.WriteLine($"Span : last name={lastNameView}, age={age}, length of the view={lastNameView.Length}");
// eine Sicht kann ohne Kopie mit einer Zeichenkette verglichen werden
Console.WriteLine($"the last name starts with \"du\": {lastNameView.StartsWith("du")}");
// eine Zeichenkette wird nur erzeugt, wenn sie wirklich benötigt wird
string firstName = view[(p1 + 1)..p2].ToString();
Console.WriteLine($"first name={firstName}");

Ergebnisse:

1
2
3
4
5
> dotnet run strings-07.cs
Substring : last name=dupont, age=45
Span : last name=dupont, age=45, length of the view=6
the last name starts with "du": True
first name=jean

Kommentare:

  • Zeilen 7–8: Jeder Aufruf von [Substring] erzeugt eine neue Zeichenkette im Speicher, auch wenn sie, wie beim Alter, nur kurz verwendet wird;
  • Zeile 12: [AsSpan] liefert eine Sicht auf die gesamte Zeichenkette;
  • Zeilen 13–14: Die Bereiche [start..end] (C# 8), die in Kapitel 3 für Arrays eingeführt wurden, gelten auch für Sichten: Man erhält zwei neue Sichten, ohne zu kopieren;
  • Zeile 16: Viele Methoden in .NET akzeptieren anstelle einer Zeichenkette eine Sicht ([Parse], [TryParse], [StartsWith], [Contains], [Equals] …);
  • Zeile 21: Eine Zeichenkette wird nur dann aus einer Sicht erzeugt, wenn sie tatsächlich benötigt wird.

Sichten sind ein Optimierungswerkzeug, das innerhalb von .NET selbst intensiv genutzt wird: Das ist einer der Gründe, warum neuere Versionen deutlich schneller sind als das .NET Framework von 2008. Eine Sicht kann nur auf dem Ausführungsstapel existieren: Sie kann zum Beispiel nicht Feld einer Klasse sein. Für ein gewöhnliches Programm sind [string] und [Substring] vollkommen ausreichend: Sichten sollten nur in Code eingesetzt werden, der als leistungskritisch identifiziert wurde. Wir gehen nicht weiter darauf ein.

5.3. Arrays

5.3.1. Die Klasse Array

Arrays leiten sich von der Klasse [System.Array] ab. Diese Klasse stellt verschiedene Methoden zum Sortieren eines Arrays, zum Suchen eines Elements in einem Array, zum Ändern der Größe eines Arrays und mehr bereit. Wir stellen einige ihrer Eigenschaften und Methoden vor. Fast alle sind überladen, das heißt, sie existieren in verschiedenen Varianten. Jedes Array erbt sie.

Eigenschaften:

Eigenschaft
Funktion
[public int Length { get; }]
Gesamtzahl der Elemente des Arrays, unabhängig von der Zahl der Dimensionen
[public int Rank { get; }]
Anzahl der Dimensionen des Arrays

Methoden:

Methode
Funktion
[public static int BinarySearch<T>(T[] array, T value)]
Liefert die Position von [value] in [array], das sortiert sein muss; eine negative Zahl, wenn [value] fehlt
[public static void Clear(Array array, int index, int length)]
setzt die [length] Elemente von [array] ab dem Index [index] auf ihre Standardwerte zurück: 0 für Zahlen, [false] für Boolesche Werte, [null] für Referenzen
[public static void Copy(Array source, Array destination, int length)]
kopiert die ersten [length] Elemente von [source] nach [destination]
[public static void Fill<T>(T[] array, T value)]
weist [value] allen Elementen von [array] zu
[public int GetLength(int dimension)]
Anzahl der Elemente in der Dimension Nr. [dimension] des Arrays
[public static int IndexOf<T>(T[] array, T value)]
liefert die Position von [value] in [array] oder -1, wenn [value] nicht gefunden wird; [LastIndexOf] liefert die letzte Position
[public static void Resize<T>(ref T[]? array, int newSize)]
ändert die Größe von [array] auf [newSize] Elemente; bereits vorhandene Elemente bleiben erhalten
[public static void Reverse(Array array)]
kehrt die Reihenfolge der Elemente in [array] um
[public static void Sort<T>(T[] array)]
sortiert [array] nach der natürlichen Ordnung seiner Elemente; eine überladene Methode nimmt ein Objekt [IComparer<T>] entgegen, das die Reihenfolge festlegt (Kapitel 4)

Das Programm [arrays-01.cs] veranschaulicht die Verwendung einiger Methoden der Klasse [Array]:

// die Klasse Array: Größenänderung, Sortieren, Suchen

// Lesen der Elemente eines über die Tastatur eingegebenen Arrays
double[] elements = Input();
// Anzeige des unsortierten Arrays
Display("Unsorted array", elements);
// lineare Suche im unsortierten Array
Search(elements, SearchType.Linear);
// Sortieren des Arrays
Array.Sort(elements);
// Anzeige des sortierten Arrays
Display("Sorted array", elements);
// binäre Suche im sortierten Array
Search(elements, SearchType.Binary);

// Eingabe der Array-Werte: liefert das erzeugte Array
static double[] Input()
{
    // am Anfang ist das Array leer
    double[] elements = [];
    // Eingabeschleife für die Array-Elemente
    while (true)
    {
        Console.Write($"Element (real) {elements.Length} of the array (nothing to finish): ");
        string answer = (Console.ReadLine() ?? "").Trim();
        // Ende der Eingabe bei leerer Zeichenkette
        if (answer == "")
        {
            break;
        }
        // Prüfung der Eingabe
        if (!double.TryParse(answer, out double element))
        {
            Console.WriteLine("Incorrect input, try again");
            continue;
        }
        // ein Element mehr: wir vergrößern das Array um eine Zelle
        Array.Resize(ref elements, elements.Length + 1);
        // und speichern darin das neue Element
        elements[^1] = element;
    }
    return elements;
}

// generische Methode zur Anzeige der Elemente eines Arrays
static void Display<T>(string text, T[] elements)
{
    Console.WriteLine(text.PadRight(50, '-'));
    foreach (T element in elements)
    {
        Console.WriteLine(element);
    }
}

// Suche der über die Tastatur eingegebenen Elemente im Array
static void Search(double[] elements, SearchType type)
{
    while (true)
    {
        Console.Write("Element searched for (nothing to stop): ");
        string answer = (Console.ReadLine() ?? "").Trim();
        // fertig?
        if (answer == "")
        {
            break;
        }
        // Prüfung
        if (!double.TryParse(answer, out double element))
        {
            Console.WriteLine("Error, try again...");
            continue;
        }
        // wir suchen das Element im Array
        int i = type == SearchType.Binary
            ? Array.BinarySearch(elements, element)    // sortiertes Array
            : Array.IndexOf(elements, element);        // beliebiges Array
        // Anzeige der Antwort
        Console.WriteLine(i >= 0 ? $"Found at position {i}" : $"Not in the array ({i})");
    }
}

// Art der Suche
enum SearchType { Linear, Binary }

Kommentare:

  • Zeilen 17–42: Die Methode [Input] liest die Elemente eines über die Tastatur eingegebenen Arrays ein. Da die Anzahl der Elemente nicht im Voraus bekannt ist, beginnt das Programm mit einem leeren Array (Zeile 20) und vergrößert es bei jeder neuen Eingabe um ein Element (Zeile 38). [Resize] erzeugt tatsächlich ein neues Array, kopiert die Elemente des alten hinein und speichert seine Referenz in der per [ref] übergebenen Variablen. Ein effizienterer Algorithmus würde den Speicherplatz in Gruppen von N Elementen reservieren. Ein Array ist nicht dafür gedacht, in der Größe verändert zu werden: Dieser Fall wird besser mit einer Liste [List<T>] behandelt, wie wir gleich sehen werden;
  • Zeile 40: [^1] bezeichnet das letzte Element des Arrays (Indizierung vom Ende her, C# 8);
  • Im Kurs von 2008 war [Input] eine Methode mit einem Parameter [out]; die moderne Version gibt das erstellte Array zurück, was natürlicher ist;
  • Zeilen 56–78: Die Methode [Search] sucht im Array nach über die Tastatur eingegebenen Elementen. Bei einem unsortierten Array erfolgt eine lineare Suche mit [IndexOf] (Zeile 76), die die Elemente nacheinander untersucht. Bei einem sortierten Array erfolgt eine binäre Suche mit [BinarySearch] (Zeile 75), die den Suchbereich bei jedem Schritt halbiert: Sie findet ein Element unter einer Million in etwa zwanzig Vergleichen;
  • Zeile 10: Das Array wird sortiert. Hier verwenden wir eine Variante von [Sort] mit nur einem Parameter: dem zu sortierenden Array. Die zum Vergleich der Array-Elemente verwendete Ordnungsrelation ist dann die für diese Elemente implizite: in diesem Fall die natürliche Ordnung der Zahlen;
  • Zeilen 46–51: eine generische Methode, die ein Array von Elementen beliebigen Typs [T] anzeigt.

Ergebnisse:

> dotnet run arrays-01.cs
Element (real) 0 of the array (nothing to finish): 3,6
Element (real) 1 of the array (nothing to finish): 7,4
Element (real) 2 of the array (nothing to finish): -1,5
Element (real) 3 of the array (nothing to finish): x
Incorrect input, try again
Element (real) 3 of the array (nothing to finish): -7
Element (real) 4 of the array (nothing to finish): 
Unsorted array------------------------------------
3,6
7,4
-1,5
-7
Element searched for (nothing to stop): 7,4
Found at position 1
Element searched for (nothing to stop): 0
Not in the array (-1)
Element searched for (nothing to stop): 
Sorted array--------------------------------------
-7
-1,5
3,6
7,4
Element searched for (nothing to stop): 7,4
Found at position 3
Element searched for (nothing to stop): 0
Not in the array (-3)
Element searched for (nothing to stop): 

Wenn das gesuchte Element nicht vorhanden ist, liefert [IndexOf] -1 und [BinarySearch] eine negative Zahl (Zeile 27): Das ist das Einerkomplement ([~i]) der Position, an der das Element eingefügt werden müsste, damit das Array sortiert bleibt. Hier ergibt [~(-3)] den Wert 2: Die Zahl 0 müsste an Position 2 eingefügt werden, zwischen -1.5 und 3.6. Achtung: [BinarySearch] auf einem unsortierten Array liefert ein bedeutungsloses Ergebnis.

5.3.2. Weitere Methoden der Klasse Array

Das Programm [arrays-02.cs] demonstriert weitere Methoden der Klasse [Array]:

// weitere Methoden der Klasse Array
int[] numbers = [40, 10, 30, 20, 50];
Display("numbers", numbers);

// Reverse: kehrt die Reihenfolge der Elemente an Ort und Stelle um
Array.Reverse(numbers);
Display("after Reverse", numbers);

// Sort auf einem Teil des Arrays: 3 Elemente ab Index 1
Array.Sort(numbers, 1, 3);
Display("after Sort(numbers, 1, 3)", numbers);

// Copy: Kopie von 3 Elementen in ein anderes Array
int[] copy = new int[5];
Array.Copy(numbers, copy, 3);
Display("copy", copy);

// Fill: füllt das Array mit einem Wert; Clear: setzt die Elemente auf ihren Standardwert zurück
Array.Fill(copy, 7);
Display("after Fill(copy, 7)", copy);
Array.Clear(copy, 1, 2);
Display("after Clear(copy, 1, 2)", copy);

// IndexOf, LastIndexOf auf einem Array von Zeichenketten
string[] colors = ["red", "green", "blue", "green"];
Console.WriteLine($"IndexOf(green)={Array.IndexOf(colors, "green")}, LastIndexOf(green)={Array.LastIndexOf(colors, "green")}, IndexOf(black)={Array.IndexOf(colors, "black")}");

// Sortieren eines Arrays von Zeichenketten: alphabetische Reihenfolge der aktuellen Kultur
Array.Sort(colors);
Display("sorted colors", colors);

// ein zweidimensionales Array: Rank, Length, GetLength
int[,] matrix = new int[2, 3];
Console.WriteLine($"Rank={matrix.Rank}, Length={matrix.Length}, GetLength(0)={matrix.GetLength(0)}, GetLength(1)={matrix.GetLength(1)}");

// Anzeige eines Arrays in einer Zeile
static void Display<T>(string text, T[] elements)
{
    Console.WriteLine($"{text,-28}: [{string.Join(", ", elements)}]");
}

Ergebnisse:

> dotnet run arrays-02.cs
numbers                     : [40, 10, 30, 20, 50]
after Reverse               : [50, 20, 30, 10, 40]
after Sort(numbers, 1, 3)   : [50, 10, 20, 30, 40]
copy                        : [50, 10, 20, 0, 0]
after Fill(copy, 7)         : [7, 7, 7, 7, 7]
after Clear(copy, 1, 2)     : [7, 0, 0, 7, 7]
IndexOf(green)=1, LastIndexOf(green)=3, IndexOf(black)=-1
sorted colors               : [blue, green, green, red]
Rank=2, Length=6, GetLength(0)=2, GetLength(1)=3

Kommentare:

  • Zeile 6: [Reverse] kehrt die Reihenfolge der Elemente im Array selbst um;
  • Zeile 10: Es werden nur 3 Elemente ab Position 1 sortiert: 20, 30, 10 werden zu 10, 20, 30;
  • Zeile 15: kopiert die ersten 3 Elemente von [numbers] nach [copy], während die übrigen Elemente ihren Anfangswert 0 behalten;
  • Zeilen 19–21: [Fill] füllt das Array; [Clear] setzt 2 Elemente ab Position 1 auf 0 zurück;
  • Zeile 29: Die Zeichenketten werden gemäß der aktuellen Kultur in alphabetischer Reihenfolge sortiert;
  • Zeile 34: Bei einem zweidimensionalen Array ist [Rank] gleich 2, [Length] ist die Gesamtzahl der Elemente, und [GetLength(i)] ist die Anzahl der Elemente in der Dimension i;
  • Zeile 39: [string.Join] zeigt ein Array in einer einzigen Zeile an.

LINQ, auf das wir später eingehen, bietet weitere Möglichkeiten, die Elemente eines Arrays zu suchen, zu sortieren oder umzuwandeln.

5.4. Generische Collections

Neben Arrays gibt es verschiedene Klassen zum Speichern von Elementsammlungen. Generische Collections, die mit .NET 2.0 eingeführt wurden, befinden sich im Namespace [System.Collections.Generic], der zu den impliziten [using]-Namespaces gehört. Wir stellen zunächst zwei häufig verwendete Collections vor – die Liste und das Dictionary – und gehen dann kurz auf weitere ein.

Der Namespace [System.Collections] enthält die älteren, nicht generischen Versionen dieser Collections, die auf .NET 1.0 zurückgehen: [ArrayList] (eine Liste), [Hashtable] (ein Dictionary) … Der Kurs von 2008 enthielt noch [ArrayList]. Diese Klassen sind heute veraltet: Sie speichern Referenzen vom Typ [object], was erfordert, die gelesenen Elemente umzuwandeln und die Zahlen in Objekte zu verpacken (Boxing), mit entsprechendem Speicher- und Zeitaufwand. Generische Collections haben diese Nachteile nicht: Eine *[List<int>] speichert ihre ganzen Zahlen direkt in einem internen *[int[]] -Array, und der Compiler prüft den Typ der hinzugefügten Elemente. [ArrayList] und [Hashtable] sollten in neuem Code nicht mehr verwendet werden.

5.4.1. Die generische Klasse List<T>

Die Klasse [System.Collections.Generic.List<T>] ermöglicht es, Sammlungen von Objekten vom Typ [T] zu implementieren, deren Größe sich während der Programmausführung ändert. Ein Objekt vom Typ [List<T>] wird fast wie ein Array behandelt. So wird das Element i einer Liste [l] als [l[i]] notiert.

Bei einer Liste vom Typ [List<T>] , bei der [T] eine Klasse ist, speichert die Liste Referenzen auf Objekte vom Typ [T], wie ein Array von Objekten; ist [T] ein Werttyp ([int], [double], Struktur …), werden die Werte selbst in der Liste gespeichert.

Hier einige Eigenschaften und Methoden generischer Listen.

Eigenschaften:

Eigenschaft
Funktion
[public int Count { get; }]
Anzahl der Elemente in der Liste
[public int Capacity { get; set; }]
Anzahl der Elemente, die die Liste aufnehmen kann, bevor sie vergrößert wird. Diese Vergrößerung erfolgt automatisch. Dieses Konzept der Kapazität entspricht dem für die Klasse [StringBuilder] beschriebenen

Methoden:

Methode
Funktion
[public void Add(T item)]
fügt [item] am Ende der Liste hinzu
[public void AddRange(IEnumerable<T> collection)]
fügt die Elemente von [collection] am Ende der Liste hinzu
[public int BinarySearch(T item)]
liefert die Position von [item] in der sortierten Liste, falls vorhanden; andernfalls eine negative Zahl
[public void Clear()]
entfernt alle Elemente aus der Liste
[public bool Contains(T item)]
liefert [true] , wenn [item] in der Liste enthalten ist, andernfalls [false]
[public List<T> GetRange(int index, int count)]
liefert eine neue Liste aus [count] Elementen ab der Position [index]
[public int IndexOf(T item)]
liefert die Position von [item] in der Liste oder -1, wenn [item] nicht gefunden wird
[public void Insert(int index, T item)]
fügt [item] an der Position [index] in die Liste ein
[public bool Remove(T item)]
entfernt das erste Vorkommen von [item] aus der Liste; liefert [true] , wenn der Vorgang gelingt, [false] sonst
[public void RemoveAt(int index)]
entfernt das Element Nr. [index] aus der Liste
[public void Reverse()]
kehrt die Reihenfolge der Elemente in der Liste um
[public void Sort()]
sortiert die Liste in natürlicher Reihenfolge; eine überladene Version nimmt einen [IComparer<T>] entgegen
[public T[] ToArray()]
liefert die Elemente der Liste als Array

Greifen wir das zuvor mit einem Array behandelte Beispiel noch einmal auf und verarbeiten es nun mit einem Objekt vom Typ [List<double>]. Da die Liste einem Array ähnelt, ändert sich der Code nur wenig. Das ist das Programm [collections-01.cs]:

// die Klasse List<T>: das Programm arrays-01.cs, mit einer Liste neu geschrieben

// Lesen der Elemente einer über die Tastatur eingegebenen Liste
List<double> elements = Input();
// Anzahl der Elemente und Kapazität
Console.WriteLine($"The list has {elements.Count} elements and a capacity of {elements.Capacity} elements");
// Anzeige der unsortierten Liste
Display("Unsorted list", elements);
// lineare Suche in der unsortierten Liste
Search(elements, SearchType.Linear);
// Sortieren der Liste
elements.Sort();
// Anzeige der sortierten Liste
Display("Sorted list", elements);
// binäre Suche in der sortierten Liste
Search(elements, SearchType.Binary);

// Eingabe der Listenwerte: liefert die erzeugte Liste
static List<double> Input()
{
    // am Anfang ist die Liste leer
    List<double> elements = new();
    // Eingabeschleife für die Listenelemente
    while (true)
    {
        Console.Write($"Element (real) {elements.Count} of the list (nothing to finish): ");
        string answer = (Console.ReadLine() ?? "").Trim();
        // Ende der Eingabe bei leerer Zeichenkette
        if (answer == "")
        {
            break;
        }
        // Prüfung der Eingabe
        if (!double.TryParse(answer, out double element))
        {
            Console.WriteLine("Incorrect input, try again");
            continue;
        }
        // ein Element mehr in der Liste: sie wächst von selbst
        elements.Add(element);
    }
    return elements;
}

// generische Methode zur Anzeige der Elemente einer beliebigen Sequenz
static void Display<T>(string text, IEnumerable<T> elements)
{
    Console.WriteLine(text.PadRight(50, '-'));
    foreach (T element in elements)
    {
        Console.WriteLine(element);
    }
}

// Suche der über die Tastatur eingegebenen Elemente in der Liste
static void Search(List<double> elements, SearchType type)
{
    while (true)
    {
        Console.Write("Element searched for (nothing to stop): ");
        string answer = (Console.ReadLine() ?? "").Trim();
        // fertig?
        if (answer == "")
        {
            break;
        }
        // Prüfung
        if (!double.TryParse(answer, out double element))
        {
            Console.WriteLine("Error, try again...");
            continue;
        }
        // wir suchen das Element in der Liste
        int i = type == SearchType.Binary
            ? elements.BinarySearch(element)    // sortierte Liste
            : elements.IndexOf(element);        // beliebige Liste
        // Anzeige der Antwort
        Console.WriteLine(i >= 0 ? $"Found at position {i}" : $"Not in the list ({i})");
    }
}

// Art der Suche
enum SearchType { Linear, Binary }

Kommentare:

  • Zeile 22: Die Liste wird leer erstellt. [new()] (C# 9) ist eine Kurzform von [new List<double>()]: Der Typ wird aus der Variablendeklaration abgeleitet;
  • Zeile 40: Die Größenänderung muss nicht mehr behandelt werden; die Liste wächst automatisch;
  • Zeile 6: die Anzahl der Elemente der Liste und ihre Kapazität;
  • Zeilen 12, 75, 76: Die Methoden [Sort], [BinarySearch] und [IndexOf] sind nun Instanzmethoden der Liste, während die von [Array] statische Methoden sind;
  • Zeilen 46–51: Die generische Methode [Display<T>] hat zwei Parameter:
    • der erste ist ein auszugebender Text;
    • der zweite ist ein Objekt, das die generische Schnittstelle [IEnumerable<T>] implementiert:
1
2
3
4
public interface IEnumerable<out T> : IEnumerable
{
    IEnumerator<T> GetEnumerator();
}

Die Struktur [foreach (T element in elements)] ist für jedes Objekt [elements] gültig, das die Schnittstelle [IEnumerable<T>] implementiert. Arrays und Listen implementieren diese Schnittstelle. Daher eignet sich die Methode [Display] sowohl zur Anzeige von Arrays als auch von Listen. Wir werden auf diese Schnittstelle zurückkommen, die das Herzstück von LINQ bildet.

Ergebnisse:

> dotnet run collections-01.cs
Element (real) 0 of the list (nothing to finish): 3,6
Element (real) 1 of the list (nothing to finish): 7,4
Element (real) 2 of the list (nothing to finish): -1,5
Element (real) 3 of the list (nothing to finish): -7
Element (real) 4 of the list (nothing to finish): 
The list has 4 elements and a capacity of 4 elements
Unsorted list-------------------------------------
3,6
7,4
-1,5
-7
Element searched for (nothing to stop): 7,4
Found at position 1
Element searched for (nothing to stop): 0
Not in the list (-1)
Element searched for (nothing to stop): 
Sorted list---------------------------------------
-7
-1,5
3,6
7,4
Element searched for (nothing to stop): 7,4
Found at position 3
Element searched for (nothing to stop): 0
Not in the list (-3)
Element searched for (nothing to stop): 

Die Ergebnisse sind dieselben wie beim Array. Die Kapazität der Liste beträgt hier 4 (Zeile 7): Von 0 ausgehend stieg sie beim ersten Hinzufügen auf 4; beim fünften Hinzufügen wäre sie auf 8 gestiegen, sie verdoppelt sich also wie die eines [StringBuilder].

5.4.2. Methoden von List<T> und Collection-Ausdrücke

Das Programm [collections-02.cs] verwendet die übrigen Methoden der Liste und die Collection-Ausdrücke von C# 12, denen wir bei den Arrays in Kapitel 3 bereits begegnet sind:

// die wichtigsten Methoden von List<T> und Collection Expressions

// eine durch eine Collection Expression initialisierte Liste (C# 12)
List<string> cities = ["Paris", "Lyon", "Angers"];
Display("start", cities);

// Hinzufügen
cities.Add("Nantes");                       // am Ende
cities.Insert(1, "Brest");                  // an Position 1
cities.AddRange(["Lille", "Tours"]);        // mehrere Elemente am Ende
Display("after Add, Insert, AddRange", cities);

// Zugriff über Index, lesend und schreibend
cities[0] = "Marseille";
Console.WriteLine($"cities[0]={cities[0]}, cities[^1]={cities[^1]}, Count={cities.Count}");

// Suche
Console.WriteLine($"Contains(\"Lyon\")={cities.Contains("Lyon")}, IndexOf(\"Angers\")={cities.IndexOf("Angers")}, IndexOf(\"Nice\")={cities.IndexOf("Nice")}");

// Entfernen
bool removed = cities.Remove("Lyon");       // nach Wert
cities.RemoveAt(0);                         // nach Position
Display($"after Remove ({removed}), RemoveAt(0)", cities);

// Sortieren, Umkehren, Elementbereich
cities.Sort();
Display("after Sort", cities);
cities.Reverse();
Display("after Reverse", cities);
List<string> slice = cities.GetRange(1, 2);
Display("GetRange(1, 2)", slice);

// Umwandlung in ein Array und zurück
string[] array = cities.ToArray();
List<string> other = new(array);
Console.WriteLine($"array of {array.Length} elements, new list of {other.Count} elements");

// der Operator .. (Spread) fügt die Elemente einer Collection in eine andere ein
int[] small = [1, 2, 3];
List<int> numbers = [0, .. small, 10, .. small];
Display("numbers", numbers);
// dieselbe Syntax erzeugt ein Array, eine Liste oder eine leere Collection
int[] empty = [];
Console.WriteLine($"empty.Length={empty.Length}");

// Clear leert die Liste
cities.Clear();
Console.WriteLine($"after Clear: Count={cities.Count}");

static void Display<T>(string text, List<T> list)
{
    Console.WriteLine($"{text,-34}: [{string.Join(", ", list)}]");
}

Ergebnisse:

> dotnet run collections-02.cs
start                             : [Paris, Lyon, Angers]
after Add, Insert, AddRange       : [Paris, Brest, Lyon, Angers, Nantes, Lille, Tours]
cities[0]=Marseille, cities[^1]=Tours, Count=7
Contains("Lyon")=True, IndexOf("Angers")=3, IndexOf("Nice")=-1
after Remove (True), RemoveAt(0)  : [Brest, Angers, Nantes, Lille, Tours]
after Sort                        : [Angers, Brest, Lille, Nantes, Tours]
after Reverse                     : [Tours, Nantes, Lille, Brest, Angers]
GetRange(1, 2)                    : [Nantes, Lille]
array of 5 elements, new list of 5 elements
numbers                           : [0, 1, 2, 3, 10, 1, 2, 3]
empty.Length=0
after Clear: Count=0

Kommentare:

  • Zeile 4: Ein Collection-Ausdruck [a, b, c] initialisiert eine Liste wie ein Array;
  • Zeilen 8–10: drei Möglichkeiten, Elemente hinzuzufügen;
  • Zeile 14: Das Element Nr. 0 ist les- und schreibbar; [cities[^1]] ist wie bei einem Array das letzte Element;
  • Zeile 21: [Remove] liefert [true] , wenn das Element gefunden und entfernt wurde;
  • Zeile 30: eine neue Liste aus 2 Elementen ab Position 1;
  • Zeilen 34–35: Umwandlung einer Liste in ein Array und eines Arrays (oder einer beliebigen Sequenz) in eine Liste;
  • Zeile 40: In einem Collection-Ausdruck fügt der Operator [..] (Spread) alle Elemente einer anderen Collection ein;
  • Zeile 43: [] bezeichnet eine leere Collection des erwarteten Typs.

5.4.3. Die Klasse Dictionary<TKey,TValue>

Die Klasse [System.Collections.Generic.Dictionary<TKey,TValue>] dient zur Implementierung eines Dictionarys. Ein Dictionary lässt sich als zweispaltiges Array auffassen:

Schlüssel
Wert
key1
value1
key2
value2
...
...

In der Klasse [Dictionary<TKey,TValue>] sind die Schlüssel vom Typ [TKey], und die Werte sind vom Typ [TValue]. Schlüssel sind eindeutig: Es kann nicht zwei gleiche Schlüssel geben. Ein solches Dictionary könnte so aussehen, wenn die Typen [TKey] und [TValue] Klassen bezeichneten:

Image

Der dem Schlüssel [c] in einem Dictionary [d] zugeordnete Wert wird mit der Schreibweise [d[c]] ermittelt. Dieser Wert ist les- und schreibbar. So können wir schreiben:

1
2
3
4
5
TValue v = ...;
TKey k = ...;
Dictionary<TKey, TValue> d = new();
d[k] = v;
v = d[k];

Beim Schreiben fügt [d[c] = v] das Paar (c, v) hinzu, wenn der Schlüssel [c] nicht existiert, und ersetzt andernfalls den [c] zugeordneten Wert. Beim Lesen löst, wenn der Schlüssel [c] im Dictionary [d] nicht existiert, die Schreibweise [d[c]] eine Ausnahme vom Typ [KeyNotFoundException] aus.

Die wichtigsten Methoden und Eigenschaften der Klasse [Dictionary<TKey,TValue>] sind die folgenden.

Eigenschaften:

Eigenschaft
Funktion
[public int Count { get; }]
Anzahl der Einträge (Schlüssel, Wert) im Dictionary
[public KeyCollection Keys { get; }]
Collection der Schlüssel des Dictionarys
[public ValueCollection Values { get; }]
Collection der Werte des Dictionarys

Methoden:

Methode
Funktion
[public void Add(TKey key, TValue value)]
Fügt das Paar (Schlüssel, Wert) zum Dictionary hinzu; löst eine Ausnahme aus, wenn der Schlüssel bereits existiert
[public bool TryAdd(TKey key, TValue value)]
Wie oben, liefert jedoch [false] , statt eine Ausnahme auszulösen
[public void Clear()]
entfernt alle Paare aus dem Dictionary
[public bool ContainsKey(TKey key)]
Liefert [true] , wenn [key] ein Schlüssel des Dictionarys ist, andernfalls [false]
[public bool ContainsValue(TValue value)]
liefert [true] , wenn [value] ein Wert des Dictionarys ist, [false] sonst
[public bool Remove(TKey key)]
entfernt das Schlüssel-Wert-Paar [key] aus dem Dictionary; liefert [true] , wenn der Vorgang gelingt, [false] sonst
[public bool TryGetValue(TKey key, out TValue value)]
liefert [true] und setzt [value] auf den dem Schlüssel [key] zugeordneten Wert, falls dieser existiert; liefert andernfalls [false] , und [value] erhält den Standardwert des Typs [TValue]

Betrachten wir das Beispielprogramm [collections-03.cs]:

// die Klasse Dictionary<TKey,TValue>

// Erzeugung eines Dictionarys <string,int> aus einem Array von Zeichenketten "name:age"
string[] list = ["jean:20", "paul:18", "mélanie:10", "violette:15"];
Dictionary<string, int> dico = new();
foreach (string element in list)
{
    string[] fields = element.Split(':');
    dico[fields[0]] = int.Parse(fields[1]);
}
// Anzahl der Elemente des Dictionarys
Console.WriteLine($"The dictionary has {dico.Count} elements");
// Liste der Schlüssel
Display("[List of keys]", dico.Keys);
// Liste der Werte
Display("[List of values]", dico.Values);
// Liste der Schlüssel und Werte
Console.WriteLine("[List of keys & values]");
foreach (string key in dico.Keys)
{
    Console.WriteLine($"key={key} value={dico[key]}");
}
// wir entfernen den Schlüssel "paul"
Console.WriteLine("[Removal of a key]");
dico.Remove("paul");
// Iteration über die (Schlüssel, Wert)-Paare mit Dekonstruktion
Console.WriteLine("[List of keys & values]");
foreach (var (key, value) in dico)
{
    Console.WriteLine($"key={key} value={value}");
}
// Add lehnt einen vorhandenen Schlüssel ab, dico[key] = value ersetzt ihn dagegen
try
{
    dico.Add("jean", 21);
}
catch (ArgumentException e)
{
    Console.WriteLine($"{e.GetType().Name} : {e.Message}");
}
// TryAdd fügt nur hinzu, wenn der Schlüssel fehlt
Console.WriteLine($"TryAdd(\"jean\", 21)={dico.TryAdd("jean", 21)}, TryAdd(\"zoé\", 12)={dico.TryAdd("zoé", 12)}");
// die Notation dico[key] löst eine Exception aus, wenn der Schlüssel fehlt
try
{
    Console.WriteLine(dico["x"]);
}
catch (KeyNotFoundException e)
{
    Console.WriteLine($"{e.GetType().Name} : {e.Message}");
}

// Suche im Dictionary
while (true)
{
    Console.Write("Name searched for (nothing to stop): ");
    string searchedName = (Console.ReadLine() ?? "").Trim();
    if (searchedName == "")
    {
        break;
    }
    // TryGetValue liefert true, wenn der Schlüssel existiert, und legt den zugehörigen Wert in age ab
    if (dico.TryGetValue(searchedName, out int age))
    {
        Console.WriteLine($"{searchedName},{age}");
    }
    else
    {
        Console.WriteLine($"Name {searchedName} unknown");
    }
}

// generische Methode zur Anzeige der Elemente einer Sequenz
static void Display<T>(string text, IEnumerable<T> elements)
{
    Console.WriteLine(text.PadRight(50, '-'));
    foreach (T element in elements)
    {
        Console.WriteLine(element);
    }
}

Kommentare:

  • Zeile 4: ein Array von Zeichenketten, das zur Initialisierung des Dictionarys <string,int> dient;
  • Zeile 5: das Dictionary, das leer ist;
  • Zeilen 6–9: seine Initialisierung mithilfe des Arrays von Zeichenketten;
  • Zeile 12: die Anzahl der Einträge im Dictionary;
  • Zeilen 14–16: die Schlüssel und Werte des Dictionarys. [dico.Keys] und [dico.Values] implementieren [IEnumerable<T>]: Die bereits bekannte Methode [Display] eignet sich dafür;
  • Zeile 25: Löschen eines Eintrags des Dictionarys;
  • Zeile 28: Ein Dictionary ist eine Sequenz von Paaren [KeyValuePair<TKey,TValue>], von denen jedes eine Eigenschaft [Key] und eine Eigenschaft [Value] hat. Seit .NET Core 2.0 wird ein solches Paar wie ein Tupel (Kapitel 3) in zwei Variablen zerlegt ;
  • Zeilen 35–42: [Add] weist einen vorhandenen Schlüssel zurück, indem es eine Ausnahme auslöst; [TryAdd] liefert in diesem Fall [false] . Die Ausnahmemeldungen von .NET sind englisch: .NET 10 stellt keine Meldungen auf Französisch bereit;
  • Zeile 46: Der Versuch, einen fehlenden Schlüssel zu lesen, löst eine Ausnahme vom Typ [KeyNotFoundException] aus;
  • Zeile 63: Suche nach einem Schlüssel im Dictionary. [TryGetValue] liefert [true] , wenn der Schlüssel existiert. Der Kurs von 2008 ignorierte dieses Ergebnis und prüfte, ob der zurückgegebene Wert null war – eine Technik, die nur funktionierte, weil der Wert 0 nicht im Dictionary vorkam. Die Prüfung des zurückgegebenen Booleschen Wertes ist der richtige Weg.

Ergebnisse:

> dotnet run collections-03.cs
The dictionary has 4 elements
[List of keys]------------------------------------
jean
paul
mélanie
violette
[List of values]----------------------------------
20
18
10
15
[List of keys & values]
key=jean value=20
key=paul value=18
key=mélanie value=10
key=violette value=15
[Removal of a key]
[List of keys & values]
key=jean value=20
key=mélanie value=10
key=violette value=15
ArgumentException : An item with the same key has already been added. Key: jean
TryAdd("jean", 21)=False, TryAdd("zoé", 12)=True
KeyNotFoundException : The given key 'x' was not present in the dictionary.
Name searched for (nothing to stop): violette
violette,15
Name searched for (nothing to stop): x
Name x unknown
Name searched for (nothing to stop): jean
jean,20
Name searched for (nothing to stop): 

Die Schlüssel werden hier in der Reihenfolge aufgelistet, in der sie hinzugefügt wurden, doch das ist nicht garantiert: Ein *[Dictionary]* behält keinerlei Reihenfolge bei. Nach Löschungen kann ein neues Element den Platz eines gelöschten einnehmen. Wenn die Reihenfolge der Schlüssel wichtig ist, verwenden Sie ein *[SortedDictionary]*, das weiter unten gezeigt wird.

5.4.4. Weitere generische Collections

Der Namespace [System.Collections.Generic] enthält weitere Collections, die jeweils für einen bestimmten Zweck geeignet sind:

Klasse
Funktion
[HashSet<T>]
eine Menge: keine Duplikate, keine Reihenfolge, sehr schneller Enthaltensein-Test; Mengenoperationen (Vereinigung, Schnitt, Differenz)
[SortedSet<T>]
eine Menge, deren Elemente sortiert gehalten werden
[Queue<T>]
eine Warteschlange: Die Elemente werden in der Reihenfolge ausgegeben, in der sie eingefügt wurden (FIFO, first in, first out)
[Stack<T>]
ein Stapel: Das zuletzt hinzugefügte Element wird als Erstes entfernt (LIFO, last in, first out)
[SortedDictionary<TKey,TValue>]
ein Dictionary, dessen Schlüssel sortiert gehalten werden
[PriorityQueue<TElement,TPriority>]
eine Prioritätswarteschlange (.NET 6): Das entfernte Element ist das mit der niedrigsten Priorität
[LinkedList<T>]
eine doppelt verkettete Liste: schnelles Einfügen und Löschen in der Mitte der Liste

Das Programm [collections-04.cs] bietet einen kurzen Überblick:

// ein Überblick über weitere generische Collections

// HashSet<T>: eine Menge, ohne Duplikate und ohne Reihenfolge
HashSet<string> languages = ["C#", "Java", "PHP"];
bool added1 = languages.Add("Python");
bool added2 = languages.Add("Java");             // bereits vorhanden: abgelehnt
Console.WriteLine($"HashSet : Add(Python)={added1}, Add(Java)={added2}, Count={languages.Count}, Contains(PHP)={languages.Contains("PHP")}");
HashSet<string> web = ["PHP", "JavaScript", "Python"];
HashSet<string> common = new(languages);
common.IntersectWith(web);                        // Schnittmenge
Console.WriteLine($"HashSet : intersection = {{{string.Join(", ", common)}}}");
common.UnionWith(["Go"]);                         // Vereinigung
Console.WriteLine($"HashSet : after union = {{{string.Join(", ", common)}}}");

// Queue<T>: eine Warteschlange, first in, first out
Queue<string> queue = new();
queue.Enqueue("client1");
queue.Enqueue("client2");
queue.Enqueue("client3");
Console.WriteLine($"Queue : Peek={queue.Peek()}, Dequeue={queue.Dequeue()}, Dequeue={queue.Dequeue()}, {queue.Count} left");

// Stack<T>: ein Stapel, last in, first out
Stack<int> stack = new();
stack.Push(1);
stack.Push(2);
stack.Push(3);
Console.WriteLine($"Stack : Peek={stack.Peek()}, Pop={stack.Pop()}, Pop={stack.Pop()}, {stack.Count} left");
// TryPop vermeidet die Exception bei einem leeren Stapel
stack.Pop();
Console.WriteLine($"Stack : TryPop on an empty stack = {stack.TryPop(out int top)}");

// SortedDictionary<TKey,TValue>: ein Dictionary, dessen Schlüssel sortiert gehalten werden
SortedDictionary<string, int> ages = new()
{
    ["violette"] = 15,
    ["jean"] = 20,
    ["mélanie"] = 10,
    ["paul"] = 18
};
Console.WriteLine($"SortedDictionary : {string.Join(", ", ages)}");

// PriorityQueue<TElement,TPriority>: das Element mit der niedrigsten Priorität kommt immer zuerst heraus
PriorityQueue<string, int> emergencies = new();
emergencies.Enqueue("sprain", 3);
emergencies.Enqueue("cardiac arrest", 1);
emergencies.Enqueue("cold", 5);
emergencies.Enqueue("fracture", 2);
Console.Write("PriorityQueue :");
while (emergencies.TryDequeue(out string? patient, out int priority))
{
    Console.Write($" {patient} ({priority})");
}
Console.WriteLine();

Ergebnisse:

1
2
3
4
5
6
7
8
9
> dotnet run collections-04.cs
HashSet : Add(Python)=True, Add(Java)=False, Count=4, Contains(PHP)=True
HashSet : intersection = {PHP, Python}
HashSet : after union = {Go, PHP, Python}
Queue : Peek=client1, Dequeue=client1, Dequeue=client2, 1 left
Stack : Peek=3, Pop=3, Pop=2, 1 left
Stack : TryPop on an empty stack = False
SortedDictionary : [jean, 20], [mélanie, 10], [paul, 18], [violette, 15]
PriorityQueue : cardiac arrest (1) fracture (2) sprain (3) cold (5)

Kommentare:

  • Zeile 4: Collection-Ausdrücke initialisieren auch eine Menge;
  • Zeile 6: [Add] liefert [false] , wenn das Element bereits in der Menge enthalten ist, die dann unverändert bleibt;
  • Zeilen 9–12: [IntersectWith] und [UnionWith] verändern die Menge; wir arbeiten daher mit einer Kopie von [languages]. Die Reihenfolge, in der die Elemente einer Menge angezeigt werden, ist bedeutungslos (Zeile 4);
  • Die doppelten geschweiften Klammern [{{] und [}}] geben in einer interpolierten Zeichenkette eine einzelne geschweifte Klammer aus;
  • Zeilen 16–20: [Enqueue] reiht ein Element in die Warteschlange ein, [Dequeue] entnimmt das älteste Element, [Peek] liest das Element, ohne es zu entnehmen;
  • Zeilen 23–30: [Push] legt ein Element auf den Stapel, [Pop] entnimmt das jüngste Element. [Pop] löst bei einem leeren Stapel eine Ausnahme aus; [TryPop] liefert [false];
  • Zeilen 33–40: ein Dictionary, das mit der Syntax [[key] = value] initialisiert wird; seine Schlüssel-Wert-Paare werden in der Reihenfolge der Schlüssel durchlaufen;
  • Zeilen 43–49: Jedes Element wird mit einer Priorität in die Warteschlange eingereiht; Patienten verlassen sie in aufsteigender Reihenfolge der Priorität, unabhängig von der Reihenfolge ihrer Ankunft.

5.4.5. Schreibgeschützte Collections

Eine Klasse, die eine Collection verwaltet, muss diese oft nach außen bereitstellen, ohne dass sie verändert werden darf. .NET stellt hierfür schreibgeschützte Schnittstellen bereit: [IReadOnlyCollection<T>] (eine Eigenschaft [Count] und ein [foreach]), [IReadOnlyList<T>] (zusätzlich der indexbasierte Zugriff) und [IReadOnlyDictionary<TKey,TValue>]. Die Klassen [List<T>], [T[]], und [Dictionary<TKey,TValue>] implementieren sie. Das Programm [collections-05.cs] verwendet sie:

// schreibgeschützte Collections

var classroom = new Classroom();
classroom.Enroll("dupont");
classroom.Enroll("martin");
// der Code außerhalb kann die Liste der Schüler lesen...
IReadOnlyList<string> students = classroom.Students;
Console.WriteLine($"{students.Count} students: {string.Join(", ", students)}, students[0]={students[0]}");
// ... aber die Schnittstelle IReadOnlyList<T> hat weder Add noch Remove: students.Add("x") lässt sich nicht kompilieren

// ein Cast nach List<string> würde es ermöglichen, den Schutz zu umgehen
if (students is List<string> list)
{
    Console.WriteLine("Students is actually a modifiable List<string>");
}
// AsReadOnly liefert einen schreibgeschützten Wrapper, der sich nicht umgehen lässt
IReadOnlyList<string> protectedList = classroom.ProtectedStudents;
Console.WriteLine($"ProtectedStudents is of type {protectedList.GetType().Name}");
try
{
    // ReadOnlyCollection<T> implementiert IList<T>, aber seine Änderungsmethoden lösen eine Exception aus
    ((IList<string>)protectedList).Add("intruder");
}
catch (NotSupportedException e)
{
    Console.WriteLine($"{e.GetType().Name} : {e.Message}");
}
// der Wrapper spiegelt die Änderungen der besitzenden Klasse wider
classroom.Enroll("durand");
Console.WriteLine($"{protectedList.Count} students: {string.Join(", ", protectedList)}");

// ein schreibgeschütztes Dictionary
IReadOnlyDictionary<string, int> grades = new Dictionary<string, int> { ["dupont"] = 12, ["martin"] = 15 };
Console.WriteLine($"grades[martin]={grades["martin"]}, ContainsKey(durand)={grades.ContainsKey("durand")}");

// eine Klasse, die die Kontrolle über ihre Liste behält
class Classroom
{
    // die Liste ist privat: nur die Klasse kann sie ändern
    private readonly List<string> _students = [];

    // über eine Schnittstelle schreibgeschützt bereitgestellt
    public IReadOnlyList<string> Students => _students;
    // über einen schreibgeschützten Wrapper bereitgestellt
    public IReadOnlyList<string> ProtectedStudents => _students.AsReadOnly();

    public void Enroll(string name) => _students.Add(name);
}

Ergebnisse:

1
2
3
4
5
6
7
> dotnet run collections-05.cs
2 students: dupont, martin, students[0]=dupont
Students is actually a modifiable List<string>
ProtectedStudents is of type ReadOnlyCollection`1
NotSupportedException : Collection is read-only.
3 students: dupont, martin, durand
grades[martin]=15, ContainsKey(durand)=False

Kommentare:

  • Zeilen 37–47: Die Klasse [Classroom] verwaltet eine Liste von Schülern. Die Liste selbst ist privat; nur die Methode [Enroll] erlaubt es, sie zu verändern;
  • Zeile 43: Die Eigenschaft [Students] wandelt die Liste in den Typ [IReadOnlyList<string>] um, der nur Lesezugriffe unterstützt: [students.Add("x")] würde einen Kompilierungsfehler verursachen;
  • Zeile 12: Dieser Schutz ist jedoch nur oberflächlich: Das zurückgegebene Objekt ist die Liste selbst, und eine Typumwandlung verschafft Zugriff auf ihre Änderungsmethoden;
  • Zeile 45: [AsReadOnly] verpackt die Liste in einen Container vom Typ [ReadOnlyCollection<T>]. Diesmal sind keine Änderungen möglich: Seine Änderungsmethoden, die von der Schnittstelle [IList<T>] vorgeschrieben werden, lösen eine Ausnahme vom Typ [NotSupportedException] aus (Zeile 5). Der Wrapper kopiert die Liste nicht: Er sieht die Änderungen, die die besitzende Klasse vornimmt (Zeile 6);
  • Zeile 33: ein Dictionary, betrachtet über die Schnittstelle [IReadOnlyDictionary<TKey,TValue>].

Für Daten, die nach ihrer Erstellung nie mehr verändert werden dürfen, stellt der Namespace [System.Collections.Immutable] unveränderliche Collections bereit ([ImmutableList<T>], [ImmutableDictionary<TKey,TValue>] …), und [System.Collections.Frozen] bietet auf Lesezugriffe optimierte, eingefrorene Collections ([FrozenDictionary<TKey,TValue>], .NET 8). Wir gehen darauf nicht näher ein.

5.5. LINQ

Der Kurs von 2008 endete unmittelbar vor LINQ und führte dessen anonyme Typen ein, ohne sie tatsächlich zu verwenden. LINQ (Language Integrated Query, C# 3, 2007) ist eine Menge von Methoden, mit denen man eine Collection so abfragen kann, wie man eine Datenbank abfragt: filtern, sortieren, gruppieren, Summen berechnen und so weiter. Es lässt sich auf jede Collection anwenden, die die Schnittstelle [IEnumerable<T>] implementiert: Arrays, Listen, Dictionarys, Mengen, Zeilen einer Datei, Ergebnisse eines regulären Ausdrucks und, mit Entity Framework Core (Kapitel 11), Datenbanktabellen. Der Namespace [System.Linq] gehört zu den impliziten [using]-Namespaces.

5.5.1. Die Sequenzen IEnumerable<T> und Iteratoren

Eine Collection, die [IEnumerable<T>] implementiert, wird als Sequenz bezeichnet: Man kann sie mit [foreach] durchlaufen. Die Schnittstelle enthält nur eine Methode, [GetEnumerator], die einen Enumerator [IEnumerator<T>] zurückgibt: ein Objekt, das sich durch die Sequenz bewegt ([MoveNext]) und das aktuelle Element liefert ([Current]).

Eine Methode kann eine Sequenz erzeugen, ohne eine Collection aufzubauen: Das ist ein Iterator. Er gibt seine Elemente mit der Anweisung [yield return] einzeln zurück. Das Programm [linq-01.cs] liefert zwei Beispiele:

// IEnumerable<T>-Sequenzen und Iteratoren (yield return)

// 1 - foreach auf einer von einem Iterator erzeugten Sequenz
Console.WriteLine("[foreach on Evens(6)]");
foreach (int n in Evens(6))
{
    Console.WriteLine($"  received {n}");
}

// 2 - was foreach tut: es fordert von der Sequenz einen Enumerator an
Console.WriteLine("[enumeration by hand]");
IEnumerable<int> sequence = Evens(4);
using (IEnumerator<int> enumerator = sequence.GetEnumerator())
{
    while (enumerator.MoveNext())
    {
        Console.WriteLine($"  Current={enumerator.Current}");
    }
}

// 3 - eine unendliche Sequenz: sie wird nur nach Bedarf erzeugt
Console.WriteLine("[infinite sequence]");
foreach (long f in Fibonacci())
{
    if (f > 100)
    {
        break;
    }
    Console.Write($"{f} ");
}
Console.WriteLine();

// 4 - ein Array, eine Liste, eine Zeichenkette sind ebenfalls IEnumerable<T>
IEnumerable<char> letters = "abc";
IEnumerable<string> words = new List<string> { "one", "two" };
Console.WriteLine($"[other sequences] {string.Join("-", letters)} {string.Join("-", words)}");

// die geraden Zahlen von 0 bis max
static IEnumerable<int> Evens(int max)
{
    Console.WriteLine("  (start of the iterator)");
    for (int i = 0; i <= max; i += 2)
    {
        Console.WriteLine($"  (production of {i})");
        // wir geben i an den aufrufenden Code zurück; bei der nächsten Anforderung machen wir hier weiter
        yield return i;
    }
    Console.WriteLine("  (end of the iterator)");
}

// die Fibonacci-Folge, endlos
static IEnumerable<long> Fibonacci()
{
    long a = 0, b = 1;
    while (true)
    {
        yield return a;
        (a, b) = (b, a + b);
    }
}

Ergebnisse:

> dotnet run linq-01.cs
[foreach on Evens(6)]
  (start of the iterator)
  (production of 0)
  received 0
  (production of 2)
  received 2
  (production of 4)
  received 4
  (production of 6)
  received 6
  (end of the iterator)
[enumeration by hand]
  (start of the iterator)
  (production of 0)
  Current=0
  (production of 2)
  Current=2
  (production of 4)
  Current=4
  (end of the iterator)
[infinite sequence]
0 1 1 2 3 5 8 13 21 34 55 89 
[other sequences] a-b-c one-two

Kommentare:

  • Zeilen 39–48: Die Methode [Evens] ist ein Iterator: Ihr Rückgabetyp ist *[IEnumerable<int>], und sie enthält die Anweisung [yield return] (Zeile 46). Sie baut keine Liste auf: Bei jedem [yield return] gibt sie ein Element an den Code zurück, der sie durchläuft, und pausiert*; sie setzt bei der nächsten Anweisung fort, wenn das nächste Element angefordert wird;
  • Zeilen 5–7: Die Ergebnisse (Zeilen 3–12) zeigen, dass die Erzeugung eines Elements durch den Iterator und sein Verbrauch durch die Schleife [foreach] sich abwechseln;
  • Zeilen 12–17: Was [foreach] tatsächlich tut: Es fordert von der Sequenz einen Enumerator an, ruft [MoveNext] so lange auf, wie diese Methode [true] liefert, und liest das aktuelle Element aus [Current]. Der Iterator wird am Ende durch die Anweisung [using] freigegeben (darauf kommen wir bei den Dateien zurück). Beachten Sie, dass der Aufruf von [Evens(4)] in Zeile 12 nichts bewirkt: Die Meldung „start of the iterator“ erscheint erst beim ersten Aufruf von [MoveNext];
  • Zeilen 52–58: Ein Iterator kann eine unendliche Sequenz erzeugen; er berechnet nur die angeforderten Elemente. Die Schleife [foreach] entscheidet, wann abgebrochen wird (Zeile 25). Zeile 58 nutzt die Tupel aus Kapitel 3, um Werte zu vertauschen;
  • Zeilen 34–35: Eine Zeichenkette ist eine Sequenz von Zeichen; eine Liste ist eine Sequenz ihrer Elemente. Die Liste wird hier mit der Syntax [new List<string> { ... }] Collection-Initialisierer (C# 3) erstellt, die in bestehendem Code häufig anzutreffen ist.

Dieser Mechanismus der Erzeugung bei Bedarf wird von allen Methoden von LINQ genutzt.

5.5.2. Filtern, Projizieren, Sortieren

Die folgenden Beispiele arbeiten mit einer kleinen Liste von Personen. Eine Person wird durch einen [record] (C# 9) Record dargestellt, der in Kapitel 4 eingeführt wurde: In einer einzigen Zeile erhalten wir eine Klasse mit einem Konstruktor, schreibgeschützten Eigenschaften, einer Methode [ToString], die die Eigenschaften anzeigt, und einem Gleichheitsoperator, der die Eigenschaftswerte vergleicht.

Das Programm [linq-02.cs] demonstriert die grundlegenden Methoden von LINQ:

// LINQ: Filtern (Where), Projizieren (Select), Sortieren (OrderBy, ThenBy)

// die Daten: eine Liste von Personen
List<Person> persons =
[
    new("dupont", "jean", 45, "Angers"),
    new("martin", "marie", 17, "Paris"),
    new("durand", "paul", 32, "Angers"),
    new("leroy", "sophie", 28, "Nantes"),
    new("moreau", "luc", 15, "Paris"),
    new("simon", "julie", 52, "Angers"),
    new("laurent", "marc", 32, "Lyon"),
];

// Where: die Erwachsenen; p => p.Age >= 18 ist eine anonyme Funktion
IEnumerable<Person> adults = persons.Where(p => p.Age >= 18);
Display("[Where: the adults]", adults);

// Select: eine Projektion, hier wird jede Person zu einer Zeichenkette
IEnumerable<string> names = persons.Select(p => $"{p.FirstName} {p.LastName.ToUpper()}");
Display("[Select: first name LAST NAME]", names);

// Operatoren lassen sich verketten: die Namen der Einwohner von Angers in alphabetischer Reihenfolge
var angersPeople = persons
    .Where(p => p.City == "Angers")
    .OrderBy(p => p.LastName)
    .Select(p => p.LastName);
Display("[Where + OrderBy + Select: the people of Angers]", angersPeople);

// Sortieren nach mehreren Kriterien: absteigendes Alter, dann aufsteigender Nachname
var sorted = persons.OrderByDescending(p => p.Age).ThenBy(p => p.LastName);
Display("[OrderByDescending + ThenBy]", sorted);

// dieselbe Abfrage wie 'angersPeople', in der Abfragesyntax geschrieben
var angersPeople2 = from p in persons
                    where p.City == "Angers"
                    orderby p.LastName
                    select p.LastName;
Display("[query syntax: the people of Angers]", angersPeople2);

// Select kann auch die Position des Elements liefern
var numbered = persons.Take(3).Select((p, i) => $"{i + 1}. {p.LastName}");
Display("[Select with index]", numbered);

// Anzeige einer Sequenz
static void Display<T>(string title, IEnumerable<T> sequence)
{
    Console.WriteLine(title);
    foreach (T element in sequence)
    {
        Console.WriteLine($"  {element}");
    }
}

// eine Person
record Person(string LastName, string FirstName, int Age, string City);

Ergebnisse:

> dotnet run linq-02.cs
[Where: the adults]
  Person { LastName = dupont, FirstName = jean, Age = 45, City = Angers }
  Person { LastName = durand, FirstName = paul, Age = 32, City = Angers }
  Person { LastName = leroy, FirstName = sophie, Age = 28, City = Nantes }
  Person { LastName = simon, FirstName = julie, Age = 52, City = Angers }
  Person { LastName = laurent, FirstName = marc, Age = 32, City = Lyon }
[Select: first name LAST NAME]
  jean DUPONT
  marie MARTIN
  paul DURAND
  sophie LEROY
  luc MOREAU
  julie SIMON
  marc LAURENT
[Where + OrderBy + Select: the people of Angers]
  dupont
  durand
  simon
[OrderByDescending + ThenBy]
  Person { LastName = simon, FirstName = julie, Age = 52, City = Angers }
  Person { LastName = dupont, FirstName = jean, Age = 45, City = Angers }
  Person { LastName = durand, FirstName = paul, Age = 32, City = Angers }
  Person { LastName = laurent, FirstName = marc, Age = 32, City = Lyon }
  Person { LastName = leroy, FirstName = sophie, Age = 28, City = Nantes }
  Person { LastName = martin, FirstName = marie, Age = 17, City = Paris }
  Person { LastName = moreau, FirstName = luc, Age = 15, City = Paris }
[query syntax: the people of Angers]
  dupont
  durand
  simon
[Select with index]
  1. dupont
  2. martin
  3. durand

Kommentare:

  • Zeilen 4–13: die Liste der Personen, initialisiert durch einen Collection-Ausdruck; [new(...)] erstellt ein Objekt des erwarteten Typs, hier [Person];
  • Zeile 56: der Record [Person]. Eine Einzeldatei-Anwendung platziert ihre Typdeklarationen nach den Top-Level-Anweisungen;
  • Zeile 16: Die Methode [Where] filtert die Sequenz: Sie behält nur die Elemente, die eine Bedingung erfüllen. Diese Bedingung wird ihr in Form einer anonymen Funktion [p => p.Age >= 18] übergeben, die man liest als „die Funktion, die einer Person p den Booleschen Wert p.Age >= 18 zuordnet“. Diese Schreibweise heißt Lambda-Ausdruck. [Where] ruft diese Funktion für jede Person auf. Lambdas werden in Kapitel 7 („Delegaten, Lambdas und Ereignisse“) ausführlich behandelt; vorerst genügt es, sie lesen zu können;
  • Das Ergebnis von [Where] ist eine neue Sequenz, [IEnumerable<Person>]: die Liste [persons] bleibt unverändert. Das gilt für alle Methoden von LINQ;
  • die Methode [Display] zeigt jede Person mit der für den Record erzeugten Methode [ToString] an: [Person { LastName = dupont, ... }];
  • Zeile 20: Die Methode [Select] bildet jedes Element der Sequenz auf einen neuen Wert ab, hier eine Zeichenkette. Das Ergebnis ist eine Sequenz [IEnumerable<string>];
  • Zeilen 24–27: Die Methoden von LINQ liefern Sequenzen, auf die weitere Methoden von LINQ angewendet werden können. Methoden werden oft einzeln pro Zeile geschrieben: Diese Aufrufkette liest sich von oben nach unten wie ein Rezept;
  • Zeile 26: [OrderBy] sortiert die Sequenz nach dem Schlüssel, den die Lambda-Funktion liefert, hier dem Namen;
  • Zeile 31: [OrderByDescending] sortiert absteigend; [ThenBy] (oder [ThenByDescending]) fügt ein sekundäres Kriterium hinzu, mit dem Elemente unterschieden werden, die nach dem ersten Kriterium gleich sind: Durand und Laurent, die beide 32 Jahre alt sind, werden nach dem Namen sortiert (Zeilen 23–24);
  • Zeilen 35–38: dieselbe Abfrage wie [angersPeople] , geschrieben in der Abfragesyntax, die SQL ähnelt. Der Compiler übersetzt sie exakt in die Aufrufkette [Where(...).OrderBy(...).Select(...)]: Die beiden Schreibweisen sind gleichwertig. Die Abfragesyntax ist bei Joins und Gruppierungen besser lesbar; die Methodensyntax ist gebräuchlicher, und nur sie bietet Zugriff auf alle Methoden von LINQ ([Take], [Count], [First] …);
  • Zeile 42: Eine Variante von [Select] übergibt der Lambda-Funktion das Element und seine Position in der Sequenz.

5.5.3. Quantoren, Aggregate, Elementauswahl

Das Programm [linq-03.cs] enthält Methoden, die einen einzelnen Wert zurückgeben, und Methoden, die einen Teil der Sequenz auswählen:

// LINQ: Quantoren, Aggregate, Elementauswahl, Partitionen

List<Person> persons =
[
    new("dupont", "jean", 45, "Angers"),
    new("martin", "marie", 17, "Paris"),
    new("durand", "paul", 32, "Angers"),
    new("leroy", "sophie", 28, "Nantes"),
    new("moreau", "luc", 15, "Paris"),
    new("simon", "julie", 52, "Angers"),
    new("laurent", "marc", 32, "Lyon"),
];

// Quantoren: Any (mindestens eines), All (alle)
Console.WriteLine($"Any(minor)={persons.Any(p => p.Age < 18)}, All(minor)={persons.All(p => p.Age < 18)}, Any()={persons.Any()}");

// Aggregate
Console.WriteLine($"Count()={persons.Count()}, Count(Angers)={persons.Count(p => p.City == "Angers")}");
Console.WriteLine($"Sum(age)={persons.Sum(p => p.Age)}, Average(age)={persons.Average(p => p.Age):F2}");
Console.WriteLine($"Min(age)={persons.Min(p => p.Age)}, Max(age)={persons.Max(p => p.Age)}");
// MinBy, MaxBy liefern das Element selbst und nicht den minimalen oder maximalen Wert
Console.WriteLine($"MinBy(age)={persons.MinBy(p => p.Age)?.LastName}, MaxBy(age)={persons.MaxBy(p => p.Age)?.LastName}");

// Auswahl eines Elements
Console.WriteLine($"First()={persons.First().LastName}, First(Paris)={persons.First(p => p.City == "Paris").LastName}, Last()={persons.Last().LastName}");
Person? unknown = persons.FirstOrDefault(p => p.City == "Brest");
Console.WriteLine($"FirstOrDefault(Brest)={unknown?.LastName ?? "null"}");
Console.WriteLine($"Single(Lyon)={persons.Single(p => p.City == "Lyon").LastName}");
try
{
    // Single verlangt genau ein Element
    _ = persons.Single(p => p.City == "Angers");
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"Single(Angers) : {e.GetType().Name} : {e.Message}");
}
try
{
    // First verlangt mindestens ein Element
    _ = persons.First(p => p.City == "Brest");
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"First(Brest) : {e.GetType().Name} : {e.Message}");
}

// Distinct: entfernt Duplikate
var cities = persons.Select(p => p.City).Distinct();
Console.WriteLine($"Distinct(cities)=[{string.Join(", ", cities)}]");
// DistinctBy: ein Element pro Schlüsselwert
var onePerCity = persons.DistinctBy(p => p.City).Select(p => p.LastName);
Console.WriteLine($"DistinctBy(city)=[{string.Join(", ", onePerCity)}]");

// Partitionen: Take, Skip, TakeWhile
var names = persons.Select(p => p.LastName);
Console.WriteLine($"Take(2)=[{string.Join(", ", names.Take(2))}], Skip(5)=[{string.Join(", ", names.Skip(5))}]");
Console.WriteLine($"Skip(2).Take(2)=[{string.Join(", ", names.Skip(2).Take(2))}], TakeWhile(length 6)=[{string.Join(", ", names.TakeWhile(n => n.Length == 6))}]");

// Chunk: Aufteilung in Pakete fester Größe (Paginierung)
int page = 1;
foreach (Person[] packet in persons.Chunk(3))
{
    Console.WriteLine($"page {page++} : {string.Join(", ", packet.Select(p => p.LastName))}");
}

record Person(string LastName, string FirstName, int Age, string City);

Ergebnisse:

> dotnet run linq-03.cs
Any(minor)=True, All(minor)=False, Any()=True
Count()=7, Count(Angers)=3
Sum(age)=221, Average(age)=31.57
Min(age)=15, Max(age)=52
MinBy(age)=moreau, MaxBy(age)=simon
First()=dupont, First(Paris)=martin, Last()=laurent
FirstOrDefault(Brest)=null
Single(Lyon)=laurent
Single(Angers) : InvalidOperationException : Sequence contains more than one matching element
First(Brest) : InvalidOperationException : Sequence contains no matching element
Distinct(cities)=[Angers, Paris, Nantes, Lyon]
DistinctBy(city)=[dupont, martin, leroy, laurent]
Take(2)=[dupont, martin], Skip(5)=[simon, laurent]
Skip(2).Take(2)=[durand, leroy], TakeWhile(length 6)=[dupont, martin, durand]
page 1 : dupont, martin, durand
page 2 : leroy, moreau, simon
page 3 : laurent

Kommentare:

  • Zeile 15: [Any] liefert [true] , wenn mindestens ein Element die Bedingung erfüllt, und [All] , wenn alle sie erfüllen. Ohne Parameter zeigt [Any] an, ob die Sequenz nicht leer ist;
  • Zeilen 18–20: Die Aggregate [Count], [Sum], [Average], [Min], [Max] berechnen einen Wert auf Grundlage der gesamten Sequenz. [Count] akzeptiert eine Bedingung (eine Liste hat auch eine Eigenschaft [Count], der man ohne Bedingung gegenüber der Methode den Vorzug gibt); [Sum], [Average], [Min] und [Max] akzeptieren eine Lambda-Funktion, die den für jedes Element zu berücksichtigenden Wert angibt;
  • Zeile 22: [MinBy] und [MaxBy] (.NET 6) liefern das Element (hier die Person), für das der Schlüssel minimal oder maximal ist, nicht den Schlüsselwert selbst. Bei einer leeren Sequenz von Objekten (Referenztyp) liefern sie [null], daher der Operator [?.];
  • Zeile 25: [First] liefert das erste Element der Sequenz oder das erste, das eine Bedingung erfüllt; [Last] liefert das letzte;
  • Zeile 26: Wenn kein Element passt, löst [First] eine Ausnahme aus (Zeile 11 der Ergebnisse), während [FirstOrDefault] den Standardwert des Typs liefert, hier [null];
  • Zeile 28: [Single] liefert das einzige Element, das die Bedingung erfüllt, und löst eine Ausnahme aus, wenn es null oder mehrere solcher Elemente gibt (Zeile 10). Das verwendet man, wenn Eindeutigkeit eine Regel der Daten ist, etwa bei der Suche nach einem Element anhand seines Schlüssels. [SingleOrDefault] liefert den Standardwert, wenn es kein Element gibt;
  • Zeile 32: Das Ergebnis des Aufrufs wird nicht verwendet; es wird dem ignorierten Element [_] (C# 7) zugewiesen, um dies zu kennzeichnen;
  • Zeile 49: [Distinct] entfernt Duplikate; [DistinctBy] (.NET 6) behält das erste Element je Schlüsselwert;
  • Zeilen 57–58: [Take(n)] behält die ersten n Elemente, [Skip(n)] überspringt sie. Kombiniert extrahieren sie eine „Seite“ von Ergebnissen. [TakeWhile] behält die Elemente, solange eine Bedingung erfüllt ist, und stoppt beim ersten Element, das sie nicht erfüllt;
  • Zeile 62: [Chunk] (.NET 6) teilt die Sequenz in Arrays von 3 Elementen auf, von denen das letzte kürzer sein kann;
  • Zeile 64: Die Variable [page] wird nach ihrer Verwendung in der Interpolation inkrementiert.

5.5.4. Anonyme Typen, Gruppierungen, Joins

Das Programm [linq-04.cs] führt anonyme Typen und komplexere Operationen ein:

// LINQ: anonyme Typen, Gruppierungen, Joins, Konvertierungen

List<Person> persons =
[
    new("dupont", "jean", 45, "Angers"),
    new("martin", "marie", 17, "Paris"),
    new("durand", "paul", 32, "Angers"),
    new("leroy", "sophie", 28, "Nantes"),
    new("moreau", "luc", 15, "Paris"),
    new("simon", "julie", 52, "Angers"),
    new("laurent", "marc", 32, "Lyon"),
];
List<City> cities =
[
    new("Angers", "Maine-et-Loire"),
    new("Nantes", "Loire-Atlantique"),
    new("Paris", "Paris"),
    new("Brest", "Finistère"),
];

// 1 - ein anonymer Typ: ein Objekt, dessen namenloser Typ vom Compiler erzeugt wird
var p1 = new { LastName = "dupont", Age = 45 };
Console.WriteLine($"[anonymous type] {p1}, p1.LastName={p1.LastName}");
// Select auf einen anonymen Typ: wir behalten nur die nützlichen Eigenschaften
var summaries = persons.Where(p => p.Age > 40).Select(p => new { p.LastName, Decade = p.Age / 10 * 10 });
foreach (var r in summaries)
{
    Console.WriteLine($"  {r.LastName} is over {r.Decade} years old");
}

// 2 - GroupBy: Gruppierung der Personen nach Stadt
Console.WriteLine("[GroupBy]");
foreach (IGrouping<string, Person> group in persons.GroupBy(p => p.City))
{
    // eine Gruppe hat einen Schlüssel (Key) und ist selbst eine Sequenz von Personen
    Console.WriteLine($"  {group.Key} : {group.Count()} person(s), average age {group.Average(p => p.Age):F1} ({string.Join(", ", group.Select(p => p.LastName))})");
}

// 3 - Join: Verknüpfung von Personen und Städten über den Namen der Stadt
Console.WriteLine("[Join]");
var join = persons.Join(cities,
    p => p.City,                                     // Schlüssel auf der Seite der Personen
    c => c.Name,                                     // Schlüssel auf der Seite der Städte
    (p, c) => new { p.LastName, c.Department });     // was wir von einem Paar behalten
foreach (var j in join)
{
    Console.WriteLine($"  {j.LastName} lives in the department {j.Department}");
}
// derselbe Join in der Abfragesyntax: Lyon, in der Städteliste nicht vorhanden, verschwindet ebenfalls
var join2 = from p in persons
            join c in cities on p.City equals c.Name
            where p.Age >= 18
            select $"{p.LastName}/{c.Department}";
Console.WriteLine($"[join in query syntax] {string.Join(", ", join2)}");

// 4 - Konvertierungen: ToList, ToArray, ToDictionary
List<string> adultNames = persons.Where(p => p.Age >= 18).Select(p => p.LastName).ToList();
Dictionary<string, int> agesByName = persons.ToDictionary(p => p.LastName, p => p.Age);
Console.WriteLine($"[ToList] {adultNames.Count} adults; [ToDictionary] agesByName[\"leroy\"]={agesByName["leroy"]}");

// 5 - .NET 9: CountBy, AggregateBy, Index
Console.WriteLine("[CountBy]");
foreach (KeyValuePair<string, int> pair in persons.CountBy(p => p.City))
{
    Console.WriteLine($"  {pair.Key}={pair.Value}");
}
Console.WriteLine("[AggregateBy: sum of the ages by city]");
foreach (var (city, total) in persons.AggregateBy(p => p.City, 0, (sum, p) => sum + p.Age))
{
    Console.WriteLine($"  {city}={total}");
}
Console.WriteLine("[Index]");
foreach (var (index, person) in persons.Where(p => p.Age < 30).Index())
{
    Console.WriteLine($"  {index} : {person.LastName}");
}

record Person(string LastName, string FirstName, int Age, string City);
record City(string Name, string Department);

Ergebnisse:

> dotnet run linq-04.cs
[anonymous type] { LastName = dupont, Age = 45 }, p1.LastName=dupont
  dupont is over 40 years old
  simon is over 50 years old
[GroupBy]
  Angers : 3 person(s), average age 43.0 (dupont, durand, simon)
  Paris : 2 person(s), average age 16.0 (martin, moreau)
  Nantes : 1 person(s), average age 28.0 (leroy)
  Lyon : 1 person(s), average age 32.0 (laurent)
[Join]
  dupont lives in the department Maine-et-Loire
  martin lives in the department Paris
  durand lives in the department Maine-et-Loire
  leroy lives in the department Loire-Atlantique
  moreau lives in the department Paris
  simon lives in the department Maine-et-Loire
[join in query syntax] dupont/Maine-et-Loire, durand/Maine-et-Loire, leroy/Loire-Atlantique, simon/Maine-et-Loire
[ToList] 5 adults; [ToDictionary] agesByName["leroy"]=28
[CountBy]
  Angers=3
  Paris=2
  Nantes=1
  Lyon=1
[AggregateBy: sum of the ages by city]
  Angers=129
  Paris=32
  Nantes=28
  Lyon=32
[Index]
  0 : martin
  1 : leroy
  2 : moreau

Kommentare:

  • Zeile 22: ein anonymer Typ (C# 3): Der Ausdruck [new { LastName = ..., Age = ... }] erzeugt ein Objekt, dessen namenlose Klasse vom Compiler mit zwei schreibgeschützten Eigenschaften generiert wird, [LastName] und [Age]. Da dieser Typ keinen Namen hat, muss die Variable als [var] deklariert werden. Der Compiler kennt diesen Typ jedoch genau: [p1.LastName] wird zur Kompilierzeit überprüft, und der Editor schlägt die Eigenschaften von [p1] in der automatischen Vervollständigung vor;
  • Zeile 25: die Hauptverwendung anonymer Typen: in einem [Select] nur die nützlichen Daten behalten, ohne dafür eine Klasse deklarieren zu müssen. [p.LastName] ist eine Abkürzung für [LastName = p.LastName];
  • Zeile 33: [GroupBy] gruppiert Elemente mit demselben Schlüssel. Das Ergebnis ist eine Sequenz von Gruppen [IGrouping<TKey,TElement>]: Jede Gruppe hat eine Eigenschaft [Key], den gemeinsamen Wert des Schlüssels, und ist selbst die Sequenz der Elemente der Gruppe, auf die wir [Count], [Average], [Select] … anwenden können (Zeile 36);
  • Zeilen 41–44: [Join] ordnet jeder Person die Stadt mit demselben Namen zu. Ihre Parameter sind die zweite Sequenz, der Join-Schlüssel auf jeder Seite und eine Lambda-Funktion, die das Ergebnis aus einem Paar (Person, Stadt) erzeugt. Wie ein SQL-Join [Join] behält es nur die zusammenpassenden Paare: Laurent, der in Lyon wohnt – das in der Liste der Städte fehlt –, erscheint nicht, ebenso wenig Brest, das keine Einwohner hat;
  • Zeilen 50–53: der Join in der Abfragesyntax, die besser lesbar ist: [join ... in ... on ... equals ...]. Hinzu kommt ein Filter, [where]. Die Abfragesyntax enthält außerdem eine Klausel [group ... by ...] für Gruppierungen;
  • Zeile 57: [ToList] (und [ToArray]) führt die Abfrage aus und speichert ihre Ergebnisse in einer Liste (einem Array);
  • Zeile 58: [ToDictionary] erstellt ein Dictionary: Die erste Lambda-Funktion liefert den Schlüssel jedes Elements, die zweite seinen Wert. Ein doppelter Schlüssel löst eine Ausnahme aus;
  • Zeile 63: [CountBy] (.NET 9) zählt die Elemente je Schlüsselwert. Es liefert eine Sequenz von Paaren [KeyValuePair<string,int>]. Das ist eine Kurzform für [GroupBy(p => p.City).Select(g => (g.Key, g.Count()))];
  • Zeile 68: [AggregateBy] (.NET 9) akkumuliert einen Wert je Schlüsselwert: Ausgehend von 0 wird für jede Person ihr Alter zur Summe ihrer Stadt addiert. Die zurückgegebenen Tupel werden in der Schleife [foreach] zerlegt;
  • Zeile 73: [Index] (.NET 9) ordnet jedem Element seine Position in der Sequenz zu, in Form eines Tupels (Position, Element).

5.5.5. Verzögerte Ausführung

Eine LINQ-Abfrage wird nicht ausgeführt, wenn sie geschrieben wird, sondern wenn ihr Ergebnis durchlaufen wird: Das ist die verzögerte Ausführung. Das Programm [linq-05.cs] demonstriert dies anhand von Lambda-Funktionen, die anzeigen, was sie tun:

// LINQ: verzögerte Ausführung

List<int> numbers = [1, 2, 3, 4, 5, 6];

// 1 - das Definieren einer Abfrage führt sie nicht aus
Console.WriteLine("[definition of the query]");
IEnumerable<int> evenSquares = numbers
    .Where(n =>
    {
        Console.WriteLine($"  Where examines {n}");
        return n % 2 == 0;
    })
    .Select(n =>
    {
        Console.WriteLine($"  Select computes {n}*{n}");
        return n * n;
    });
Console.WriteLine("[the query is defined, nothing has been executed yet]");

// 2 - sie wird bei der Iteration ausgeführt, Element für Element
Console.WriteLine("[foreach]");
foreach (int c in evenSquares)
{
    Console.WriteLine($"  foreach receives {c}");
}

// 3 - die Abfrage wird bei jeder Iteration neu ausgewertet: sie sieht die Änderungen der Quelle
IEnumerable<int> large = numbers.Where(n => n > 4);
Console.WriteLine($"[before adding] large=[{string.Join(", ", large)}]");
numbers.Add(10);
Console.WriteLine($"[after adding 10] large=[{string.Join(", ", large)}]");

// 4 - ToList führt die Abfrage sofort aus und speichert das Ergebnis
List<int> snapshot = numbers.Where(n => n > 4).ToList();
numbers.Add(20);
Console.WriteLine($"[after adding 20] large=[{string.Join(", ", large)}], snapshot=[{string.Join(", ", snapshot)}]");

// 5 - Aggregate (Count, Sum, First...) werden ebenfalls sofort ausgeführt
int howMany = numbers.Count(n => n > 4);
numbers.Add(30);
Console.WriteLine($"[after adding 30] howMany={howMany}, new Count={numbers.Count(n => n > 4)}");

// 6 - First beendet die Iteration, sobald es ein Element gefunden hat
Console.WriteLine("[First on a query]");
int first = numbers.Where(n =>
{
    Console.WriteLine($"  Where examines {n}");
    return n > 2;
}).First();
Console.WriteLine($"  first={first}");

Ergebnisse:

> dotnet run linq-05.cs
[definition of the query]
[the query is defined, nothing has been executed yet]
[foreach]
  Where examines 1
  Where examines 2
  Select computes 2*2
  foreach receives 4
  Where examines 3
  Where examines 4
  Select computes 4*4
  foreach receives 16
  Where examines 5
  Where examines 6
  Select computes 6*6
  foreach receives 36
[before adding] large=[5, 6]
[after adding 10] large=[5, 6, 10]
[after adding 20] large=[5, 6, 10, 20], snapshot=[5, 6, 10]
[after adding 30] howMany=4, new Count=5
[First on a query]
  Where examines 1
  Where examines 2
  Where examines 3
  first=3

Kommentare:

  • Zeilen 7–16: Eine Abfrage, die gerade Zahlen auswählt und dann deren Quadrate berechnet. Die Lambda-Funktionen sind hier mit einem Rumpf in geschweiften Klammern geschrieben, der eine Meldung anzeigt, bevor er seinen Wert mit [return] zurückgibt;
  • Zeile 3 der Ergebnisse: Nachdem die Abfrage definiert wurde, wurde nichts angezeigt: Weder [Where] noch [Select] hat bisher ein einziges Element untersucht. [evenSquares] enthält keine Ergebnisse, sondern eine Beschreibung einer Berechnung;
  • Zeilen 4–16: Die Abfrage läuft während der Schleife [foreach] Element für Element: Jede Zahl durchläuft [Where], dann, wenn sie gerade ist, [Select] und gelangt anschließend in die Schleife, bevor die nächste Zahl untersucht wird. Es handelt sich um Iteratoren wie [Evens] in [linq-01.cs];
  • Zeilen 28–31: Die Abfrage [large] wird bei jedem Durchlauf neu ausgewertet: Sie berücksichtigt die Zahl 10, die nach ihrer Definition zur Liste hinzugefügt wurde;
  • Zeile 34: [ToList] führt die Abfrage sofort aus und speichert ihre Ergebnisse: [snapshot] ist eine Liste, die das Hinzufügen von 20 (Zeile 19) nicht sieht;
  • Zeile 39: Methoden, die einen einzelnen Wert zurückgeben ([Count], [Sum], [First], [Any] …), durchlaufen die Sequenz ebenfalls sofort;
  • Zeilen 45–49: [First] beendet die Iteration, sobald es ein Element findet: Die auf 3 folgenden Zahlen werden nie untersucht.

Die verzögerte Ausführung hat zwei praktische Folgen:

  • Eine Abfrage, die mehrfach durchlaufen wird, wird mehrfach ausgeführt. Wenn ihre Berechnung aufwendig ist oder ein feststehendes Ergebnis gewünscht wird, wandelt man sie einmalig mit [ToList] oder [ToArray] um;
  • Abfragen lassen sich ohne Kosten zusammensetzen: Die Verkettung von [Where], [Select] und [Take] erzeugt keine Zwischen-Collection, und es werden nur die notwendigen Elemente berechnet.

Wir werden LINQ im gesamten Kurs begegnen, und in Kapitel 7 werden wir sehen, wie seine Methoden aufgebaut sind.

5.6. Textdateien

Die Klassen zum Lesen und Schreiben von Dateien befinden sich im Namespace [System.IO], der zu den impliziten [using]-Namespaces gehört.

5.6.1. Die Klasse StreamReader

Die Klasse [System.IO.StreamReader] erlaubt es, den Inhalt einer Textdatei zu lesen. Sie kann tatsächlich auch Datenströme verarbeiten, die keine Dateien sind (zum Beispiel eine Netzwerkverbindung). Hier einige ihrer Eigenschaften und Methoden.

Konstruktoren:

Konstruktor
Funktion
[public StreamReader(string path)]
Erstellt einen Lesestrom für die Datei am Pfad [path]. Der Inhalt der Datei kann unterschiedlich kodiert sein; standardmäßig wird die UTF-8-Kodierung verwendet. Eine andere Überladung erlaubt es, die Kodierung anzugeben: [new StreamReader(path, Encoding.Latin1)]

Eigenschaften:

Eigenschaft
Funktion
[public bool EndOfStream { get; }]
[true] , wenn der Datenstrom vollständig gelesen wurde

Methoden:

Methode
Funktion
[public void Dispose()]
Schließt den Datenstrom und gibt die für seine Verwaltung reservierten Ressourcen frei. Das muss nach der Verarbeitung des Datenstroms geschehen, was die Anweisung [using] übernimmt. [Close] tut dasselbe
[public int Peek()]
liefert das nächste Zeichen des Datenstroms, ohne es zu verbrauchen; -1 am Ende des Datenstroms
[public int Read()]
liefert das nächste Zeichen des Datenstroms und rückt um ein Zeichen vor; -1 am Ende des Datenstroms
[public string? ReadLine()]
liefert die nächste Zeile des Datenstroms ohne das Zeilenende-Zeichen oder [null] am Ende des Datenstroms
[public string ReadToEnd()]
liefert den Rest des Datenstroms oder "", wenn das Ende des Datenstroms erreicht ist

Das Programm [files-01.cs] lautet wie folgt:

// Lesen einer Textdatei mit StreamReader

// der aktuelle Ordner: hier werden die über einen relativen Namen bezeichneten Dateien gesucht
Console.WriteLine($"Current folder: {Path.GetFileName(Environment.CurrentDirectory)}");
// der Dateiname kann als Argument übergeben werden; andernfalls infos.txt
string fileName = args.Length > 0 ? args[0] : "infos.txt";
try
{
    // Lesen 1: Zeile für Zeile
    Console.WriteLine("Reading 1----------------");
    using (var stream = new StreamReader(fileName))
    {
        string? line;
        // ReadLine liefert am Dateiende null
        while ((line = stream.ReadLine()) != null)
        {
            Console.WriteLine(line);
        }
    } // hier wird der Stream geschlossen

    // Lesen 2: die gesamte Datei auf einmal, mit einer using-Deklaration
    Console.WriteLine("Reading 2----------------");
    using var stream2 = new StreamReader(fileName);
    Console.Write(stream2.ReadToEnd());
    // stream2 wird am Ende des Blocks geschlossen, der seine Deklaration enthält, hier der try-Block
}
catch (FileNotFoundException e)
{
    // e.FileName ist der vollständige Pfad der Datei; wir zeigen nur ihren Namen an
    Console.WriteLine($"{e.GetType().Name} : the file [{Path.GetFileName(e.FileName)}] does not exist");
}
catch (IOException e)
{
    // die übrigen Ein-/Ausgabefehler
    Console.WriteLine($"{e.GetType().Name} : {e.Message}");
}

Kommentare:

  • Zeile 4: zeigt den Namen des aktuellen Verzeichnisses an, also dessen, aus dem der Befehl [dotnet run] gestartet wurde. Mit [Path.GetFileName] wird nur das letzte Element des Pfades angezeigt, um die Ergebnisse nicht mit einem vollständigen Pfad zu überladen;
  • Zeile 6: Die gelesene Datei ist [infos.txt] oder die als Argument übergebene. Da es sich um einen relativen Pfad handelt, wird sie im aktuellen Ordner gesucht;
  • Zeile 11: Die Struktur [using (stream = ...) { ... }] stellt sicher, dass der Datenstrom am Ende des Blocks geschlossen wird, selbst wenn im Block eine Ausnahme auftritt. Dadurch entfällt der explizite Aufruf der Methode zum Schließen. Sie gilt für jedes Objekt, das die Schnittstelle [IDisposable] implementiert – also jedes Objekt mit einer Methode [Dispose], die Ressourcen freigibt (Datei, Netzwerkverbindung, Datenbankverbindung usw.);
  • Zeilen 15–17: Die Datei wird Zeile für Zeile gelesen. Die Zuweisung [line = stream.ReadLine()] ist ein Ausdruck, dessen Wert der von [line] ist: Er wird mit [null] verglichen, was das Dateiende anzeigt. Die Variable [line] hat den Typ [string?]: [ReadLine] kann den Wert [null] zugewiesen bekommen;
  • Zeile 23: eine using-Deklaration (C# 8). Es gibt keinen Block mehr: Die Variable [stream2] wird am Ende des Blocks freigegeben, der ihre Deklaration enthält, hier der Block *[try]*. Diese knappere Syntax ist heute die gebräuchlichste;
  • Zeile 24: Die Datei wird in einem Zug gelesen;
  • Zeilen 27–32: Ein-/Ausgabefehler werden durch Ausnahmen signalisiert, die von [IOException]* abgeleitet sind. *[FileNotFoundException]* ist eine solche Ausnahme; sie wird daher zuerst abgefangen. Ihre Eigenschaft *[FileName] enthält den vollständigen Pfad der gesuchten Datei.

Die Datei [infos.txt] lautet wie folgt:

1
2
3
12620:0:0
13190:0,05:631
15640:0,1:1290,5

Sie befindet sich im Ordner [05-classes-dotnet], aus dem das Programm ausgeführt wird:

> dotnet run files-01.cs
Current folder: 05-classes-dotnet
Reading 1----------------
12620:0:0
13190:0,05:631
15640:0,1:1290,5
Reading 2----------------
12620:0:0
13190:0,05:631
15640:0,1:1290,5

Mit einer nicht vorhandenen Datei:

1
2
3
4
> dotnet run files-01.cs -- xx.txt
Current folder: 05-classes-dotnet
Reading 1----------------
FileNotFoundException : the file [xx.txt] does not exist

Den aktuellen Ordner zum Auffinden von Datendateien zu wählen, ist der natürliche Ansatz für eine Einzeldatei-Anwendung, die aus ihrem eigenen Ordner ausgeführt wird. Bei einem Projekt befindet sich die ausführbare Datei in einem Unterordner namens [bin/Debug/net10.0] innerhalb des Projekts: Wir werden in der Beispielanwendung sehen, wie man die Datendateien dorthin kopiert und wie man sie findet.

5.6.2. Die Klasse StreamWriter

Die Klasse [System.IO.StreamWriter] erlaubt es, in eine Textdatei zu schreiben. Wie die Klasse [StreamReader] kann sie tatsächlich auch Datenströme verarbeiten, die keine Dateien sind. Hier einige ihrer Eigenschaften und Methoden.

Konstruktoren:

Konstruktor
Funktion
[public StreamWriter(string path)]
erstellt einen Schreibstrom zur Datei am Pfad [path]. Die Datei wird erstellt oder überschrieben, falls sie existiert. Standardmäßig wird der Text in UTF-8 ohne BOM kodiert (siehe unten)
[public StreamWriter(string path, bool append)]
Wenn [append] gleich [true] ist, werden die Ausgaben am Ende der bestehenden Datei angehängt

Eigenschaften:

Eigenschaft
Funktion
[public bool AutoFlush { get; set; }]
legt den Schreibmodus für die Datei fest. Wenn [AutoFlush] gleich [false] ist (Standardwert), erfolgt das Schreiben in den Datenstrom nicht sofort: Der Text wird zunächst in einen Puffer geschrieben und dann in die Datei, wenn der Puffer voll ist, wenn er mit der Methode [Flush] ausdrücklich geleert wird oder wenn der Datenstrom geschlossen wird. Das ist der effizienteste Modus für Dateien, da er die Plattenzugriffe begrenzt. Er ist nicht für alle Datenströme geeignet, insbesondere nicht für Netzwerkdatenströme: In einem Dialog zwischen zwei Partnern muss das, was der eine schreibt, vom anderen sofort gelesen werden können, und der Schreibstrom muss im Modus [AutoFlush=true] sein
[public string NewLine { get; set; }]
das von [WriteLine] geschriebene Zeilenende-Zeichen. Standardmäßig ist es das Zeilenende-Zeichen des Systems: "\r\n" unter Windows, "\n" unter Linux und macOS
[public Encoding Encoding { get; }]
die verwendete Kodierung

Methoden:

Methode
Funktion
[public void Dispose()]
Schließt den Datenstrom, nachdem der Inhalt des Puffers in die Datei geschrieben wurde. Muss nach der Verarbeitung des Datenstroms erfolgen; [Close] führt dieselbe Aktion aus
[public void Flush()]
schreibt den Inhalt des Puffers in die Datei, ohne zu warten, bis er voll ist
[public void Write(T value)]
schreibt [value] in die mit dem Datenstrom verbundene Datei. Hier ist [T] kein generischer Typ, sondern symbolisiert, dass die Methode [Write] verschiedene Parametertypen akzeptiert ([string], [int], [object] …)
[public void WriteLine(T value)]
Wie [Write] , jedoch mit angefügtem Zeilenende-Zeichen ([NewLine])

Das Programm [files-02.cs] lautet wie folgt:

// Schreiben einer Textdatei mit StreamWriter
const string fileName = "infos2.txt";
try
{
    // Erzeugung der Textdatei (existiert sie bereits, wird sie überschrieben)
    using (var stream = new StreamWriter(fileName))
    {
        Console.WriteLine($"AutoFlush mode: {stream.AutoFlush}, encoding: {stream.Encoding.WebName}");
        // Schleife, solange die eingegebene Zeile nicht leer ist
        while (true)
        {
            Console.Write("line (nothing to stop): ");
            string line = (Console.ReadLine() ?? "").Trim();
            if (line == "")
            {
                break;
            }
            // Schreiben der Zeile in die Textdatei
            stream.WriteLine(line);
        }
    } // Schließen des Streams: der Puffer wird in die Datei geschrieben

    // Prüfung: wir lesen die erzeugte Datei erneut
    Console.WriteLine($"Content of {fileName} ({new FileInfo(fileName).Length} bytes):");
    using var reader = new StreamReader(fileName);
    Console.Write(reader.ReadToEnd());
}
catch (IOException e)
{
    Console.WriteLine($"The following error occurred: {e.Message}");
}

Ergebnisse:

1
2
3
4
5
6
7
8
> dotnet run files-02.cs
AutoFlush mode: False, encoding: utf-8
line (nothing to stop): 1st line
line (nothing to stop): 2nd line
line (nothing to stop): 
Content of infos2.txt (18 bytes):
1st line
2nd line

Kommentare:

  • Zeile 6: Wir verwenden erneut die Anweisung [using], damit wir den Datenstrom nicht ausdrücklich schließen müssen. Das Schließen erfolgt automatisch am Ende des Blocks (schließende geschweifte Klammer in Zeile 21). Dieses Schließen schreibt den im Puffer verbliebenen Text in die Datei; ohne es könnte die Datei unvollständig bleiben;
  • Zeile 19: schreibt eine Zeile in die Textdatei;
  • Zeile 24: Die Klasse [FileInfo] liefert Informationen über eine Datei, hier ihre Größe in Bytes. Die 18 Bytes setzen sich wie folgt zusammen: 16 Zeichen plus zwei einbytige Zeilenumbrüche ("\n" unter Linux, wo der Code ausgeführt wurde; unter Windows würde jeder Zeilenumbruch "\r\n" 2 Bytes belegen);
  • Zeile 28: Warum ein [try / catch]? Wir könnten einen Dateinamen in der Form [dir1/dir2/file] mit einem Verzeichnis [dir1/dir2] angeben, das nicht existiert, sodass die Datei nicht erstellt werden kann. Es würde dann eine Ausnahme [DirectoryNotFoundException] ausgelöst, die von [IOException] abgeleitet ist. Es gibt weitere mögliche Ausnahmefälle (Datenträger voll, unzureichende Berechtigungen usw.).

5.6.3. Die Klassen File, Path und Directory

Für häufige Operationen erspart die statische Klasse [File] den Umgang mit Datenströmen: Eine einzige Methode öffnet die Datei, liest oder schreibt sie vollständig und schließt sie dann. Die statischen Klassen [Path] und [Directory] verarbeiten Pfade beziehungsweise Verzeichnisse.

Methode
Funktion
[File.ReadAllText(path)]
liefert den Inhalt der Datei als Zeichenkette
[File.ReadAllLines(path)]
Liefert die Zeilen der Datei in einem Array [string[]]
[File.ReadLines(path)]
liefert die Zeilen der Datei als [IEnumerable<string>]-Sequenz, die bei Bedarf gelesen wird
[File.WriteAllText(path, contents)]
erstellt die Datei (oder überschreibt sie) und schreibt [contents] hinein; [WriteAllLines] schreibt eine Collection von Zeilen
[File.AppendAllText(path, contents)], [File.AppendAllLines(path, lines)]
fügt Text – Zeilen – am Ende der Datei an (die erstellt wird, falls sie nicht existiert)
[File.ReadAllBytes(path)], [File.WriteAllBytes(path, bytes)]
liest und schreibt die Datei als Byte-Array
[File.Exists(path)], [File.Delete(path)], [File.Copy(source, dest)], [File.Move(source, dest)]
prüft, ob eine Datei existiert, löscht, kopiert oder verschiebt sie
[Path.Combine(p1, p2, ...)]
erstellt einen Pfad aus seinen Elementen unter Verwendung des Systemtrennzeichens
[Path.GetFileName(path)], [Path.GetExtension(path)], [Path.GetDirectoryName(path)]
extrahiert aus einem Pfad den Dateinamen, die Dateierweiterung und den Ordner
[Directory.CreateDirectory(path)]
erstellt den Ordner und seine übergeordneten Ordner, falls sie nicht existieren
[Directory.GetFiles(path, pattern)], [Directory.EnumerateFiles(path, pattern)]
Dateien im Ordner, deren Namen zum Muster passen ([*.txt] …), in einem Array oder einer Sequenz
[Directory.Exists(path)], [Directory.Delete(path, recursive)]
prüft, ob ein Ordner existiert, und löscht ihn (samt Inhalt, wenn [recursive] gleich [true] ist)

Das Programm [files-03.cs] verwendet sie:

using System.Text;

// die statischen Klassen File, Path und Directory

// Path.Combine baut einen Pfad mit dem Trennzeichen des Systems (\ unter Windows, / unter Linux)
string folder = "data";
string path = Path.Combine(folder, "cities.txt");
Console.WriteLine($"path={path}, name={Path.GetFileName(path)}, without extension={Path.GetFileNameWithoutExtension(path)}, extension={Path.GetExtension(path)}");

// Directory.CreateDirectory erzeugt den Ordner (und seine Elternordner), falls er nicht existiert
Directory.CreateDirectory(folder);

// File.WriteAllText: erzeugt (oder überschreibt) eine Datei mit dem angegebenen Text, in UTF-8 ohne BOM
File.WriteAllText(path, "Angers\nNantes\n");
// File.AppendAllLines: fügt Zeilen am Dateiende hinzu
File.AppendAllLines(path, ["Paris", "Lyon"]);
// File.ReadAllLines: alle Zeilen in einem Array
string[] lines = File.ReadAllLines(path);
Console.WriteLine($"ReadAllLines : {lines.Length} lines [{string.Join(", ", lines)}]");
// File.ReadAllText: die gesamte Datei in einer Zeichenkette
Console.WriteLine($"ReadAllText : {File.ReadAllText(path).Length} characters");
// File.ReadLines: die Zeilen werden bei Bedarf einzeln gelesen (IEnumerable<string>)
foreach (string city in File.ReadLines(path).Where(l => l.StartsWith('N') || l.StartsWith('L')))
{
    Console.WriteLine($"ReadLines + Where : {city}");
}

// die Kodierung: standardmäßig UTF-8 ohne BOM; eine andere kann erzwungen werden
string text = "café";
File.WriteAllText(Path.Combine(folder, "utf8.txt"), text);
File.WriteAllText(Path.Combine(folder, "utf8bom.txt"), text, new UTF8Encoding(true));
File.WriteAllText(Path.Combine(folder, "latin1.txt"), text, Encoding.Latin1);
foreach (string name in new[] { "utf8.txt", "utf8bom.txt", "latin1.txt" })
{
    byte[] bytes = File.ReadAllBytes(Path.Combine(folder, name));
    Console.WriteLine($"{name,-12}: {bytes.Length} bytes: {Convert.ToHexString(bytes)}");
}
// eine als UTF-8 zurückgelesene Latin-1-Datei: die Zeichen mit Akzent gehen verloren
Console.WriteLine($"latin1.txt read as UTF-8: {File.ReadAllText(Path.Combine(folder, "latin1.txt"))}");
Console.WriteLine($"latin1.txt read as Latin-1: {File.ReadAllText(Path.Combine(folder, "latin1.txt"), Encoding.Latin1)}");

// File.Exists, Directory.GetFiles
Console.WriteLine($"Exists(cities.txt)={File.Exists(path)}, Exists(xx.txt)={File.Exists(Path.Combine(folder, "xx.txt"))}");
foreach (string file in Directory.GetFiles(folder, "*.txt").Order())
{
    Console.WriteLine($"  {Path.GetFileName(file),-12} {new FileInfo(file).Length,3} bytes");
}

// Aufräumen: Löschen des Ordners und seines Inhalts
Directory.Delete(folder, recursive: true);
Console.WriteLine($"after Delete: Directory.Exists={Directory.Exists(folder)}");

Ergebnisse:

> dotnet run files-03.cs
path=data/cities.txt, name=cities.txt, without extension=cities, extension=.txt
ReadAllLines : 4 lines [Angers, Nantes, Paris, Lyon]
ReadAllText : 25 characters
ReadLines + Where : Nantes
ReadLines + Where : Lyon
utf8.txt    : 5 bytes: 636166C3A9
utf8bom.txt : 8 bytes: EFBBBF636166C3A9
latin1.txt  : 4 bytes: 636166E9
latin1.txt read as UTF-8: caf�
latin1.txt read as Latin-1: café
Exists(cities.txt)=True, Exists(xx.txt)=False
  cities.txt    25 bytes
  latin1.txt     4 bytes
  utf8.txt       5 bytes
  utf8bom.txt    8 bytes
after Delete: Directory.Exists=False

Kommentare:

  • Zeile 7: [Path.Combine] verwendet das Pfadtrennzeichen des Systems. Die Übungen des Kurses wurden unter Linux ausgeführt: Der resultierende Pfad lautet [data/cities.txt]; unter Windows wäre er [data\cities.txt]. Pfade mit [Path.Combine] statt durch Verkettung von Zeichenketten zu erstellen, macht den Code portabel;
  • Zeile 11: Das Erstellen des Ordners [data] verursacht keinen Fehler, wenn er bereits existiert;
  • Zeilen 14–18: Schreiben, Anfügen und Lesen, jeweils in einer einzigen Anweisung;
  • Zeile 23: [File.ReadLines] liefert eine Sequenz: Die Zeilen werden im Verlauf der Schleife nacheinander gelesen, wie die Elemente eines Iterators. Man kann LINQ darauf anwenden und so eine mehrere Gigabyte große Datei verarbeiten, ohne sie in den Speicher zu laden – was [ReadAllLines] tun würde. Die Datei wird am Ende der Iteration geschlossen;
  • Zeilen 29–36: Derselbe Text „café“ wird mit drei Kodierungen geschrieben, anschließend werden die Bytes der Dateien hexadezimal angezeigt:
    • In UTF-8, der Standardkodierung von .NET, belegen Zeichen mit Akzent 2 Bytes (é = C3 A9) und die übrigen 1 Byte: 5 Bytes für 4 Zeichen;
    • in UTF-8 mit BOM (Byte Order Mark) beginnt die Datei mit den 3 Bytes EF BB BF, die der Software anzeigen, dass die Datei in UTF-8 kodiert ist. [new UTF8Encoding(true)] weist das System an, dieses BOM zu schreiben;
    • in Latin-1 (ISO-8859-1), der traditionellen Kodierung für westeuropäische Texte, belegt jedes Zeichen ein Byte (é = E9);
  • Zeile 39: Das Lesen einer Datei mit einer anderen Kodierung als der beim Schreiben verwendeten verfälscht Zeichen mit Akzent: Das Byte E9 am Ende der Datei ist in UTF-8 ungültig, und jedes ungültige Byte wird durch das Zeichen � ersetzt. Beim Lesen erkennen [File.ReadAllText] und [StreamReader] ein BOM, falls vorhanden; andernfalls nehmen sie UTF-8 an, sofern keine andere Kodierung angegeben wird (Zeile 40). Heute gilt die einfache Regel: Textdateien werden in UTF-8 geschrieben und gelesen;
  • Zeile 44: die Namen der Textdateien im Ordner. [GetFiles] garantiert die Reihenfolge der Namen nicht; die LINQ-Methode [Order] (.NET 7) sortiert sie;
  • Zeile 50: Löscht den Ordner und seinen Inhalt. Der Parameter wird namentlich übergeben, [recursive: true], was den Aufruf lesbarer macht als ein einfaches [true] (benannte Argumente, Kapitel 3).

Alle diese Methoden haben asynchrone Versionen ([File.ReadAllTextAsync], [File.ReadAllLinesAsync] …): Wir werden sie in Kapitel 9 verwenden, das der asynchronen Programmierung gewidmet ist.

5.7. Binärdateien

5.7.1. Die Klassen BinaryWriter und BinaryReader

Die Klassen [System.IO.BinaryWriter] und [System.IO.BinaryReader] dienen zum Schreiben und Lesen von Binärdateien. In einer solchen Datei werden die Daten nicht als Text, sondern in ihrer internen Form geschrieben: Ein [int] belegt unabhängig von seinem Wert immer 4 Bytes.

Betrachten Sie die folgende Anwendung:

1
2
3
4
// Syntax: dotnet run files-04.cs -- text binary logs
// wir lesen eine Textdatei (text) und speichern ihren Inhalt in einer Binärdatei (binary)
// die Textdatei hat Zeilen der Form name : age, die wir in der Form (string, int) schreiben
// (logs) ist eine Textdatei für das Protokoll

Die Textdatei [persons1.txt] hat folgenden Inhalt:

1
2
3
4
5
6
7
8
9
paul : 10
helene : 15

jacques : 11
sylvain : 12
xx : -1

xx: yy : zz
xx : yy

Das Programm [files-04.cs] lautet wie folgt:

// Syntax: dotnet run files-04.cs -- text binary logs
// wir lesen eine Textdatei (text) und speichern ihren Inhalt in einer Binärdatei (binary)
// die Textdatei hat Zeilen der Form name : age, die wir in der Form (string, int) schreiben
// (logs) ist eine Textdatei für das Protokoll

// 3 Argumente sind erforderlich
if (args.Length != 3)
{
    Console.WriteLine("syntax: dotnet run files-04.cs -- text binary logs");
    return 1;
}
try
{
    // Öffnen der Textdatei zum Lesen
    using var input = new StreamReader(args[0]);
    // Öffnen der Binärdatei zum Schreiben
    using var output = new BinaryWriter(new FileStream(args[1], FileMode.Create, FileAccess.Write));
    // Öffnen der Protokolldatei zum Schreiben
    using var logs = new StreamWriter(args[2]);
    // Verarbeitung der Textdatei
    string? line;
    int lineNumber = 0, nbPersons = 0;
    while ((line = input.ReadLine()) != null)
    {
        // eine Zeile mehr
        lineNumber++;
        // leere Zeile? wir ignorieren sie
        if (line.Trim() == "")
        {
            continue;
        }
        // eine Zeile name : age
        string[] fields = line.Split(':', StringSplitOptions.TrimEntries);
        // wir benötigen 2 Felder
        if (fields.Length != 2)
        {
            logs.WriteLine($"Line no. [{lineNumber}] of the file [{args[0]}] has an incorrect number of fields");
            continue;
        }
        // das 1. Feld darf nicht leer sein
        bool error = false;
        string name = fields[0];
        if (name == "")
        {
            logs.WriteLine($"Line no. [{lineNumber}] of the file [{args[0]}] has an empty name");
            error = true;
        }
        // das zweite Feld muss eine Ganzzahl >= 0 sein
        if (!int.TryParse(fields[1], out int age) || age < 0)
        {
            logs.WriteLine($"Line no. [{lineNumber}] of the file [{args[0]}] has an incorrect age [{fields[1]}]");
            error = true;
        }
        // wenn kein Fehler vorliegt, schreiben wir die Daten in die Binärdatei
        if (!error)
        {
            output.Write(name);
            output.Write(age);
            nbPersons++;
        }
    }
    Console.WriteLine($"{lineNumber} lines read, {nbPersons} persons written to [{args[1]}], errors in [{args[2]}]");
    // Ende des try-Blocks: die drei Streams werden hier in umgekehrter Reihenfolge ihrer Öffnung geschlossen
}
catch (FileNotFoundException e)
{
    // e.FileName ist der vollständige Pfad der Datei; wir zeigen nur ihren Namen an
    Console.WriteLine($"The file [{Path.GetFileName(e.FileName)}] does not exist");
    return 2;
}
catch (IOException e)
{
    Console.WriteLine($"The following error occurred: {e.GetType().Name} : {e.Message}");
    return 3;
}
return 0;

Sehen wir uns die Operationen mit der Klasse [BinaryWriter] genauer an:

  • Zeile 17: Das Objekt [BinaryWriter] wird durch die Operation [new BinaryWriter(new FileStream(args[1], FileMode.Create, FileAccess.Write))] geöffnet. Das Argument des Konstruktors muss ein Datenstrom ([Stream]) sein. Hier ist es ein aus einer Datei erstellter Datenstrom ([FileStream]), für den wir Folgendes angeben:
    • den Namen;
    • die auszuführende Operation, hier [FileMode.Create] zum Erstellen der Datei (oder zum Überschreiben, falls sie existiert);
    • die Zugriffsart, hier [FileAccess.Write] für den Schreibzugriff auf die Datei;
  • Zeilen 57–58: die Schreiboperationen. Die Klasse [BinaryWriter] hat überladene Methoden [Write] zum Schreiben der verschiedenen Typen einfacher Daten ([int], [double], [decimal], [bool], [string] ...);
  • Zeilen 15–19: Die drei Datenströme werden mit [using]-Deklarationen geöffnet. Sie werden am Ende des Blocks [try] in der umgekehrten Reihenfolge ihrer Öffnung geschlossen. Der Kurs von 2008 schloss sie in einer Klausel [finally] nach der Prüfung, dass sie nicht [null] waren: Die Deklaration mit [using] leistet dasselbe in einer einzigen Zeile;
  • Zeile 10: Anweisungen der obersten Ebene können mit [return n] enden; n ist dann der Exit-Code des Programms, den ein Skript prüfen kann (0: Erfolg);
  • Zeile 33: Die Option [TrimEntries] entfernt die Leerzeichen um Name und Alter;
  • Zeile 49: Das Alter muss eine positive ganze Zahl oder null sein. Dank der Kurzschlussauswertung des Operators [||] wird die Bedingung [age < 0] nur ausgewertet, wenn die Umwandlung erfolgreich war.

Die drei Argumente des Programms werden nach [--] im Befehl [dotnet run] übergeben. Die Ergebnisse sind folgende:

> dotnet run files-04.cs -- persons1.txt persons1.bin logs.txt
9 lines read, 4 persons written to [persons1.bin], errors in [logs.txt]

Die Protokolldatei [logs.txt] enthält Folgendes:

1
2
3
4
> cat logs.txt
Line no. [6] of the file [persons1.txt] has an incorrect age [-1]
Line no. [8] of the file [persons1.txt] has an incorrect number of fields
Line no. [9] of the file [persons1.txt] has an incorrect age [yy]

Der Inhalt der Binärdatei [persons1.bin] lässt sich unter Linux mit dem Befehl [od] hexadezimal anzeigen (unter Windows erzeugt der PowerShell-Befehl [Format-Hex] eine ähnliche Anzeige):

1
2
3
4
5
> od -A d -t x1z persons1.bin
0000000 04 70 61 75 6c 0a 00 00 00 06 68 65 6c 65 6e 65  >.paul.....helene<
0000016 0f 00 00 00 07 6a 61 63 71 75 65 73 0b 00 00 00  >.....jacques....<
0000032 07 73 79 6c 76 61 69 6e 0c 00 00 00              >.sylvain....<
0000044

Daran sehen Sie, wie [BinaryWriter] die Daten schreibt:

  • Eine Zeichenkette wird mit vorangestellter Länge in Bytes geschrieben: das Byte 04, gefolgt von den 4 Bytes von „paul“ (70 61 75 6c);
  • eine ganze Zahl [int] wird auf 4 Bytes geschrieben, wobei das niederwertigste Byte zuerst steht: 10 wird als 0a 00 00 00 geschrieben;
  • die Daten werden ohne Trennzeichen und ohne Zeilenumbrüche aneinandergereiht geschrieben: Die Datei ist 44 Bytes lang (Zeile 5: Mit der Option [-A d] zeigt [od] die Positionen dezimal an).

Um diese Datei zu lesen, müssen Sie also die genaue Reihenfolge und den Typ der geschriebenen Daten kennen. Dies leistet das Programm [files-05.cs], das die umgekehrte Operation ausführt: Es liest die Binärdatei, um eine Textdatei zu erzeugen. Enthält die entstandene Textdatei die korrekten Daten der Ausgangsdatei, wissen Sie, dass die Umwandlung Text → binär → Text gelungen ist.

// Syntax: dotnet run files-05.cs -- binary text
// wir lesen eine Binärdatei (binary) und speichern ihren Inhalt in einer Textdatei (text)
// die Binärdatei enthält (string, int)-Paare
// die Textdatei hat Zeilen der Form name:age

// 2 Argumente sind erforderlich
if (args.Length != 2)
{
    Console.WriteLine("syntax: dotnet run files-05.cs -- binary text");
    return 1;
}
try
{
    // Öffnen der Binärdatei zum Lesen
    using var input = new BinaryReader(new FileStream(args[0], FileMode.Open, FileAccess.Read));
    // Öffnen der Textdatei zum Schreiben
    using var output = new StreamWriter(args[1]);
    // Verarbeitung der Binärdatei, solange wir nicht am Ende des Streams sind
    int nbPersons = 0;
    while (input.BaseStream.Position < input.BaseStream.Length)
    {
        // Lesen von name, dann age: in der Reihenfolge, in der sie geschrieben wurden
        string name = input.ReadString();
        int age = input.ReadInt32();
        // Schreiben in die Textdatei
        output.WriteLine($"{name}:{age}");
        nbPersons++;
    }
    Console.WriteLine($"{nbPersons} persons read from [{args[0]}] and written to [{args[1]}]");
}
catch (EndOfStreamException)
{
    // die Datei endet mitten in einem Datensatz
    Console.WriteLine($"The file [{args[0]}] is truncated");
    return 2;
}
catch (FileNotFoundException e)
{
    // e.FileName ist der vollständige Pfad der Datei; wir zeigen nur ihren Namen an
    Console.WriteLine($"The file [{Path.GetFileName(e.FileName)}] does not exist");
    return 3;
}
catch (IOException e)
{
    Console.WriteLine($"The following error occurred: {e.GetType().Name} : {e.Message}");
    return 4;
}
return 0;

Sehen wir uns die Operationen mit der Klasse [BinaryReader] genauer an:

  • Zeile 15: Das Objekt [BinaryReader] wird auf einem [FileStream]-Datenstrom im Modus [FileMode.Open] (zum Öffnen einer vorhandenen Datei) und mit dem Zugriffsmodus [FileAccess.Read] (nur lesender Zugriff) geöffnet;
  • Zeilen 23–24: Leseoperationen. Die Klasse [BinaryReader] stellt die Methoden [ReadXX] zum Lesen verschiedener einfacher Datentypen bereit: [ReadString], [ReadInt32], [ReadDouble], [ReadDecimal], [ReadBoolean] ... Sie müssen in der Reihenfolge der Schreibvorgänge aufgerufen werden;
  • Zeile 20: Die Eigenschaft [BaseStream] liefert den zugrunde liegenden Datenstrom, hier den [FileStream]. Es wird gelesen, bis die aktuelle Position in der Datei das Dateiende erreicht. Die Version von 2008 las endlos und erkannte das Dateiende anhand der Ausnahme [EndOfStreamException]: Eine Ausnahme muss die Ausnahme bleiben, und das Ende einer Datei ist keine Ausnahme;
  • Zeile 31: Diese Ausnahme signalisiert nun eine echte Anomalie: eine Datei, die mitten in einem Datensatz endet.

Führen wir das Programm mit der zuvor erzeugten Datei [persons1.bin] aus:

> dotnet run files-05.cs -- persons1.bin persons2.txt
4 persons read from [persons1.bin] and written to [persons2.txt]

Der Inhalt von [persons2.txt] lautet:

1
2
3
4
5
> cat persons2.txt
paul:10
helene:15
jacques:11
sylvain:12

Wir finden die 4 gültigen Personen der Datei [persons1.txt] wieder. Bei einer Datei [truncated.bin], die aus den ersten 30 Bytes von [persons1.bin] besteht, schlägt das Lesen des Alters von Jacques fehl:

> dotnet run files-05.cs -- truncated.bin truncated.txt
The file [truncated.bin] is truncated

5.7.2. Die JSON-Serialisierung

Eine Binärdatei Byte für Byte zu schreiben und zu lesen ist mühsam, und schon die kleinste Abweichung zwischen Schreiben und Lesen führt zu falschen Ergebnissen. In der Regel ist es vorzuziehen, Objekte zu serialisieren: Sie werden automatisch in eine Folge von Bytes oder Zeichen umgewandelt und anschließend deserialisiert, um sie wiederherzustellen.

.NET stellte hierfür die Klasse [BinaryFormatter] bereit, die Objekte in ein .NET-spezifisches Binärformat serialisierte. Sie wurde inzwischen entfernt: In .NET 5 wurde sie als veraltet erklärt, und ihre Implementierung wurde in .NET 9 entfernt, da das Deserialisieren von Daten aus einer nicht vertrauenswürdigen Quelle mit [BinaryFormatter] die Ausführung beliebigen Codes erlaubte. Microsoft empfiehlt, sie durch die JSON-Serialisierung der Bibliothek [System.Text.Json] zu ersetzen, die seit .NET Core 3.0 in .NET integriert ist.

JSON (JavaScript Object Notation) ist ein textbasiertes, menschenlesbares und universelles Format: Es ist das Austauschformat für Webdienste (Kapitel 13) und zahlreiche Konfigurationsdateien. Ein Objekt wird in geschweiften Klammern in Form von Paaren "property":value geschrieben, Arrays stehen in eckigen Klammern.

Die statische Klasse [System.Text.Json.JsonSerializer] hat zwei Hauptmethoden:

Methode
Rolle
[string Serialize<T>(T value, JsonSerializerOptions? options = null)]
liefert den Text JSON, der das Objekt [value] darstellt
[T? Deserialize<T>(string json, JsonSerializerOptions? options = null)]
rekonstruiert ein Objekt vom Typ [T] aus dem Text JSON [json]; löst eine [JsonException] aus, wenn der Text fehlerhaft ist

Das Programm [files-06.cs] verwendet sie:

#:property PublishAot=false
using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.Unicode;

// JSON-Serialisierung mit System.Text.Json

List<Person> persons =
[
    new("paul", 10, ["football"]),
    new("hélène", 15, ["piano", "tennis"]),
    new("jacques", 11, []),
];

// 1 - Standardserialisierung: eine einzige Zeile, Nicht-ASCII-Zeichen maskiert
string json = JsonSerializer.Serialize(persons[1]);
Console.WriteLine($"[default] {json}");

// 2 - Optionen: Einrückung, Zeichen mit Akzent bleiben unverändert
var options = new JsonSerializerOptions
{
    WriteIndented = true,
    Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
};
json = JsonSerializer.Serialize(persons, options);
// Schreiben in eine Textdatei
File.WriteAllText("persons.json", json);
Console.WriteLine("[persons.json]");
Console.WriteLine(File.ReadAllText("persons.json"));

// 3 - Deserialisierung: vom JSON-Text zu Objekten
string text = File.ReadAllText("persons.json");
List<Person>? readBack = JsonSerializer.Deserialize<List<Person>>(text);
Console.WriteLine($"[read back] {readBack?.Count} persons");
foreach (Person p in readBack ?? [])
{
    Console.WriteLine($"  {p.Name}, {p.Age} years old, hobbies: [{string.Join(", ", p.Hobbies)}]");
}

// 4 - ohne Attribute: die „Web"-Optionen setzen die Eigenschaftsnamen in camelCase
var web = new JsonSerializerOptions(JsonSerializerDefaults.Web);
string jsonArticle = JsonSerializer.Serialize(new Article("A12", 12.5m), web);
Console.WriteLine($"[Web options] {jsonArticle}");
// und sie ignorieren beim Lesen die Groß-/Kleinschreibung
Article? article = JsonSerializer.Deserialize<Article>("""{ "CODE": "B7", "price": 3 }""", web);
Console.WriteLine($"[Web options] {article}");

// 5 - ein fehlerhaftes JSON-Dokument löst eine JsonException aus
try
{
    JsonSerializer.Deserialize<Person>("""{ "name": "x", "age": "twelve" }""");
}
catch (JsonException e)
{
    Console.WriteLine($"[error] {e.GetType().Name} : {e.Message}");
}

// eine Person; die Attribute [JsonPropertyName] legen die Namen der JSON-Eigenschaften fest
record Person(
    [property: JsonPropertyName("name")] string Name,
    [property: JsonPropertyName("age")] int Age,
    [property: JsonPropertyName("hobbies")] List<string> Hobbies);

// ein Artikel, ohne Attribute
record Article(string Code, decimal Price);

Ergebnisse:

> dotnet run files-06.cs
[default] {"name":"h\u00E9l\u00E8ne","age":15,"hobbies":["piano","tennis"]}
[persons.json]
[
  {
    "name": "paul",
    "age": 10,
    "hobbies": [
      "football"
    ]
  },
  {
    "name": "hélène",
    "age": 15,
    "hobbies": [
      "piano",
      "tennis"
    ]
  },
  {
    "name": "jacques",
    "age": 11,
    "hobbies": []
  }
]
[read back] 3 persons
  paul, 10 years old, hobbies: [football]
  hélène, 15 years old, hobbies: [piano, tennis]
  jacques, 11 years old, hobbies: []
[Web options] {"code":"A12","price":12.5}
[Web options] Article { Code = B7, Price = 3 }
[error] JsonException : The JSON value could not be converted to Person. Path: $.age | LineNumber: 0 | BytePositionInLine: 30.

Kommentare:

  • Zeile 1: Eine Direktive für Single-File-Anwendungen. Standardmäßig sind diese für die native Kompilierung (AOT, „Ahead of Time“) konfiguriert, die eine eigenständige ausführbare Datei erzeugt, aber Mechanismen deaktiviert, die auf der Typermittlung zur Laufzeit (Reflection) beruhen. [JsonSerializer] verwendet jedoch standardmäßig Reflection, um die Eigenschaften der zu serialisierenden Objekte zu ermitteln: Ohne diese Direktive erzeugt die Kompilierung Warnungen, und die Ausführung schlägt fehl. Ein normales [.csproj]-Projekt, wie das der Beispielanwendung, unterliegt dieser Einschränkung nicht. Für eine nativ kompilierte Anwendung stellt [System.Text.Json] einen Source Generator (eine von [JsonSerializerContext] abgeleitete Klasse) bereit, der den Serialisierungscode zur Kompilierzeit erzeugt: Darauf gehen wir hier nicht ein;
  • Zeilen 60–63: der zu serialisierende Record [Person]. Seine Eigenschaften tragen das Attribut [JsonPropertyName], das den Eigenschaftsnamen im Text JSON auf [name] statt [Name] festlegt. In einem positionalen Record gibt [property: ...] an, dass das Attribut für die generierte Eigenschaft und nicht für den Konstruktorparameter gilt;
  • Zeile 17: Serialisierung eines Objekts mit Standardoptionen: Der Text wird in einer einzigen Zeile geschrieben, und Nicht-ASCII-Zeichen werden maskiert: [é] wird zu [é]. Der Text bleibt korrekt, ist aber schwer lesbar;
  • Zeilen 21–26: Die Option [WriteIndented] erzeugt eingerückten Text über mehrere Zeilen; die Option [Encoder] legt fest, welche Zeichen unverändert bleiben – hier alle Unicode-Zeichen. Eine Liste wird in ein Array JSON serialisiert;
  • Zeile 28: Der Text JSON wird in einer Textdatei gespeichert: So wird die binäre Serialisierung heute ersetzt;
  • Zeile 34: Die Deserialisierung rekonstruiert die Liste. [Deserialize] erzeugt die [Person]-Objekte durch Aufruf des Konstruktors des Records, dessen Parameter den gleichnamigen JSON-Eigenschaften zugeordnet werden. Das Ergebnis hat den Typ [List<Person>?]: Der Text JSON [null] ist ein gültiges Dokument, das [null] ergibt;
  • Zeile 42: Die „Web“-Optionen, die von den Webdiensten in ASP.NET Core standardmäßig verwendet werden, schreiben Eigenschaftsnamen im camelCase-Format (erster Buchstabe klein): [Code] wird ohne Attribut zu [code]. Beim Einlesen wird die Groß- und Kleinschreibung nicht beachtet: [CODE] wird akzeptiert (Zeile 31);
  • Zeile 52: Ein ungültiges Dokument JSON – hier eine Zeichenkette, wo eine Zahl erwartet wird – löst eine [JsonException] aus, deren Meldung die Fehlerstelle angibt.

Wir werden JSON im folgenden Beispiel und im weiteren Verlauf des Kurses verwenden.

5.8. Reguläre Ausdrücke

Die Klasse [System.Text.RegularExpressions.Regex] unterstützt die Verwendung regulärer Ausdrücke. Damit lässt sich das Format einer Zeichenkette überprüfen. So können Sie beispielsweise verifizieren, dass eine Zeichenkette, die ein Datum darstellt, tatsächlich das Format dd/mm/yy hat. Dazu verwenden Sie ein Muster und vergleichen die Zeichenkette mit diesem Muster. In diesem Beispiel müssen d, m und y Ziffern sein. Das Muster für ein gültiges Datumsformat lautet daher [\d\d/\d\d/\d\d], wobei das Symbol [\d] für eine Ziffer steht. In einem Muster können folgende Symbole verwendet werden:

Zeichen
Beschreibung
[\]
markiert das folgende Zeichen als Sonderzeichen oder Literal. Beispielsweise entspricht [n] dem Zeichen n, [\n] einem Zeilenumbruch, [\\] dem Zeichen \ und [\(] dem Zeichen (
[^]
entspricht dem Anfang der Zeichenkette
[$]
entspricht dem Ende der Zeichenkette
[*]
entspricht dem vorhergehenden Element null- oder mehrmals. So passt [zo*] auf z oder zoo
[+]
entspricht dem vorhergehenden Element ein- oder mehrmals. So passt [zo+] auf „zoo“, aber nicht auf „z“
[?]
entspricht dem vorhergehenden Element null- oder einmal. Beispielsweise passt [a?ve?] auf „ve“ in „lever“
[.]
entspricht einem beliebigen einzelnen Zeichen außer einem Zeilenumbruch
[(pattern)]
sucht das Muster und speichert den Treffer (eine Gruppe). Der passende Teilstring kann aus der Sammlung [Groups] im Ergebnis extrahiert werden. Um Treffer mit Zeichen in Klammern zu finden, verwenden Sie [\(] oder [\)]
[x|y]
entspricht entweder x oder y. Beispielsweise passt [z|foot] auf z oder foot; [(z|f)oo] passt auf zoo oder foo
[{n}]
n ist eine nicht negative ganze Zahl. Entspricht genau n-mal dem vorhergehenden Element. Beispielsweise passt [o{2}] nicht auf das o in Bob, wohl aber auf die ersten beiden o in fooooot
[{n,}]
entspricht dem vorhergehenden Element mindestens n-mal. Beispielsweise passt [o{2,}] nicht auf das „o“ in „Bob“, wohl aber auf alle „o“ in „fooooot“. [o{1,}] ist gleichbedeutend mit [o+], und [o{0,}] ist gleichbedeutend mit [o*]
[{n,m}]
entspricht dem vorhergehenden Element mindestens n-mal und höchstens m-mal. Beispielsweise passt [o{1,3}] auf die ersten drei „o“ in „foooooot“; [o{0,1}] ist gleichbedeutend mit [o?]
[xyz]
Zeichenmenge: entspricht einem der angegebenen Zeichen. Beispielsweise passt [abc] auf den Buchstaben „a“ in „plat“
[^xyz]
negierte Zeichenmenge: entspricht jedem nicht aufgeführten Zeichen. Beispielsweise passt [^abc] auf „p“ in „plat“
[a-z]
Zeichenbereich: entspricht jedem Zeichen im angegebenen Bereich, hier einem Kleinbuchstaben ohne Akzent
[^m-z]
negierter Zeichenbereich: entspricht jedem Zeichen, das nicht zwischen „m“ und „z“ liegt
[\b]
entspricht einer Wortgrenze, also der Position zwischen einem Wortzeichen und einem Nicht-Wortzeichen. Beispielsweise passt [er\b] auf „er“ in „lever“, aber nicht auf „er“ in „verb“
[\B]
entspricht einer Position, die keine Wortgrenze ist. [en*t\B] entspricht „ent“ in „entertain“
[\d]
entspricht einer Ziffer; ist gleichbedeutend mit [0-9] (bei .NET auch für Ziffern aus anderen Unicode-Schriften)
[\D]
entspricht einem Zeichen, das keine Ziffer ist
[\f], [\n], [\r], [\t], [\v]
entsprechen den Zeichen Seitenvorschub, Zeilenumbruch, Wagenrücklauf, Tabulator beziehungsweise vertikaler Tabulator
[\s]
entspricht beliebigem Leerraum: Leerzeichen, Tabulator, Seitenvorschub, Zeilenumbruch … Gleichbedeutend mit [ \f\n\r\t\v], zuzüglich weiterer Unicode-Leerzeichen (geschütztes Leerzeichen usw.)
[\S]
entspricht jedem Zeichen, das kein Leerraumzeichen ist
[\w]
entspricht jedem Wortzeichen: Buchstabe (mit oder ohne Akzent), Ziffer oder Unterstrich
[\W]
entspricht jedem Zeichen, das kein Wortzeichen ist
[\num]
num ist eine positive ganze Zahl: verweist auf die Gruppe mit der Nummer num. Beispielsweise passt [(.)\1] auf zwei aufeinanderfolgende gleiche Zeichen
[\xnn], [\unnnn]
entspricht dem hexadezimalen Zeichen nn (2 Ziffern) oder nnnn (4 Ziffern). Beispielsweise entspricht [\x41] dem Zeichen A

Ein Element in einem Muster kann einmal oder mehrfach vorkommen. Sehen wir uns einige Beispiele mit dem Symbol [\d], an, das eine einzelne Ziffer darstellt:

Muster
Bedeutung
[\d]
eine Ziffer
[\d?]
0 oder 1 Ziffer
[\d*]
0 oder mehr Ziffern
[\d+]
1 oder mehr Ziffern
[\d{2}]
2 Ziffern
[\d{3,}]
Mindestens 3 Ziffern
[\d{5,7}]
zwischen 5 und 7 Ziffern

Stellen wir uns nun ein Muster vor, das das erwartete Format einer Zeichenkette beschreiben kann:

Zielzeichenkette
Muster
ein Datum im Format dd/mm/yy
[\d{2}/\d{2}/\d{2}]
eine Uhrzeit im Format hh:mm:ss
[\d{2}:\d{2}:\d{2}]
eine vorzeichenlose ganze Zahl
[\d+]
eine Folge von Leerzeichen, die auch leer sein kann
[\s*]
eine vorzeichenlose ganze Zahl, der Leerzeichen vorausgehen oder folgen können
[\s*\d+\s*]
eine ganze Zahl, die ein Vorzeichen haben kann und der Leerzeichen vorausgehen oder folgen können
[\s*[+-]?\s*\d+\s*]
eine vorzeichenlose reelle Zahl, der Leerzeichen vorausgehen oder folgen können
[\s*\d+(\.\d*)?\s*]
eine reelle Zahl, die ein Vorzeichen haben kann und der Leerzeichen vorausgehen oder folgen können
[\s*[+-]?\s*\d+(\.\d*)?\s*]
eine Zeichenkette, die das Wort „just“ enthält
[\bjust\b]

Der Kurs von 2008 verwendete [+|-] für das Vorzeichen: In eckigen Klammern hat das Zeichen [|] keine besondere Bedeutung, und dieses Format akzeptierte auch das Zeichen | vor einer Zahl. Außerdem wurde [(.\d*)] für den Dezimalteil verwendet: Der dort nicht maskierte Punkt steht für ein beliebiges Zeichen. Die obigen Muster wurden korrigiert.

Sie können angeben, an welcher Stelle der Zeichenkette nach dem Muster gesucht wird:

Muster
Bedeutung
[^pattern]
das Muster steht am Anfang der Zeichenkette
[pattern$]
Das Muster steht am Ende der Zeichenkette
[^pattern$]
Das Muster steht am Anfang und am Ende der Zeichenkette
[pattern]
Das Muster wird an beliebiger Stelle der Zeichenkette gesucht, beginnend am Anfang der Zeichenkette
zu durchsuchende Zeichenkette
Muster
eine Zeichenkette, die mit einem Ausrufezeichen endet
[!$]
eine Zeichenkette, die mit einem Punkt endet
[\.$]
eine Zeichenkette, die mit der Folge // beginnt
[^//]
eine Zeichenkette aus einem einzigen Wort, dem Leerzeichen vorausgehen oder folgen können
[^\s*\w+\s*$]
eine Zeichenkette aus genau zwei Wörtern, denen Leerzeichen vorausgehen oder folgen können
[^\s*\w+\s+\w+\s*$]
eine Zeichenkette, die das Wort „secret“ enthält
[\bsecret\b]

Teilmuster eines Musters können „extrahiert“ werden. So können wir nicht nur prüfen, ob eine Zeichenkette einem bestimmten Muster entspricht, sondern auch die Elemente aus dieser Zeichenkette extrahieren, die den in Klammern eingeschlossenen Teilmustern entsprechen. Wenn Sie beispielsweise eine Zeichenkette mit einem Datum im Format dd/mm/yy analysieren und zusätzlich die Bestandteile dd, mm und yy dieses Datums extrahieren möchten, verwenden Sie das Muster [(\d\d)/(\d\d)/(\d\d)].

In C#-Code schreibt man ein Muster vorzugsweise als wörtliche Zeichenkette (Verbatim-String) [@"..."]: So müssen die zahlreichen Zeichen [\] in den Mustern nicht verdoppelt werden. Bei einer normalen Zeichenkette müssten Sie stattdessen ***["\\\\d+"] schreiben statt ***[@"\\d+"].

5.8.1. Prüfen, ob eine Zeichenkette einem bestimmten Muster entspricht

Ein Objekt vom Typ [Regex] wird wie folgt konstruiert:

Konstruktor
Rolle
[public Regex(string pattern)]
erzeugt aus einem als Parameter übergebenen Muster ([pattern]) ein Objekt für einen „regulären Ausdruck“. Eine [ArgumentException] wird ausgelöst, wenn das Muster fehlerhaft ist
[public Regex(string pattern, RegexOptions options, TimeSpan matchTimeout)]
wie oben, mit Optionen und einem Timeout (siehe unten)

Sobald der reguläre Ausdruck konstruiert ist, kann er mit der Methode [IsMatch] mit Zeichenketten verglichen werden:

Methode
Rolle
[public bool IsMatch(string input)]
true, wenn die Zeichenkette [input] eine Teilzeichenkette enthält, die dem Muster des regulären Ausdrucks entspricht

Das Programm [regex-01.cs] lautet wie folgt:

using System.Text.RegularExpressions;

// Prüfen, ob eine Zeichenkette zu einem Muster passt
string pattern1 = @"^\s*\d+\s*$";
var regex1 = new Regex(pattern1);
// Vergleich von Beispielen mit dem Muster
foreach (string sample in new[] { "  123  ", "  123a  ", "4567" })
{
    if (regex1.IsMatch(sample))
    {
        Console.WriteLine($"[{sample}] matches the pattern [{pattern1}]");
    }
    else
    {
        Console.WriteLine($"[{sample}] does not match the pattern [{pattern1}]");
    }
}
// die statische Methode Regex.IsMatch erspart es, das Regex-Objekt selbst zu erzeugen
Console.WriteLine($"Regex.IsMatch(\"18/05/97\", date) : {Regex.IsMatch("18/05/97", @"^\d{2}/\d{2}/\d{2}$")}");
Console.WriteLine($"Regex.IsMatch(\"5/1/01\", date) : {Regex.IsMatch("5/1/01", @"^\d{2}/\d{2}/\d{2}$")}");

Ergebnisse:

1
2
3
4
5
6
> dotnet run regex-01.cs
[  123  ] matches the pattern [^\s*\d+\s*$]
[  123a  ] does not match the pattern [^\s*\d+\s*$]
[4567] matches the pattern [^\s*\d+\s*$]
Regex.IsMatch("18/05/97", date) : True
Regex.IsMatch("5/1/01", date) : False

Kommentare:

  • Zeile 4: das Muster für eine vorzeichenlose ganze Zahl, optional von Leerzeichen umgeben, die die gesamte Zeichenkette einnimmt (Anker [^] und [$]);
  • Zeile 9: Die von Leerzeichen umgebene Zeichenkette „123a“ entspricht dem Muster nicht: Das Zeichen „a“ kann weder eine Ziffer noch ein Leerzeichen sein. Ohne die Anker [^] und [$]würde die Zeichenkette passen, da sie eine Zahl enthält;
  • Zeile 19: Die Klasse [Regex] hat auch statische Methoden, die das Muster als Parameter erhalten. .NET hält die zuletzt verwendeten Muster im Speicher: Sie können in einer Schleife verwendet werden, ohne dass das Muster bei jedem Aufruf neu analysiert wird.

5.8.2. Alle Vorkommen eines Musters in einer Zeichenkette finden

Die Methode [Matches] ruft die Elemente einer Zeichenkette ab, die einem Muster entsprechen:

Methode
Rolle
[public MatchCollection Matches(string input)]
liefert die Sammlung der Elemente der Zeichenkette [input] , die dem Muster entsprechen

Die Klasse [MatchCollection] hat eine Eigenschaft [Count], die Anzahl der Elemente der Sammlung. Ist [results] ein Objekt vom Typ [MatchCollection], dann ist [results[i]] das i-te Element dieser Sammlung; es hat den Typ [Match]. Die Klasse [Match] hat verschiedene Eigenschaften, darunter die folgenden:

  • [Value]: der Wert des Objekts [Match], also ein Element, das dem Muster entspricht;
  • [Index]: die Position, an der das Element in der durchsuchten Zeichenkette gefunden wurde.

Das Programm [regex-02.cs] lautet wie folgt:

using System.Text.RegularExpressions;

// alle Vorkommen eines Musters in einer Zeichenkette finden
string pattern2 = @"\d+";
var regex2 = new Regex(pattern2);
string sample3 = "  123  456  789 ";
MatchCollection results = regex2.Matches(sample3);
Console.WriteLine($"Pattern=[{pattern2}], sample=[{sample3}]");
Console.WriteLine($"There are {results.Count} occurrences of the pattern in the sample");
foreach (Match m in results)
{
    Console.WriteLine($"[{m.Value}] found at position {m.Index}");
}
// eine MatchCollection ist eine Sequenz: LINQ lässt sich darauf anwenden
int sum = results.Sum(m => int.Parse(m.Value));
Console.WriteLine($"sum of the numbers found: {sum}");
// Count zählt die Vorkommen, ohne die Collection aufzubauen
Console.WriteLine($"number of vowels of \"antidisestablishmentarianism\": {Regex.Count("antidisestablishmentarianism", "[aeiouy]")}");

Ergebnisse:

1
2
3
4
5
6
7
8
> dotnet run regex-02.cs
Pattern=[\d+], sample=[  123  456  789 ]
There are 3 occurrences of the pattern in the sample
[123] found at position 2
[456] found at position 7
[789] found at position 12
sum of the numbers found: 1368
number of vowels of "antidisestablishmentarianism": 11

Kommentare:

  • Zeile 4: Das gesuchte Muster ist eine Folge von Ziffern;
  • Zeile 6: die Zeichenkette, in der dieses Muster gesucht wird;
  • Zeile 7: Alle Elemente von [sample3], die dem Muster [pattern2] entsprechen, werden abgerufen;
  • Zeilen 10–12: Sie werden angezeigt. Eine [MatchCollection] wird wie eine Liste mit [foreach] durchlaufen;
  • Zeile 15: [MatchCollection] implementiert [IEnumerable<Match>]: LINQ lässt sich darauf anwenden. Hier summieren wir die gefundenen Zahlen;
  • Zeile 18: Die Methode [Count] (.NET 7) zählt die Vorkommen des Musters, ohne eine Sammlung zu erzeugen. Das Muster [aeiouy] bezeichnet einen Vokal.

5.8.3. Teile eines Musters abrufen

Wie bereits erwähnt, werden die in Klammern eingeschlossenen Teile eines Musters gespeichert: Das sind die Gruppen. Das Programm [regex-03.cs] verwendet sie:

using System.Text.RegularExpressions;

// Teile eines Musters abrufen: Gruppen
string pattern3 = @"(\d\d):(\d\d):(\d\d)";
var regex3 = new Regex(pattern3);
string sample4 = "It is 18:05:49";
// Match liefert das erste Vorkommen des Musters
Match result = regex3.Match(sample4);
if (result.Success)
{
    Console.WriteLine($"The sample [{sample4}] matches the pattern [{pattern3}]");
    // wir zeigen die Gruppen in Klammern an
    for (int i = 0; i < result.Groups.Count; i++)
    {
        Console.WriteLine($"groups[{i}]=[{result.Groups[i].Value}] found at position {result.Groups[i].Index}");
    }
}
else
{
    Console.WriteLine($"The sample [{sample4}] does not match the pattern [{pattern3}]");
}

// benannte Gruppen: (?<name>...)
var regexDate = new Regex(@"(?<day>\d{1,2})/(?<month>\d{1,2})/(?<year>\d{4})");
string text = "Appointment on 3/10/2026, then on 15/11/2026.";
foreach (Match m in regexDate.Matches(text))
{
    // eine Gruppe wird eher über ihren Namen als über ihre Nummer angesprochen
    int day = int.Parse(m.Groups["day"].Value);
    int month = int.Parse(m.Groups["month"].Value);
    int year = int.Parse(m.Groups["year"].Value);
    var date = new DateOnly(year, month, day);
    Console.WriteLine($"[{m.Value}] : day={day}, month={month}, year={year} -> {date:dddd d MMMM yyyy}");
}

// Replace: die Gruppen können in der Ersetzungszeichenkette wiederverwendet werden
string reversed = regexDate.Replace(text, "${year}-${month}-${day}");
Console.WriteLine($"Replace : {reversed}");

Ergebnisse:

1
2
3
4
5
6
7
8
9
> dotnet run regex-03.cs
The sample [It is 18:05:49] matches the pattern [(\d\d):(\d\d):(\d\d)]
groups[0]=[18:05:49] found at position 6
groups[1]=[18] found at position 6
groups[2]=[05] found at position 9
groups[3]=[49] found at position 12
[3/10/2026] : day=3, month=10, year=2026 -> Saturday 3 October 2026
[15/11/2026] : day=15, month=11, year=2026 -> Sunday 15 November 2026
Replace : Appointment on 2026-10-3, then on 2026-11-15.

Kommentare:

  • Zeile 8: Die Zeichenkette [sample4] wird mit dem Muster [regex3] mithilfe der Methode [Match] verglichen. Diese Methode liefert das erste Vorkommen des Musters als Objekt vom Typ [Match], das bereits vorgestellt wurde. Hier verwenden wir zwei neue Eigenschaften dieser Klasse:
    • [Success] (Zeile 9): gibt an, ob ein Treffer gefunden wurde;
    • [Groups] (Zeile 13): eine Sammlung, in der [Groups[0]] dem Teil der Zeichenkette entspricht, der das Muster darstellt, und [Groups[i]] (i >= 1) dem i-ten Klammerpaar entspricht;
  • Wenn [result] den Typ [Match] hat, dann ist [result.Groups] vom Typ [GroupCollection] und [result.Groups[i]] ist vom Typ [Group]. Die Klasse [Group] hat wie die Klasse [Match]die Eigenschaften [Value] (der von der Gruppe erfasste Text) und [Index] (seine Position in der analysierten Zeichenkette);
  • Zeile 24: Eine Gruppe kann mit der Syntax benannt werden: [(?<name>...)]. Das Muster erkennt hier ein Datum im Format d/m/yyyy mit ein- oder zweistelligem Tag und Monat;
  • Zeilen 29–31: Auf eine benannte Gruppe wird über ihren Namen statt über ihre Nummer zugegriffen: Der Code ist lesbarer und hängt nicht von der Reihenfolge der Klammern ab;
  • Zeile 32: Der Typ [DateOnly] (.NET 6) stellt ein Datum ohne Uhrzeit dar. Er wird im Format [dddd d MMMM yyyy] angezeigt: Der Wochentag erscheint auf Englisch;
  • Zeile 37: Die Methode [Replace] ersetzt jedes Vorkommen des Musters durch eine Zeichenkette, in der [${name}] (oder [$1], [$2] … bei nummerierten Gruppen) den Wert einer Gruppe bezeichnet. Die Daten werden so in das Format Jahr-Monat-Tag umformatiert.

5.8.4. Ein Lernprogramm

Den regulären Ausdruck zu finden, der prüft, ob eine Zeichenkette einem bestimmten Muster entspricht, kann mitunter eine echte Herausforderung sein. Das Programm [regex-04.cs] lässt Sie üben. Es nimmt ein Muster und eine Zeichenkette als Eingabe entgegen und zeigt an, ob die Zeichenkette dem Muster entspricht oder nicht.

using System.Text.RegularExpressions;

// ein Programm zum Erlernen regulärer Ausdrücke
while (true)
{
    // wir fragen nach dem Muster
    Console.Write("Type the pattern to test or nothing to stop: ");
    string pattern = Console.ReadLine() ?? "";
    // fertig?
    if (pattern.Trim() == "")
    {
        break;
    }
    // wir erzeugen den regulären Ausdruck; ein fehlerhaftes Muster löst eine Exception aus
    Regex regex;
    try
    {
        regex = new Regex(pattern, RegexOptions.None, TimeSpan.FromSeconds(1));
    }
    catch (ArgumentException e)
    {
        Console.WriteLine($"Error: {e.Message}");
        continue;
    }
    // wir fragen nach den Beispielen, die mit dem Muster verglichen werden sollen
    while (true)
    {
        Console.Write($"Type the string to compare with the pattern [{pattern}] or nothing to stop: ");
        string input = Console.ReadLine() ?? "";
        // fertig?
        if (input.Trim() == "")
        {
            break;
        }
        try
        {
            // wir führen den Vergleich durch
            MatchCollection results = regex.Matches(input);
            if (results.Count == 0)
            {
                Console.WriteLine("I did not find any matches");
                continue;
            }
            // wir zeigen die Elemente an, die zum Muster passen
            foreach (Match m in results)
            {
                Console.WriteLine($"I found the match [{m.Value}] at position [{m.Index}]");
                // und ihre Unterelemente (Gruppen 1, 2, ...)
                for (int j = 1; j < m.Groups.Count; j++)
                {
                    Console.WriteLine($"\tsub-element [{m.Groups[j].Value}] at position [{m.Groups[j].Index}]");
                }
            }
        }
        catch (RegexMatchTimeoutException)
        {
            Console.WriteLine("The search was abandoned: it lasted more than one second");
        }
    }
}

Kommentare:

  • Zeile 18: Der reguläre Ausdruck wird mit einem Timeout von einer Sekunde konstruiert: Dauert eine Suche länger, wird sie abgebrochen, und eine [RegexMatchTimeoutException] wird ausgelöst (Zeile 55). Wir werden später sehen, wozu das nützlich ist;
  • Zeile 20: Ein ungültiges Muster löst eine [ArgumentException] aus (genauer gesagt eine [RegexParseException], die von ihr abgeleitet ist);
  • Zeilen 45–51: Für jeden Treffer werden die Gruppe Nr. 1 und gegebenenfalls die folgenden Gruppen angezeigt.

Hier ein Beispiel für die Ausgabe:

> dotnet run regex-04.cs
Type the pattern to test or nothing to stop: \d+
Type the string to compare with the pattern [\d+] or nothing to stop: 123 456 789
I found the match [123] at position [0]
I found the match [456] at position [4]
I found the match [789] at position [8]
Type the string to compare with the pattern [\d+] or nothing to stop: 
Type the pattern to test or nothing to stop: (\d{2}):(\d\d)
Type the string to compare with the pattern [(\d{2}):(\d\d)] or nothing to stop: 14:15 abcd 17:18 xyzt
I found the match [14:15] at position [0]
    sub-element [14] at position [0]
    sub-element [15] at position [3]
I found the match [17:18] at position [11]
    sub-element [17] at position [11]
    sub-element [18] at position [14]
Type the string to compare with the pattern [(\d{2}):(\d\d)] or nothing to stop: 
Type the pattern to test or nothing to stop: ^\s*\d+\s*$
Type the string to compare with the pattern [^\s*\d+\s*$] or nothing to stop:    1456
I found the match [   1456] at position [0]
Type the string to compare with the pattern [^\s*\d+\s*$] or nothing to stop: 
Type the pattern to test or nothing to stop: ^\s*(\d+)\s*$
Type the string to compare with the pattern [^\s*(\d+)\s*$] or nothing to stop: 1456
I found the match [1456] at position [0]
    sub-element [1456] at position [0]
Type the string to compare with the pattern [^\s*(\d+)\s*$] or nothing to stop: abcd 1456
I did not find any matches
Type the string to compare with the pattern [^\s*(\d+)\s*$] or nothing to stop: 
Type the pattern to test or nothing to stop: (a+)+$
Type the string to compare with the pattern [(a+)+$] or nothing to stop: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!
The search was abandoned: it lasted more than one second
Type the string to compare with the pattern [(a+)+$] or nothing to stop: 
Type the pattern to test or nothing to stop: (\d+
Error: Invalid pattern '(\d+' at offset 4. Not enough )'s.
Type the pattern to test or nothing to stop: 

Die Muster [^\s*\d+\s*$] und [^\s*(\d+)\s*$] zeigen, wie nützlich Gruppen sind: Das erste erkennt die Zeichenkette „1456“ mit drei vorangestellten Leerzeichen, einschließlich der Leerzeichen; das zweite extrahiert zusätzlich die Zahl ohne die Leerzeichen. Das Muster [(a+)+$] wird weiter unten untersucht.

5.8.5. Die Methode Split

Die Methode [Split] der Klasse [String] ist uns bereits begegnet:

Methode
Rolle
[public string[] Split(params char[] separator)]
Die Zeichenkette wird als Folge von Feldern behandelt, die durch die im Array [separator] aufgeführten Zeichen getrennt sind. Das Ergebnis ist ein Array dieser Felder

Die Methode [Split] der Klasse [Regex] erlaubt es, das Trennzeichen über ein Muster anzugeben:

Methode
Rolle
[public string[] Split(string input)]
Die Zeichenkette [input] wird in Felder zerlegt, die durch ein Trennzeichen getrennt sind, das dem Muster des aktuellen [Regex]-Objekts entspricht

Angenommen, eine Textdatei enthält Zeilen der Form field1, field2, ..., fieldn. Die Felder sind durch ein Komma getrennt, dem jedoch Leerzeichen vorausgehen oder folgen können. Das Muster [\s*,\s*] beschreibt dieses Trennzeichen genau, wie das Programm [regex-05.cs] zeigt:

using System.Text.RegularExpressions;

// Regex.Split: das Trennzeichen wird durch ein Muster definiert
string line = "abc  , def  ,ghi ,   jkl";
// ein Komma, vor und nach dem beliebig viele Leerzeichen stehen
var separator = new Regex(@"\s*,\s*");
string[] fields = separator.Split(line);
for (int i = 0; i < fields.Length; i++)
{
    Console.WriteLine($"fields[{i}]=[{fields[i]}]");
}
// mehrere mögliche Trennzeichen: ; oder | oder eine Folge von Leerzeichen
string[] words = Regex.Split("one;two|three   four", @"[;|]|\s+");
Console.WriteLine($"words=[{string.Join(", ", words)}]");

Ergebnisse:

1
2
3
4
5
6
> dotnet run regex-05.cs
fields[0]=[abc]
fields[1]=[def]
fields[2]=[ghi]
fields[3]=[jkl]
words=[one, two, three, four]

Kommentare:

  • Zeile 6: das Trennzeichen: ein Komma, vor und nach dem beliebig viele Leerzeichen stehen. Die Leerzeichen werden zusammen mit dem Trennzeichen entfernt. Beachten Sie, dass die weiter oben vorgestellte Option [TrimEntries] von [string.Split]es inzwischen erlaubt, dasselbe Ergebnis ohne regulären Ausdruck zu erzielen;
  • Zeile 13: Ein Trennzeichen, das mehrere Formen annehmen kann: ein Semikolon oder ein senkrechter Strich ([;|]) oder ([|]) eine Folge von Leerzeichen ([\s+]). Hier ist ein regulärer Ausdruck erforderlich.

5.8.6. Generierte reguläre Ausdrücke, Optionen, Timeout

Ein [Regex]-Objekt analysiert sein Muster zur Laufzeit und übersetzt es dann in eine interne Struktur, die es interpretiert, oder kompiliert es in ausführbaren Code, wenn ihm die Option [RegexOptions.Compiled] übergeben wird. Ab .NET 7 erlaubt das Attribut [GeneratedRegex], diese Arbeit zur Kompilierzeit erledigen zu lassen: Ein Source Generator schreibt den C#-Code für die Suche, der im Editor angezeigt werden kann (F12 auf der Methode). Das Muster wird zur Kompilierzeit validiert, beim Start fällt kein Analyseaufwand mehr an, und der generierte Code läuft so schnell wie möglich. Dies ist inzwischen der empfohlene Weg, ein im Voraus bekanntes Muster zu verwenden. Das Programm [regex-06.cs] lautet wie folgt:

using System.Diagnostics;
using System.Text.RegularExpressions;

// 1 - zur Kompilierzeit erzeugte reguläre Ausdrücke
Console.WriteLine($"Time(\"It is 18:05:49\") : {Patterns.Time().IsMatch("It is 18:05:49")}");
Match m = Patterns.Time().Match("departure at 07:45:00");
Console.WriteLine($"hours={m.Groups["h"].Value}, minutes={m.Groups["m"].Value}, seconds={m.Groups["s"].Value}");

// 2 - Optionen: hier IgnoreCase, im Attribut gesetzt
foreach (string answer in new[] { "yes", "YES", "Yes", "no", "yesss" })
{
    Console.Write($"{answer}={Patterns.Yes().IsMatch(answer)} ");
}
Console.WriteLine();
// Optionen werden mit | kombiniert: Multiline bewirkt, dass ^ und $ an jedem Zeilenanfang und -ende passen
string text = "price: 10\nquantity: 3\ntotal: 30";
foreach (Match line in Regex.Matches(text, @"^(\w+): (\d+)$", RegexOptions.Multiline))
{
    Console.Write($"[{line.Groups[1].Value}={line.Groups[2].Value}] ");
}
Console.WriteLine();

// 3 - ein Timeout schützt vor Mustern mit katastrophalem Backtracking
string input = new string('a', 30) + "!";
try
{
    Console.WriteLine(Patterns.Catastrophic().IsMatch(input));
}
catch (RegexMatchTimeoutException e)
{
    Console.WriteLine($"{e.GetType().Name} : search abandoned after {e.MatchTimeout.TotalMilliseconds} ms");
}
// dasselbe Muster antwortet mit der Engine ohne Backtracking sofort
var stopwatch = Stopwatch.StartNew();
bool found = Regex.IsMatch(input, @"^(a+)+$", RegexOptions.NonBacktracking);
Console.WriteLine($"NonBacktracking : {found}, answer in less than one second: {stopwatch.ElapsedMilliseconds < 1000}");

// die Muster des Programms
static partial class Patterns
{
    // eine Uhrzeit hh:mm:ss mit benannten Gruppen
    [GeneratedRegex(@"(?<h>\d\d):(?<m>\d\d):(?<s>\d\d)")]
    public static partial Regex Time();

    // ja, unabhängig von der Groß-/Kleinschreibung
    [GeneratedRegex(@"^\s*yes\s*$", RegexOptions.IgnoreCase)]
    public static partial Regex Yes();

    // ein pathologisches Muster, mit einem Timeout von 100 ms
    [GeneratedRegex(@"^(a+)+$", RegexOptions.None, matchTimeoutMilliseconds: 100)]
    public static partial Regex Catastrophic();
}

Ergebnisse:

1
2
3
4
5
6
7
> dotnet run regex-06.cs
Time("It is 18:05:49") : True
hours=07, minutes=45, seconds=00
yes=True YES=True Yes=True no=False yesss=False 
[price=10] [quantity=3] [total=30] 
RegexMatchTimeoutException : search abandoned after 100 ms
NonBacktracking : False, answer in less than one second: True

Kommentare:

  • Zeilen 39–51: Jedes Muster wird durch eine partielle statische Methode ([partial]) ohne Rumpf deklariert, die ein [Regex] erzeugt und der das Attribut [GeneratedRegex] vorangestellt ist. Der Source Generator schreibt den Methodenrumpf in einen anderen Teil der Klasse, der ebenfalls als [partial] deklariert ist. Ab C# 13 und .NET 9 können Sie auch eine partielle Eigenschaft deklarieren: [[GeneratedRegex(...)] private static partial Regex Time { get; }];
  • Zeile 5: Die Methode wird wie ein gewöhnliches [Regex]-Objekt verwendet;
  • Zeile 46: Der zweite Parameter des Attributs ist eine Kombination von Optionen [RegexOptions]. [IgnoreCase] ignoriert die Groß- und Kleinschreibung: „YES“ und „Yes“ entsprechen dem Muster;
  • Zeile 17: Die Optionen werden bei den Methoden von [Regex] auf dieselbe Weise verwendet. [Multiline] lässt [^] und [$] am Anfang und am Ende jeder Zeile der Zeichenkette passen, nicht nur am Anfang und Ende der Zeichenkette selbst. Weitere Optionen sind nützlich: [Singleline] ([.] passt auch auf Zeilenumbrüche), [IgnorePatternWhitespace] (Leerzeichen im Muster werden ignoriert, sodass es sich über mehrere Zeilen und mit Kommentaren schreiben lässt), [ExplicitCapture] (nur benannte Gruppen werden gespeichert). Sie lassen sich mit dem Operator [|] kombinieren;
  • Zeile 50: Das Muster [^(a+)+$] ist pathologisch: Wird es auf eine Folge von „a“ angewendet, die mit einem anderen Zeichen endet, probiert die Engine für reguläre Ausdrücke jede mögliche Verteilung der „a“ auf die Wiederholungen der Gruppe durch, bevor sie feststellt, dass die Suche gescheitert ist. Die Zahl der Möglichkeiten verdoppelt sich mit jedem zusätzlichen „a“: Bei 30 „a“ sind es etwa eine Milliarde Möglichkeiten. Dies nennt man katastrophales Backtracking. Ein solches Muster, das auf von Benutzern eingegebene Zeichenketten angewendet wird, ist eine Sicherheitslücke: Schon wenige Anfragen genügen, um einen Server zum Absturz zu bringen. Der Parameter [matchTimeoutMilliseconds] legt ein Timeout von 100 ms fest: Danach wird die Suche mit einer [RegexMatchTimeoutException] abgebrochen (Zeile 6);
  • Zeile 35: Die Option [NonBacktracking] (.NET 7) verwendet eine andere Engine, die eine zur Länge der Zeichenkette proportionale Suchzeit garantiert. Sie unterstützt bestimmte Konstrukte nicht (Rückwärtsverweise wie [\1] zum Beispiel), liefert in diesem Fall aber sofort ein Ergebnis.

Beachten Sie, dass Sie ein Timeout festlegen oder [NonBacktracking] verwenden müssen, sobald das Muster oder die durchsuchte Zeichenkette von außerhalb des Programms stammt.

5.9. Beispielanwendung – V3

Wir greifen die Anwendung aus Kapitel 3 (Version 1) und Kapitel 4 (Version 2) wieder auf. Denken Sie daran, dass es sich um eine Übung handelt: Die verwendete Steuertabelle ist die von 2004 (Einkommen 2003), die seit dem ursprünglichen Kurs unverändert geblieben ist.

5.9.1. Daten in einer Datei

In Version 2 wurde die Steuerberechnung in der abstrakten Klasse [AbstractTax] durchgeführt, die wir hier bis auf ihren Namespace unverändert wiedergeben:

namespace TaxV3;

public abstract class AbstractTax : ITax
{
    // die für die Berechnung benötigten Steuerstufen stammen aus einer externen Quelle,
    // die nur die abgeleiteten Klassen kennen
    protected abstract TaxBracket[] TaxBrackets { get; }

    // Steuerberechnung
    public int Calculate(bool married, int nbChildren, int salary)
    {
        // Berechnung der Anzahl der Anteile
        decimal shares = (decimal)nbChildren / 2 + (married ? 2 : 1);
        if (nbChildren >= 3)
        {
            shares += 0.5m;
        }
        // Berechnung des zu versteuernden Einkommens und des Familienquotienten
        decimal income = 0.72m * salary;
        decimal quotient = income / shares;
        // Suche der Steuerstufe: die letzte wird verwendet, wenn keine Grenze passt
        TaxBracket[] brackets = TaxBrackets;
        TaxBracket bracket = brackets[^1];
        for (int i = 0; i < brackets.Length - 1; i++)
        {
            if (quotient <= brackets[i].Limit)
            {
                bracket = brackets[i];
                break;
            }
        }
        // Steuerberechnung
        return (int)(income * bracket.CoeffR - shares * bracket.CoeffN);
    }
}

Die Methode [Calculate] verwendet die Steuerstufen, die von der abstrakten Eigenschaft [TaxBrackets] geliefert werden (Zeile 7). Die Klasse [AbstractTax] weiß nicht, woher diese Stufen stammen: Es ist Aufgabe der abgeleiteten Klassen, sie bereitzustellen. In Version 2 hatte die abgeleitete Klasse [HardwiredTax] sie fest in ihren Code geschrieben. Eine Steuerstufe wird wie in Version 2 durch die Record-Struktur [TaxBracket] dargestellt:

1
2
3
4
namespace TaxV3;

// eine Stufe des Steuertarifs
public readonly record struct TaxBracket(decimal Limit, decimal CoeffR, decimal CoeffN);

und die Berechnung wird durch die Schnittstelle [ITax] beschrieben:

1
2
3
4
5
6
7
namespace TaxV3;

public interface ITax
{
    // Steuerberechnung für einen Steuerpflichtigen
    int Calculate(bool married, int nbChildren, int salary);
}

Die neue Version speichert die Daten in einer Datei, sodass sich die Steuertabelle ändern lässt, ohne das Programm neu zu kompilieren. Wir schreiben zwei neue, von [AbstractTax] abgeleitete Klassen:

  • [FileTax] liest die Stufen aus einer Textdatei [TaxData.txt];
  • [JsonTax] liest sie aus einer JSON-Datei mit dem Namen [TaxData.json].

Die Textdatei [TaxData.txt] enthält pro Zeile eine Steuerstufe im Format limit:coeffR:coeffN:

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

Der Kurs von 2008 schrieb Zahlen mit Dezimalkomma (0,068) und las sie mit [decimal.TryParse] in der Ländereinstellung des Rechners ein: Dieselbe Datei wäre auf einem britischen oder amerikanischen Rechner abgelehnt oder, schlimmer noch, falsch interpretiert worden. Eine Datendatei darf nicht von der Sprache des lesenden Rechners abhängen: Wir schreiben Zahlen mit Dezimalpunkt und lesen sie in der invarianten Kultur ([CultureInfo.InvariantCulture]) ein, die auch von JSON und den meisten Datenformaten verwendet wird.

Die Datei [TaxData.json] enthält dieselben Daten in Form eines JSON-Arrays von Objekten:

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 }
]

5.9.2. Fehler

Die Verarbeitung dieser Dateien kann scheitern: fehlende Datei, fehlerhafte Zeile, falsche Zahl usw. Wie in der Version von 2008 erstellen wir eine eigene Ausnahmeklasse, um diese Fehler zu melden. Der Kurs von 2008 nannte sie [FileTaxException]; wir nennen sie [TaxException], da sie auch für andere Datenquellen verwendet wird (hier die JSON-Datei, später eine Datenbank). Sie trägt einen Fehlercode:

namespace TaxV3;

// die Fehlercodes: Zweierpotenzen, die kombiniert werden können
[Flags]
public enum ErrorCode
{
    Access = 1,     // die Datei kann nicht gelesen werden
    Line = 2,       // eine Zeile hat nicht drei Felder
    Field1 = 4,     // Feld 1 (limit) ist fehlerhaft
    Field2 = 8,     // Feld 2 (coeffR) ist fehlerhaft
    Field3 = 16,    // Feld 3 (coeffN) ist fehlerhaft
    Json = 32       // das JSON-Dokument ist fehlerhaft
}

// die Exception, die von den Klassen ausgelöst wird, die die Steuerstufen lesen
public class TaxException : Exception
{
    // der Fehlercode (eine Kombination von ErrorCode-Werten)
    public int Code { get; init; }

    public TaxException(string message) : base(message) { }
    public TaxException(string message, Exception inner) : base(message, inner) { }
}

Kommentare:

  • Zeilen 16–22: Die Klasse [TaxException] leitet sich von der Klasse [Exception] ab. Sie dient dazu, alle Fehler zu melden, die bei der Verarbeitung der Datendatei auftreten. Sie hat zwei Konstruktoren: Der erste nimmt eine Fehlermeldung entgegen, der zweite zusätzlich die Ausnahme, die den Fehler verursacht hat und die in der Eigenschaft [InnerException] verfügbar sein wird;
  • Zeile 19: Die Eigenschaft [Code] speichert den Fehlercode. Das Schlüsselwort [init] erlaubt es, ihn nur bei der Erzeugung des Objekts mit einem Objektinitialisierer zu setzen: [new TaxException("...") { Code = 2 }]. Genau diese Form der Ausnahme mit einem ganzzahligen Code werden die folgenden Versionen der Anwendung verwenden;
  • Zeilen 4–12: eine Liste der möglichen Fehlercodes:
    • [Access]: Fehler beim Zugriff auf die Datendatei;
    • [Line]: Zeile, in der die drei erwarteten Felder fehlen, oder Datei ohne Steuerstufen;
    • [Field1], [Field2], [Field3]: Feld 1, 2 oder 3 einer Zeile ist fehlerhaft;
    • [Json]: Das Dokument JSON ist fehlerhaft.

Einige dieser Fehler können gleichzeitig auftreten: Alle drei Felder einer Zeile können fehlerhaft sein. Deshalb wurde die Aufzählung [ErrorCode] mit dem Attribut [Flags] versehen, und ihre Werte sind Zweierpotenzen: Jeder entspricht einem Bit der ganzen Zahl. Ein Fehler in den Feldern 2 und 3 führt zum Code [Field2 | Field3], also 8 + 16 = 24. Dank des Attributs [Flags] zeigt die Methode [ToString] der Aufzählung eine solche Kombination in der Form „Field2, Field3“ an.

5.9.3. Die Klasse FileTax

Die Klasse [FileTax] liefert die aus einer Textdatei gelesenen Stufen:

using System.Globalization;
using System.Text.RegularExpressions;

namespace TaxV3;

// die aus einer Textdatei mit Zeilen limit:coeffR:coeffN gelesenen Steuerstufen
public partial class FileTax : AbstractTax
{
    // das Feldtrennzeichen: das Zeichen : mit optionalen Leerzeichen drumherum
    [GeneratedRegex(@"\s*:\s*")]
    private static partial Regex Separator();

    // die aus der Datei gelesenen Steuerstufen
    private readonly TaxBracket[] taxBrackets;

    // Implementierung der abstrakten Eigenschaft der Elternklasse
    protected override TaxBracket[] TaxBrackets => taxBrackets;

    public FileTax(string fileName)
    {
        // der Name der Datei, ohne Pfad, für die Fehlermeldungen
        string name = Path.GetFileName(fileName);
        // die gelesenen Stufen; ihre Anzahl kennen wir nicht im Voraus
        List<TaxBracket> brackets = [];
        try
        {
            int lineNumber = 0;
            foreach (string lineRead in File.ReadLines(fileName))
            {
                lineNumber++;
                string line = lineRead.Trim();
                // leere Zeilen werden ignoriert
                if (line == "")
                {
                    continue;
                }
                // die Zeile muss drei Felder haben
                string[] fields = Separator().Split(line);
                if (fields.Length != 3)
                {
                    throw new TaxException($"Line no. {lineNumber} is incorrect ({line})")
                    {
                        Code = (int)ErrorCode.Line
                    };
                }
                // drei positive oder null betragende Dezimalzahlen, mit Dezimalpunkt geschrieben
                ErrorCode code = 0;
                if (!Read(fields[0], out decimal limit)) code |= ErrorCode.Field1;
                if (!Read(fields[1], out decimal coeffR)) code |= ErrorCode.Field2;
                if (!Read(fields[2], out decimal coeffN)) code |= ErrorCode.Field3;
                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 {name}", e)
            {
                Code = (int)ErrorCode.Access
            };
        }
        // mindestens eine Stufe ist erforderlich
        if (brackets.Count == 0)
        {
            throw new TaxException($"The file {name} does not contain any bracket")
            {
                Code = (int)ErrorCode.Line
            };
        }
        // wir übertragen die Liste in das Array der Stufen
        taxBrackets = brackets.ToArray();
    }

    // Umwandlung eines Felds in einen Dezimalwert >= 0, unabhängig von der Kultur des Rechners
    private static bool Read(string field, out decimal result) =>
        decimal.TryParse(field, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out result);
}

Kommentare:

  • Zeile 7: Die Klasse [FileTax] ist von der Klasse [AbstractTax] abgeleitet, so wie es in Version 2 die Klasse [HardwiredTax] war. Sie ist als [partial] deklariert, weil sie einen generierten regulären Ausdruck enthält;
  • Zeilen 10–11: der reguläre Ausdruck für das Feldtrennzeichen in einer Zeile limit:coeffR:coeffN: das Zeichen [:], vor und nach dem beliebig viele Leerzeichen stehen;
  • Zeilen 14–17: die gelesenen Stufen, geliefert von der Eigenschaft [TaxBrackets], die die abstrakte Eigenschaft von [AbstractTax] überschreibt;
  • Zeile 19: Der Konstruktor erhält den Namen der Textdatei mit den Daten. Seine Aufgabe ist es, das Array [taxBrackets] zu füllen;
  • Zeile 22: der Dateiname ohne Pfad, der in Fehlermeldungen verwendet wird. Der Konstruktor erhält tatsächlich einen vollständigen Pfad, der dem Benutzer nicht angezeigt werden muss;
  • Zeile 24: Das Lesen einer Textdatei erfolgt sequenziell: Die Anzahl der Zeilen ist erst bekannt, wenn die gesamte Datei gelesen wurde. Das Array kann daher nicht im Voraus dimensioniert werden; die Stufen werden vorübergehend in einer Liste gespeichert;
  • Zeile 28: Die Datei wird mit [File.ReadLines] zeilenweise gelesen, wobei die Methode die Datei selbst öffnet und schließt. Der Kurs von 2008 verwendete [StreamReader];
  • Zeilen 38–43: Die Zeile wird mithilfe eines regulären Ausdrucks in Felder zerlegt; sind es nicht drei Felder, wird eine [TaxException] mit dem Code [Line] ausgelöst. Der Kurs von 2008 speicherte den Fehler in einer Variablen, verließ die Schleife und löste die Ausnahme erst nach dem Schließen der Datei aus: Sie sofort auszulösen ist einfacher, und [File.ReadLines] schließt die Datei in jedem Fall, da die Schleife [foreach] ihren Enumerator auch dann freigibt, wenn eine Ausnahme sie unterbricht;
  • Zeilen 47–55: Umwandlung der drei Felder in Dezimalzahlen. Fehler werden in der Variablen [code] mit dem Operator [|=] gesammelt und anschließend gemeinsam gemeldet;
  • Zeilen 83–84: Umwandlung eines Feldes. [NumberStyles.AllowDecimalPoint] lässt nur Ziffern und einen Dezimalpunkt zu: keine Vorzeichen, Leerzeichen oder Tausendertrennzeichen. Negative Zahlen werden daher abgelehnt, wodurch die Daten zugleich mit der Umwandlung validiert werden. [CultureInfo.InvariantCulture] erzwingt den Punkt als Dezimaltrennzeichen, unabhängig von der Ländereinstellung des Rechners;
  • Zeilen 62–67: Dateizugriffsfehler ([IOException] und ihre Varianten wie [FileNotFoundException] oder [UnauthorizedAccessException] bei unzureichenden Berechtigungen) werden verpackt in einer [TaxException] mit dem Code [Access]. Der [when (...)] Exception-Filter (C# 6) fängt nur diese Ausnahmen ab: [TaxException]-Ausnahmen, die innerhalb der Schleife ausgelöst werden, werden nicht abgefangen und verlassen den Konstruktor unverändert. Das Muster [e is IOException or UnauthorizedAccessException] ist ein kombiniertes Muster mit [or] (C# 9);
  • Zeilen 71–79: Eine leere Datei wird abgelehnt; andernfalls wird die Liste in das Array der Stufen übertragen, was der Zweck des Konstruktors war.

Das Kapseln von Low-Level-Ausnahmen ([IOException]) in eine anwendungsspezifische Ausnahme ([TaxException]) erlaubt es dem aufrufenden Code, unabhängig von der Datenquelle nur einen Ausnahmetyp zu behandeln: eine Textdatei, eine JSON-Datei und, später im Kurs, eine Datenbank.

5.9.4. Die Klasse JsonTax

Die Klasse [JsonTax] liefert die aus einer JSON-Datei gelesenen Stufen:

using System.Text.Json;

namespace TaxV3;

// die aus einer JSON-Datei gelesenen Steuerstufen
public class JsonTax : AbstractTax
{
    // „Web"-Optionen: Eigenschaftsnamen in camelCase (limit, coeffR, coeffN)
    private static readonly JsonSerializerOptions options = new(JsonSerializerDefaults.Web);

    // die aus der Datei gelesenen Steuerstufen
    private readonly TaxBracket[] taxBrackets;

    // Implementierung der abstrakten Eigenschaft der Elternklasse
    protected override TaxBracket[] TaxBrackets => taxBrackets;

    public JsonTax(string fileName)
    {
        // der Name der Datei, ohne Pfad, für die Fehlermeldungen
        string name = Path.GetFileName(fileName);
        string json;
        try
        {
            // Lesen der Datei
            json = File.ReadAllText(fileName);
        }
        catch (Exception e) when (e is IOException or UnauthorizedAccessException)
        {
            throw new TaxException($"Error while reading the file {name}", e)
            {
                Code = (int)ErrorCode.Access
            };
        }
        TaxBracket[]? brackets;
        try
        {
            // Deserialisierung des Arrays der Stufen
            brackets = JsonSerializer.Deserialize<TaxBracket[]>(json, options);
        }
        catch (JsonException e)
        {
            throw new TaxException($"The file {name} is incorrect: {e.Message}", e)
            {
                Code = (int)ErrorCode.Json
            };
        }
        // mindestens eine Stufe ist erforderlich, ohne negativen Wert
        if (brackets is null || brackets.Length == 0)
        {
            throw new TaxException($"The file {name} does not contain any bracket")
            {
                Code = (int)ErrorCode.Json
            };
        }
        if (brackets.Any(t => t.Limit < 0 || t.CoeffR < 0 || t.CoeffN < 0))
        {
            throw new TaxException($"The file {name} contains a negative value")
            {
                Code = (int)ErrorCode.Json
            };
        }
        taxBrackets = brackets;
    }
}

Kommentare:

  • Zeile 9: Die „Web“-Optionen: Die JSON-Eigenschaften [limit], [coeffR] und [coeffN] entsprechen den Eigenschaften [Limit], [CoeffR] und [CoeffN] der Struktur [TaxBracket], ohne dass diese mit Attributen angepasst werden muss. Die Optionen werden in einem statischen Feld gespeichert: Ein [JsonSerializerOptions]-Objekt speichert Informationen über die Typen, die es verarbeitet hat, und es wird empfohlen, es wiederzuverwenden;
  • Zeilen 25–31: das Lesen der Datei; ein Zugriffsfehler wird wie in [FileTax] behandelt;
  • Zeile 38: Eine einzige Anweisung wandelt den Text JSON in ein Array von Stufen um. [System.Text.Json] versteht es, eine Record-Struktur durch Aufruf ihres Konstruktors zu erzeugen. Ein ungültiges Dokument löst eine [JsonException] aus, die in einer [TaxException] mit dem Code [Json] gekapselt wird;
  • Zeilen 48–57: Die Deserialisierung prüft das Format des Dokuments, nicht die Gültigkeit der Daten: Es bleibt zu überprüfen, dass es mindestens eine Stufe gibt (das Dokument [null] oder [] ist ein gültiges JSON) und dass keine Werte negativ sind. Die LINQ-Methode [Any] führt diese letzte Prüfung in einer einzigen Zeile durch.

Der Vergleich der beiden Klassen ist aufschlussreich: Mit einem strukturierten Datenformat und einer Bibliothek, die es versteht, erfordert das Parsen der Datei keinen Code mehr.

5.9.5. Das Hauptprogramm

Das Konsolenprojekt [TaxV3] hat die folgende Verzeichnisstruktur:

05-classes-dotnet/
  05-classes-dotnet.slnx
  TaxV3/
    AbstractTax.cs
    FileTax.cs
    ITax.cs
    JsonTax.cs
    Program.cs
    TaxBracket.cs
    TaxData.json
    TaxData.txt
    TaxDataInvalid.json
    TaxDataInvalid.txt
    TaxException.cs
    TaxV3.csproj

Die Projektdatei [TaxV3.csproj] ist die von [dotnet new console] erzeugte, der eine Gruppe von Elementen hinzugefügt wurde:

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

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

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

</Project>

Das Element [<None Update="..." CopyToOutputDirectory="PreserveNewest" />] (Zeile 12) legt fest, dass die Datendateien bei der Kompilierung in den Ordner der ausführbaren Datei ([bin/Debug/net10.0]) kopiert werden, wenn sie neuer sind als die vorhandene Kopie. Das Zeichen [*] erlaubt es, alle Dateien [TaxData*.txt] und [TaxData*.json] auf einmal anzugeben. Das entspricht der Eigenschaft „In Ausgabeverzeichnis kopieren“, die der Kurs von 2008 in den Dateieigenschaften in Visual Studio setzte.

Das Programm [Program.cs] lautet wie folgt:

using TaxV3;

// Steuerberechnung, Version 3: die Steuerstufen werden aus einer Datei gelesen
// Syntax: dotnet run [-- Datei]; Datei: standardmäßig TaxData.txt oder eine .json-Datei

const string syntax = """
    syntax: Married NbChildren Salary
    Married: y for married, n for not married
    NbChildren: number of children
    Salary: annual salary in euros
    """;

// die Datendatei wird neben der ausführbaren Datei gesucht
string fileName = args.Length > 0 ? args[0] : "TaxData.txt";
string path = Path.Combine(AppContext.BaseDirectory, fileName);
Console.WriteLine($"Tax brackets read from [{fileName}]");

// Erzeugung eines ITax-Objekts; die Klasse hängt von der Dateierweiterung ab
ITax tax;
try
{
    tax = Path.GetExtension(fileName).ToLower() switch
    {
        ".json" => new JsonTax(path),
        _ => new FileTax(path)
    };
}
catch (TaxException e)
{
    // Anzeige des Fehlers; der Code wird als Kombination von ErrorCode angezeigt
    string origin = e.InnerException is null ? "" : $", original exception: {e.InnerException.GetType().Name}";
    Console.WriteLine($"The following error occurred: [Code={(ErrorCode)e.Code}, Message={e.Message}{origin}]");
    // Beenden des Programms
    return 1;
}

// Eingabeschleife
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 Feldanzahl der eingegebenen Zeile
    string[] fields = parameters.Split(' ', StringSplitOptions.RemoveEmptyEntries);
    if (fields.Length != 3)
    {
        Console.WriteLine(syntax);
        continue;
    }
    // Prüfung der Gültigkeit der Parameter
    // married
    string married = fields[0].ToLower();
    if (married != "y" && married != "n")
    {
        Console.WriteLine(syntax + "\nIncorrect married argument: type y or n");
        continue;
    }
    // nbChildren
    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 berechnen die Steuer
    Console.WriteLine($"Tax={tax.Calculate(married == "y", nbChildren, salary)} euros");
}
return 0;

Kommentare:

  • Zeile 14: Der Name der Datendatei wird als Argument übergeben; standardmäßig ist es [TaxData.txt];
  • Zeile 15: Die Datei wird im Ordner der ausführbaren Datei gesucht, [AppContext.BaseDirectory], wohin sie bei der Kompilierung kopiert wurde. So findet das Programm seine Daten unabhängig davon, aus welchem Ordner es gestartet wird, was bei den Single-File-Anwendungen dieses Kapitels nicht der Fall war;
  • Zeilen 22–25: Ein [switch] -Ausdruck (Kapitel 3) wählt anhand der Dateierweiterung die zu instanziierende Klasse aus. Die beiden Zweige liefern unterschiedliche Typen, [JsonTax] und [FileTax]: Der Compiler leitet den Typ des Ausdrucks aus der Zielvariablen [tax] ab, die den Typ [ITax] hat ([switch] -Ausdruck mit Zieltyp). Der Rest des Programms kennt nur die Schnittstelle [ITax] und weiß nicht, woher die Daten stammen;
  • Zeilen 28–34: Das Erzeugen des Objekts kann eine [TaxException] auslösen, die angezeigt wird, bevor das Programm endet. Der Code wird in [ErrorCode] umgewandelt, um im Klartext angezeigt zu werden; die ursprüngliche Ausnahme, falls vorhanden, wird anhand ihres Typs identifiziert (ihre Meldung enthält den vollständigen Dateipfad);
  • Zeilen 37–76: Die Dialogschleife ist exakt dieselbe wie in Version 2.

5.9.6. Ausführungen

Mit der Datei [TaxData.txt], die standardmäßig verwendet wird:

> dotnet run
Tax brackets read from [TaxData.txt]
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: q s d
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 d
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: 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: 

Die Werte der vorherigen Versionen werden reproduziert: 4.282 Euro für ein Ehepaar mit 2 Kindern, 2.959 Euro mit 3 Kindern und 11.519 Euro für eine alleinstehende Person ohne Kinder bei einem Jahresgehalt von 60.000 Euro. Fehlerhafte Eingaben werden wie in Version 2 gemeldet.

Mit der Datei [TaxData.json]:

1
2
3
4
5
6
7
8
9
> dotnet run -- TaxData.json
Tax brackets read from [TaxData.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: 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 einer nicht vorhandenen Datei [xx.txt]:

1
2
3
> dotnet run -- xx.txt
Tax brackets read from [xx.txt]
The following error occurred: [Code=Access, Message=Error while reading the file xx.txt, original exception: FileNotFoundException]

Mit der folgenden Datei [TaxDataInvalid.txt], in der die dritte Zeile ein Dezimalkomma verwendet:

1
2
3
4
4962:0:0
8382:0.068:291.09
14753:0,191:1322,92
23888:0.283:2668.39
1
2
3
> dotnet run -- TaxDataInvalid.txt
Tax brackets read from [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 in Zeile 3 werden abgelehnt: Der Fehlercode ist die Kombination „Field2, Field3“. Feld 1 (14753), das keinen Dezimalteil hat, ist korrekt.

Mit der folgenden Datei [TaxDataInvalid.json], in der ein Koeffizient als Zeichenkette geschrieben ist:

1
2
3
4
[
  { "limit": 4962, "coeffR": 0, "coeffN": 0 },
  { "limit": 8382, "coeffR": "0,068", "coeffN": 291.09 }
]
1
2
3
> dotnet run -- TaxDataInvalid.json
Tax brackets read from [TaxDataInvalid.json]
The following error occurred: [Code=Json, Message=The file TaxDataInvalid.json is incorrect: The JSON value could not be converted to System.Decimal. Path: $[1].coeffR | LineNumber: 2 | BytePositionInLine: 36., original exception: JsonException]

Die Meldung der [JsonException] gibt die genaue Fehlerstelle an: die Eigenschaft [coeffR] des zweiten Elements des Arrays ([$[1].coeffR]), [LineNumber: 2] – das heißt die dritte Zeile des Dokuments, da [System.Text.Json] die Zeilen ab 0 nummeriert.

5.10. Fazit

Dieses Kapitel hat die .NET-Klassen vorgestellt, die in fast allen Programmen verwendet werden:

  • unveränderliche Zeichenketten ([string]) und veränderliche Zeichenketten ([StringBuilder]) zu ihrem stückweisen Aufbau; Interpolation mit Breiten und Formaten, Raw-Strings; Sichten ([ReadOnlySpan<char>]) für kritischen Code;
  • die Arrays und die Klasse [Array];
  • die generischen Sammlungen [List<T>], [Dictionary<TKey,TValue>], [HashSet<T>], [Queue<T>], [Stack<T>], [PriorityQueue<TElement,TPriority>] und ihre schreibgeschützten Schnittstellen; die nicht generischen Sammlungen [ArrayList] und [Hashtable] sind veraltet;
  • LINQ, seine Sequenzen [IEnumerable<T>], seine Iteratoren und seine verzögerte Ausführung;
  • Textdateien ([StreamReader], [StreamWriter], [File]), Binärdateien ([BinaryWriter], [BinaryReader]) und die JSON-Serialisierung, die die binäre Serialisierung von [BinaryFormatter] ersetzt, das aus .NET entfernt wurde;
  • reguläre Ausdrücke, vorzugsweise zur Kompilierzeit generiert und bei der Verarbeitung externer Daten stets durch ein Timeout geschützt.

Die Beispielanwendung liest ihre Daten nun aus einer Textdatei oder aus JSON. Das folgende Kapitel gliedert sie in Schichten um: Das Lesen der Daten, die Steuerberechnung und die Benutzerinteraktion werden zu unabhängigen Komponenten.