version 4.0 - 13.0 (AI generated)

README.md

@@ -11,3 +11,19 @@ Die Geschichte von C#
 ## [Version 2.0](Version2.0/README.md)
 
 ## [Version 3.0](Version3.0/README.md)
+
+## [Version 4.0](Version4.0/README.md)
+
+## [Version 5.0](Version5.0/README.md)
+
+## [Version 6.0](Version6.0/README.md)
+
+## [Version 7.0](Version7.0/README.md)
+
+## [Version 8.0](Version8.0/README.md)
+
+## [Version 9.0](Version9.0/README.md)
+
+## [Version 10.0](Version10.0/README.md)
+
+## [Version 11.0](Version11.0/README.md)

Version10.0/README.md

@@ -0,0 +1,87 @@
+# C# Version 10.0
+
+Veröffentlicht im November 2021 mit .NET 6.
+
+## Neue Features
+
+### Datensatzstrukturen
+Records können jetzt auch als Strukturen (`record struct`) definiert werden.
+
+```csharp
+public record struct Punkt(int X, int Y);
+```
+
+### Verbesserungen von Strukturtypen
+Strukturen und anonyme Typen unterstützen jetzt `with`-Ausdrücke.
+
+```csharp
+var p1 = new Punkt(1, 2);
+var p2 = p1 with { X = 3 };
+```
+
+### Handler für interpolierte Zeichenfolgen
+Optimierte Verarbeitung von interpolierten Strings für bessere Performance.
+
+```csharp
+Console.WriteLine($"Wert: {wert}");
+```
+
+### global using-Direktiven
+Globale `using`-Anweisungen für das gesamte Projekt.
+
+```csharp
+// global using System;
+```
+
+### Dateibezogene Namespacedeklaration
+Einfachere Namespace-Deklaration am Dateianfang.
+
+```csharp
+namespace MeinProjekt;
+```
+
+### Erweiterte Eigenschaftenmuster
+Präzisere Muster für Eigenschaften.
+
+```csharp
+if (person is { Adresse.Stadt: "Berlin" }) { /* ... */ }
+```
+
+### Verbesserungen bei Lambda-Ausdrücken
+- Natürlicher Typ für Lambdas
+- Rückgabetyp deklarierbar
+- Attribute auf Lambdas möglich
+
+```csharp
+Func<int, int> quad = x => x * x;
+[Obsolete] Func<int, int> alt = x => x + 1;
+```
+
+### Zeichenfolgeninterpolation für const-Strings
+Konstante Strings können interpoliert werden, wenn alle Platzhalter konstant sind.
+
+```csharp
+const string Name = "Jonas";
+const string Begruessung = $"Hallo, {Name}!";
+```
+
+### sealed ToString in records
+`ToString` kann in record-Typen als `sealed` überschrieben werden.
+
+### Verbesserte Warnungen für Null-Status und Zuweisungen
+
+### Dekonstruktion: Zuweisung und Deklaration gleichzeitig möglich
+
+### AsyncMethodBuilder-Attribut für Methoden
+
+### CallerArgumentExpression-Attribut
+
+### Neues Format für #line-Pragma
+
+### Vorschaufeatures (nur mit `<LangVersion>preview</LangVersion>`)
+- Generische Attribute
+- Statische abstrakte Member in Schnittstellen
+
+---
+
+C# 10.0 bringt viele Verbesserungen für kompakteren, präziseren und leistungsfähigeren Code.

Version11.0/README.md

@@ -0,0 +1,95 @@
+# C# Version 11.0
+
+Veröffentlicht im November 2022.
+
+## Neue Features
+
+### Unformatierte Zeichenfolgenliterale
+Mehrzeilige Strings ohne Escape-Zeichen.
+
+```csharp
+string text = """
+    Zeile 1
+    Zeile 2
+    """;
+```
+
+### Generische Mathematik
+Numerische Algorithmen können für alle Zahlentypen geschrieben werden.
+
+```csharp
+static T Add<T>(T a, T b) where T : INumber<T> => a + b;
+```
+
+### Generische Attribute
+Attribute können generisch sein.
+
+```csharp
+[MyAttribute<int>]
+public class Beispiel { }
+```
+
+### UTF-8-Zeichenfolgenliterale
+Direkte UTF-8-Strings.
+
+```csharp
+ReadOnlySpan<byte> utf8 = "Hallo"u8;
+```
+
+### Zeilenvorschübe in Zeichenfolgeninterpolation
+Zeilenumbrüche sind in interpolierten Strings erlaubt.
+
+```csharp
+string info = $"Name: {name}
+Alter: {alter}";
+```
+
+### Listenmuster
+Vergleich von Listenstrukturen mit Mustern.
+
+```csharp
+if (arr is [1, 2, ..])
+{
+    // Beginnt mit 1, 2
+}
+```
+
+### Dateilokale Typen
+Typen können nur innerhalb einer Datei sichtbar sein.
+
+```csharp
+file class Helper { }
+```
+
+### Erforderliche Member
+Member müssen beim Initialisieren gesetzt werden.
+
+```csharp
+public class Person
+{
+    public required string Name { get; set; }
+}
+```
+
+### Automatische Standardstrukturen
+Strukturen erhalten automatisch einen Standardwert.
+
+### Musterabgleich Span<char> für string
+Vergleich von `Span<char>` mit konstanten Strings.
+
+### Erweiterter nameof-Bereich
+`nameof` kann in mehr Kontexten verwendet werden.
+
+### Numerisches IntPtr
+`IntPtr` unterstützt numerische Operationen.
+
+### ref-Felder und scoped ref
+Mehr Kontrolle über Referenzen und Lebensdauer.
+
+### Verbesserte Methodengruppenkonvertierung zu Delegaten
+
+### Warnungswelle 7
+
+---
+
+C# 11.0 bringt viele Features für moderne, sichere und flexible Programmierung.

Version12.0/README.md

@@ -0,0 +1,74 @@
+# C# Version 12.0
+
+Veröffentlicht im November 2023.
+
+## Neue Features
+
+### Primäre Konstruktoren
+Erstellen Sie Konstruktoren direkt in der Klassen- oder Strukturdefinition.
+
+```csharp
+public class Person(string name, int alter)
+{
+    public string Name { get; } = name;
+    public int Alter { get; } = alter;
+}
+```
+
+### Sammlungsausdrücke
+Neue Syntax für die Erstellung und Erweiterung von Sammlungen.
+
+```csharp
+int[] zahlen = [1, 2, 3];
+int[] mehrZahlen = [..zahlen, 4, 5];
+```
+
+### Inlinearrays
+Arrays mit fester Größe direkt in einem `struct`.
+
+```csharp
+public struct Buffer
+{
+    private inline int[8] data;
+}
+```
+
+### Optionale Parameter in Lambdaausdrücken
+Lambda-Parameter können Standardwerte haben.
+
+```csharp
+Func<int, int, int> addiere = (a, b = 1) => a + b;
+```
+
+### ref readonly-Parameter
+Mehr Klarheit für APIs mit `ref`- oder `in`-Parametern.
+
+```csharp
+void Print(ref readonly int x)
+{
+    Console.WriteLine(x);
+}
+```
+
+### Alias eines beliebigen Typs
+`using` kann für jeden Typ als Alias verwendet werden.
+
+```csharp
+using Ganzzahl = System.Int32;
+Ganzzahl x = 5;
+```
+
+### Experimentattribute
+Kennzeichnen Sie experimentelle Features.
+
+```csharp
+[Experimental]
+void NeueFunktion() { }
+```
+
+### Interceptors (Preview)
+Erlauben das Abfangen und Modifizieren von Methodenaufrufen (nur als Preview verfügbar).
+
+---
+
+C# 12.0 bringt neue Syntax und Features für produktiveren und konsistenteren Code.

Version13.0/README.md

@@ -0,0 +1,65 @@
+# C# Version 13.0
+
+Freigegeben im November 2024.
+
+## Neue Features
+
+### params Collections
+Der `params`-Modifikator ist jetzt für beliebige Sammlungen wie `Span<T>` und Schnittstellentypen erlaubt.
+
+```csharp
+void PrintAll(params Span<int> zahlen) { /* ... */ }
+```
+
+### Neuer lock-Typ und Semantik
+`lock` unterstützt jetzt `System.Threading.Lock` mit exklusivem Bereich und Dispose-Muster.
+
+```csharp
+lock (meinLock)
+{
+    // exklusiver Bereich
+}
+```
+
+### Neue Escape-Sequenz: `\e`
+Das Escape-Zeichen (Unicode U+001B) kann als `\e` verwendet werden.
+
+```csharp
+char esc = '\e';
+```
+
+### Optimierungen bei Methodengruppen-Überlastauflösung
+
+### Impliziter Indexerzugriff in Objektinitialisierern
+Der Indexoperator `^` ist jetzt in Objektinitialisierungen erlaubt.
+
+```csharp
+var arr = new int[] { 1, 2, 3, 4 };
+var obj = new MyClass { Werte = { [^1] = 99 } };
+```
+
+### ref in Iteratoren und asynchronen Methoden
+`ref` kann in nativen und unsicheren Kontexten in Iteratoren und async-Methoden verwendet werden.
+
+### ref struct-Typen implementieren Schnittstellen
+`ref struct`-Typen können Schnittstellen implementieren.
+
+```csharp
+ref struct Buffer : IBuffer { /* ... */ }
+```
+
+### ref struct als Typargument in Generika
+`ref struct`-Typen sind als Typargumente für Generika erlaubt.
+
+### Partielle Eigenschaften und Indexer
+Teilweise deklarierte Eigenschaften und Indexer sind in `partial`-Typen möglich.
+
+### Überlastauflösung mit Priorität
+Bibliotheksautoren können Überladungen als bevorzugt kennzeichnen.
+
+### Vorschau: `field`-Schlüsselwort
+Das kontextbezogene Schlüsselwort `field` erlaubt Zugriff auf das Backing-Feld einer automatisch implementierten Eigenschaft.
+
+---
+
+C# 13.0 bringt neue Möglichkeiten für Sammlungen, Locking, Typen und Initialisierungen sowie weitere Optimierungen.

Version4.0/README.md

@@ -0,0 +1,40 @@
+# C# Version 4.0
+
+C# 4.0 wurde mit Visual Studio 2010 veröffentlicht und brachte folgende Neuerungen:
+
+## Dynamische Bindung (`dynamic`)
+Das `dynamic`-Schlüsselwort erlaubt es, den Typ einer Variable erst zur Laufzeit festzulegen. Dies ähnelt dynamisch typisierten Sprachen wie JavaScript.
+
+```csharp
+dynamic x = "Hallo";
+Console.WriteLine(x.Length); // Funktioniert, da x zur Laufzeit ein string ist
+```
+
+## Benannte und optionale Argumente
+Methodenparameter können beim Aufruf benannt und/oder weggelassen werden. Das vereinfacht Methodenüberladungen und erhöht die Flexibilität.
+
+```csharp
+void Print(string text, int times = 1)
+{
+    for (int i = 0; i < times; i++)
+        Console.WriteLine(text);
+}
+
+Print("Hi", times: 3); // Benannter Parameter
+Print("Hallo");        // Optionaler Parameter
+```
+
+## Generische Kovarianz und Kontravarianz
+Erlaubt mehr Flexibilität beim Arbeiten mit Generics, besonders für Framework- und Bibliotheksautoren.
+
+```csharp
+IEnumerable<string> strings = new List<string>();
+IEnumerable<object> objects = strings; // Kovarianz
+```
+
+## Eingebettete Interop-Typen
+Vereinfacht die Bereitstellung von COM-Interopassemblys durch das Einbetten der benötigten Typen direkt in die Anwendung.
+
+---
+
+Das wichtigste Feature war die Einführung von `dynamic`, das mächtige, aber auch fehleranfällige Konstrukte ermöglicht.

Version5.0/README.md

@@ -0,0 +1,33 @@
+# C# Version 5.0
+
+Veröffentlicht im August 2012 mit Visual Studio 2012.
+
+## Neue Features
+
+### Asynchrone Member (`async` und `await`)
+Ermöglichen die einfache und übersichtliche asynchrone Programmierung.
+
+```csharp
+public async Task<int> GetDataAsync()
+{
+    await Task.Delay(1000);
+    return 42;
+}
+```
+
+### CallerInfo-Attribute
+Erlauben den Zugriff auf Informationen über den Aufrufer einer Methode, z.B. Dateiname, Methodenname oder Zeilennummer.
+
+```csharp
+void Log(string message,
+    [CallerMemberName] string memberName = "",
+    [CallerFilePath] string filePath = "",
+    [CallerLineNumber] int lineNumber = 0)
+{
+    Console.WriteLine($"{message} in {memberName} ({filePath}:{lineNumber})");
+}
+```
+
+---
+
+Das Highlight dieser Version sind die Schlüsselwörter `async` und `await`, die Asynchronität zum festen Bestandteil der Sprache machen.

Version6.0/README.md

@@ -0,0 +1,69 @@
+# C# Version 6.0
+
+Veröffentlicht im Juli 2015 mit Visual Studio 2015.
+
+## Neue Features
+
+### Statische Importe
+Erlaubt das direkte Verwenden von statischen Methoden ohne Klassennamen.
+
+```csharp
+using static System.Console;
+WriteLine("Hallo Welt!");
+```
+
+### Ausnahmefilter
+Ermöglicht das Filtern von Exceptions mit Bedingungen.
+
+```csharp
+try { /* ... */ }
+catch (Exception ex) when (ex.Message.Contains("kritisch"))
+{
+    // Nur bei bestimmten Fehlern
+}
+```
+
+### Initialisierer für automatische Eigenschaften
+Automatische Eigenschaften können direkt initialisiert werden.
+
+```csharp
+public int Zahl { get; set; } = 42;
+```
+
+### Ausdruckskörpermember
+Kürzere Syntax für Methoden und Eigenschaften.
+
+```csharp
+public int Quadrat(int x) => x * x;
+```
+
+### Nullpropagator
+Vereinfacht den Umgang mit null-Werten.
+
+```csharp
+int? länge = text?.Length;
+```
+
+### Zeichenfolgeninterpolation
+Einfaches Einfügen von Variablen in Strings.
+
+```csharp
+string name = "Jonas";
+string begruessung = $"Hallo, {name}!";
+```
+
+### `nameof`-Operator
+Gibt den Namen eines Symbols als String zurück.
+
+```csharp
+Console.WriteLine(nameof(name)); // "name"
+```
+
+### Weitere Features
+- Indexinitialisierer
+- `await` in `catch`- und `finally`-Blöcken
+- Standardwerte für Getter-exklusive Eigenschaften
+
+---
+
+C# 6.0 machte den Code kompakter und lesbarer. Außerdem wurde der Roslyn-Compiler als Dienst veröffentlicht, der nun selbst in C# geschrieben ist.

Version7.0/README.md

@@ -0,0 +1,72 @@
+# C# Version 7.0
+
+Veröffentlicht im März 2017 mit Visual Studio 2017.
+
+## Neue Features
+
+### Out-Variablen
+Direkte Deklaration von Variablen im `out`-Parameter.
+
+```csharp
+if (int.TryParse("123", out int zahl))
+{
+    Console.WriteLine(zahl);
+}
+```
+
+### Tupel und Dekonstruktionen
+Mehrere Werte einfach zurückgeben und zerlegen.
+
+```csharp
+(string Name, int Alter) GetPerson() => ("Jonas", 30);
+var (name, alter) = GetPerson();
+```
+
+### Mustervergleich
+Vergleiche mit Mustern für mehr Lesbarkeit.
+
+```csharp
+if (obj is string s)
+{
+    Console.WriteLine($"String: {s}");
+}
+```
+
+### Lokale Funktionen
+Funktionen innerhalb von Methoden definieren.
+
+```csharp
+void Hauptfunktion()
+{
+    int Addiere(int a, int b) => a + b;
+    Console.WriteLine(Addiere(2, 3));
+}
+```
+
+### Erweiterte Ausdruckskörpermember
+Mehr Möglichkeiten für kurze Methoden und Eigenschaften.
+
+```csharp
+public int Quadrat(int x) => x * x;
+```
+
+### Lokale ref-Variablen und Ref-Rückgaben
+Direkter Zugriff und Rückgabe von Referenzen.
+
+```csharp
+ref int Suche(int[] arr, int wert)
+{
+    for (int i = 0; i < arr.Length; i++)
+        if (arr[i] == wert) return ref arr[i];
+    throw new Exception("Nicht gefunden");
+}
+```
+
+### Weitere Features
+- Verwerfen mit `_`
+- Binäre Literale (`0b1010`) und Zahlentrennzeichen (`1_000_000`)
+- Throw-Ausdrücke (`throw new Exception()` direkt in Ausdrücken)
+
+---
+
+Diese Features machen den Code noch kompakter und lesbarer. .NET Core unterstützt nun alle Betriebssysteme und fokussiert sich auf Cloud und Portabilität.

Version7.1/README.md

@@ -0,0 +1,49 @@
+# C# Version 7.1
+
+Veröffentlicht im August 2017.
+
+Mit C# 7.1 wurden Punktreleases eingeführt. Diese Version brachte ein Konfigurationselement zur Auswahl der Sprachversion, drei neue Sprachfeatures und neues Compilerverhalten.
+
+## Neue Features
+
+### async Main-Methode
+Der Einstiegspunkt einer Anwendung kann jetzt `async` sein.
+
+```csharp
+static async Task Main(string[] args)
+{
+    await Task.Delay(1000);
+    Console.WriteLine("Async Main!");
+}
+```
+
+### default-Literale Ausdrücke
+Sie können `default` als Wert verwenden, wenn der Zieltyp bekannt ist.
+
+```csharp
+int x = default;
+MyClass obj = default;
+```
+
+### Abgeleitete Tupelelementnamen
+Tupelelementnamen werden aus der Initialisierung abgeleitet.
+
+```csharp
+var name = "Jonas";
+var alter = 30;
+var person = (name, alter); // person.name, person.alter
+```
+
+### Musterabgleich für generische Typparameter
+Musterabgleich funktioniert jetzt auch mit generischen Typen.
+
+```csharp
+bool IstString<T>(T value) => value is string;
+```
+
+### Compileroptionen
+Neue Optionen `-refout` und `-refonly` zur Steuerung der Referenzassembly-Generierung.
+
+---
+
+C# 7.1 brachte kleine, aber nützliche Verbesserungen für moderne und flexible Programmierung.

Version7.2/README.md

@@ -0,0 +1,98 @@
+# C# Version 7.2
+
+Veröffentlicht im November 2017.
+
+Mit C# 7.2 wurden einige kleine, aber nützliche Sprachfeatures hinzugefügt:
+
+## Neue Features
+
+### Initialisierer für stackalloc-Arrays
+Direkte Initialisierung von Arrays auf dem Stack.
+
+```csharp
+Span<int> zahlen = stackalloc int[] { 1, 2, 3 };
+```
+
+### fixed-Anweisung für beliebige Typen
+`fixed` kann mit jedem Typ verwendet werden, der ein Muster unterstützt.
+
+### Zugriff auf feste Felder ohne Anheften
+Erlaubt den Zugriff auf Felder, ohne sie explizit zu fixieren.
+
+### Neuzuweisung lokaler ref-Variablen
+Ref-Variablen können neu zugewiesen werden.
+
+```csharp
+ref int r = ref arr[0];
+r = ref arr[1];
+```
+
+### readonly struct-Typen
+Strukturen können als unveränderlich deklariert werden.
+
+```csharp
+public readonly struct Punkt
+{
+    public int X { get; }
+    public int Y { get; }
+}
+```
+
+### in-Parameter
+Argumente werden als Referenz übergeben, aber nicht verändert.
+
+```csharp
+void Print(in int x)
+{
+    Console.WriteLine(x);
+}
+```
+
+### ref readonly-Rückgaben
+Methoden können einen Wert als Referenz zurückgeben, ohne Schreibzugriff zu erlauben.
+
+```csharp
+public ref readonly int GetValue() => ref value;
+```
+
+### ref struct-Typen
+Strukturen, die direkt auf verwalteten Speicher zugreifen und nur auf dem Stack liegen dürfen.
+
+```csharp
+ref struct Buffer { /* ... */ }
+```
+
+### Allgemeinere Beschränkungen
+Mehr Flexibilität bei Generics.
+
+### Nicht schließende benannte Argumente
+Positionale Argumente können auf benannte Argumente folgen.
+
+```csharp
+Print("Hallo", times: 3);
+```
+
+### Führende Unterstriche in numerischen Literalen
+Numerische Literale dürfen mit Unterstrichen beginnen.
+
+```csharp
+int zahl = _1_000_000;
+```
+
+### private protected-Zugriffsmodifizierer
+Zugriff für abgeleitete Klassen innerhalb derselben Assembly.
+
+```csharp
+private protected int Wert;
+```
+
+### Bedingte ref-Ausdrücke
+Das Ergebnis eines bedingten Ausdrucks kann ein Verweis sein.
+
+```csharp
+ref int r = ref (a > b ? ref x : ref y);
+```
+
+---
+
+C# 7.2 brachte viele kleine Verbesserungen für Performance, Lesbarkeit und Sicherheit.

Version7.3/README.md

@@ -0,0 +1,48 @@
+# C# Version 7.3
+
+Veröffentlicht im Mai 2018.
+
+C# 7.3 bringt zwei Hauptdesigns: bessere Performance für sicheren Code und inkrementelle Verbesserungen vorhandener Features. Es wurden auch neue Compileroptionen hinzugefügt.
+
+## Neue Features für sicheren Code
+
+- Zugriff auf feste Felder ohne Anheften
+- Neuzuweisung lokaler ref-Variablen
+- Initialisierer für stackalloc-Arrays
+- `fixed`-Anweisungen mit jedem Typ, der ein Muster unterstützt
+- Generischere Einschränkungen bei Generics
+
+## Verbesserungen vorhandener Features
+
+- Vergleich von Tupeltypen mit `==` und `!=`
+
+    ```csharp
+    (int, int) a = (1, 2);
+    (int, int) b = (1, 2);
+    bool gleich = a == b; // true
+    ```
+
+- Ausdrucksvariablen an mehreren Standorten verwenden
+
+    ```csharp
+    if (int.TryParse("123", out int x) || int.TryParse("456", out x))
+        Console.WriteLine(x);
+    ```
+
+- Attribute für Sicherungsfelder von automatisch implementierten Eigenschaften
+
+    ```csharp
+    [field: NonSerialized]
+    public int Wert { get; set; }
+    ```
+
+- Verbesserte Methodenauflösung bei `in`-Parametern und Überladungen
+
+## Neue Compileroptionen
+
+- `-publicsign`: Ermöglicht das Signieren von Assemblys für OSS
+- `-pathmap`: Bietet Zuordnung für Quellverzeichnisse
+
+---
+
+C# 7.3 macht sicheren Code leistungsfähiger und verbessert bestehende Sprachfeatures.

Version8.0/README.md

@@ -0,0 +1,107 @@
+# C# Version 8.0
+
+Veröffentlicht im September 2019.
+
+C# 8.0 ist das erste Hauptrelease, das speziell auf .NET Core ausgerichtet ist. Viele Features benötigen neue CLR-Funktionen oder Bibliothekstypen aus .NET Core 3.0.
+
+## Neue Features
+
+### Readonly-Member
+Mit `readonly` können Member als unveränderlich markiert werden.
+
+```csharp
+readonly struct Punkt
+{
+    public int X { get; }
+    public int Y { get; }
+    public readonly int Abstand() => X * X + Y * Y;
+}
+```
+
+### Standardschnittstellenmethoden
+Interfaces können nun Implementierungen für Methoden enthalten.
+
+```csharp
+public interface IBeispiel
+{
+    void Methode() => Console.WriteLine("Standardimplementierung");
+}
+```
+
+### Verbesserungen am Musterabgleich
+
+- **Switch-Ausdrücke**
+
+    ```csharp
+    string ergebnis = wert switch
+    {
+        1 => "eins",
+        2 => "zwei",
+        _ => "anderes"
+    };
+    ```
+
+- **Eigenschafts-, Tupel- und Positionsmuster**
+
+    ```csharp
+    if (person is { Name: "Jonas", Alter: 30 }) { /* ... */ }
+    if ((x, y) is (0, 0)) { /* Ursprung */ }
+    ```
+
+### using-Deklarationen
+Ressourcen werden automatisch am Ende des Blocks freigegeben.
+
+```csharp
+using var stream = File.OpenRead("datei.txt");
+```
+
+### Statische lokale Funktionen
+Lokale Funktionen können als `static` deklariert werden.
+
+```csharp
+void Methode()
+{
+    static int Add(int a, int b) => a + b;
+}
+```
+
+### Verwerfbare Referenzstrukturen
+Strukturen können `IDisposable` implementieren.
+
+### Nullwerte zulassende Verweistypen
+Erlaubt die explizite Angabe, ob ein Verweistyp `null` sein darf.
+
+```csharp
+string? text = null;
+```
+
+### Asynchrone Streams
+Daten können asynchron gestreamt werden.
+
+```csharp
+async IAsyncEnumerable<int> Zahlen()
+{
+    for (int i = 0; i < 5; i++)
+        yield return i;
+}
+```
+
+### Indizes und Bereiche
+Einfacher Zugriff auf Teile von Arrays und Listen.
+
+```csharp
+int[] zahlen = { 1, 2, 3, 4, 5 };
+int letzter = zahlen[^1]; // 5
+int[] teil = zahlen[1..3]; // {2, 3}
+```
+
+### NULL-Coalescing-Zuweisung
+Weist einen Wert nur zu, wenn die Variable `null` ist.
+
+```csharp
+text ??= "Standardwert";
+```
+
+---
+
+C# 8.0 bringt viele moderne Features, die vor allem mit .NET Core 3.0 optimal genutzt werden können.

Version9.0/README.md

@@ -0,0 +1,74 @@
+# C# Version 9.0
+
+Veröffentlicht im November 2020 mit .NET 5.
+
+## Neue Features
+
+### Datensätze (`record`)
+Kompakte Syntax für unveränderliche Datencontainer mit Wertsemantik.
+
+```csharp
+public record Person(string Name, int Alter);
+var p1 = new Person("Jonas", 30);
+var p2 = p1 with { Alter = 31 };
+```
+
+### init-only-Setter
+Eigenschaften können nur bei der Initialisierung gesetzt werden.
+
+```csharp
+public class Auto
+{
+    public string Marke { get; init; }
+}
+```
+
+### Top-Level-Anweisungen
+Kein `Main`-Methoden- oder Klassen-Wrapper nötig.
+
+```csharp
+Console.WriteLine("Hallo Welt!");
+```
+
+### Verbesserter Musterabgleich
+- **Relationale Muster:** `<`, `>`, `<=`, `>=`
+- **Logische Muster:** `and`, `or`, `not`
+
+```csharp
+if (wert is >= 0 and <= 10) { /* ... */ }
+if (obj is not null) { /* ... */ }
+```
+
+### Integerwerte mit nativer Größe
+`nint` und `nuint` für CPU-native Integer.
+
+```csharp
+nint x = 42;
+```
+
+### Funktionszeiger
+Direkte Zeiger auf Funktionen.
+
+```csharp
+delegate*<int, int, int> addPtr = &Add;
+```
+
+### Modulinitialisierer
+Methoden, die beim Laden einer Assembly ausgeführt werden.
+
+```csharp
+[ModuleInitializer]
+public static void Init() { /* ... */ }
+```
+
+### Weitere Features
+- Zieltypisierte `new`-Ausdrücke: `List<int> zahlen = new();`
+- Anonyme `static`-Funktionen: `static () => 42`
+- Lambda-Parameter verwerfen: `_ => ...`
+- Attribute auf lokale Funktionen
+- Erweiterung von `GetEnumerator()` für `foreach`
+- Partielle Methoden mit Rückgabewert und Zugriffsmodifizierer
+
+---
+
+C# 9.0 bringt viele moderne Features für produktiven, kompakten und sicheren Code.