From 164f956c01a454a17a121bea18749024278eeef0 Mon Sep 17 00:00:00 2001 From: "jonas@geiger-natur.de" Date: Sun, 28 Sep 2025 17:52:30 +0200 Subject: [PATCH] version 4.0 - 13.0 (AI generated) --- README.md | 16 +++++++ Version10.0/README.md | 87 ++++++++++++++++++++++++++++++++++ Version11.0/README.md | 95 +++++++++++++++++++++++++++++++++++++ Version12.0/README.md | 74 +++++++++++++++++++++++++++++ Version13.0/README.md | 65 +++++++++++++++++++++++++ Version4.0/README.md | 40 ++++++++++++++++ Version5.0/README.md | 33 +++++++++++++ Version6.0/README.md | 69 +++++++++++++++++++++++++++ Version7.0/README.md | 72 ++++++++++++++++++++++++++++ Version7.1/README.md | 49 +++++++++++++++++++ Version7.2/README.md | 98 ++++++++++++++++++++++++++++++++++++++ Version7.3/README.md | 48 +++++++++++++++++++ Version8.0/README.md | 107 ++++++++++++++++++++++++++++++++++++++++++ Version9.0/README.md | 74 +++++++++++++++++++++++++++++ 14 files changed, 927 insertions(+) create mode 100644 Version10.0/README.md create mode 100644 Version11.0/README.md create mode 100644 Version12.0/README.md create mode 100644 Version13.0/README.md create mode 100644 Version4.0/README.md create mode 100644 Version5.0/README.md create mode 100644 Version6.0/README.md create mode 100644 Version7.0/README.md create mode 100644 Version7.1/README.md create mode 100644 Version7.2/README.md create mode 100644 Version7.3/README.md create mode 100644 Version8.0/README.md create mode 100644 Version9.0/README.md diff --git a/README.md b/README.md index 92b7b4d..2f9b734 100644 --- a/README.md +++ b/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) \ No newline at end of file diff --git a/Version10.0/README.md b/Version10.0/README.md new file mode 100644 index 0000000..f0162a8 --- /dev/null +++ b/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 quad = x => x * x; +[Obsolete] Func 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 `preview`) +- Generische Attribute +- Statische abstrakte Member in Schnittstellen + +--- + +C# 10.0 bringt viele Verbesserungen für kompakteren, präziseren und leistungsfähigeren Code. \ No newline at end of file diff --git a/Version11.0/README.md b/Version11.0/README.md new file mode 100644 index 0000000..41cc097 --- /dev/null +++ b/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 a, T b) where T : INumber => a + b; +``` + +### Generische Attribute +Attribute können generisch sein. + +```csharp +[MyAttribute] +public class Beispiel { } +``` + +### UTF-8-Zeichenfolgenliterale +Direkte UTF-8-Strings. + +```csharp +ReadOnlySpan 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 für string +Vergleich von `Span` 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. \ No newline at end of file diff --git a/Version12.0/README.md b/Version12.0/README.md new file mode 100644 index 0000000..eb99744 --- /dev/null +++ b/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 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. \ No newline at end of file diff --git a/Version13.0/README.md b/Version13.0/README.md new file mode 100644 index 0000000..34d00e1 --- /dev/null +++ b/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` und Schnittstellentypen erlaubt. + +```csharp +void PrintAll(params Span 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. \ No newline at end of file diff --git a/Version4.0/README.md b/Version4.0/README.md new file mode 100644 index 0000000..45c1abb --- /dev/null +++ b/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 strings = new List(); +IEnumerable 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. \ No newline at end of file diff --git a/Version5.0/README.md b/Version5.0/README.md new file mode 100644 index 0000000..b252e15 --- /dev/null +++ b/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 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. \ No newline at end of file diff --git a/Version6.0/README.md b/Version6.0/README.md new file mode 100644 index 0000000..126b0e9 --- /dev/null +++ b/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. \ No newline at end of file diff --git a/Version7.0/README.md b/Version7.0/README.md new file mode 100644 index 0000000..2ef0e23 --- /dev/null +++ b/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. \ No newline at end of file diff --git a/Version7.1/README.md b/Version7.1/README.md new file mode 100644 index 0000000..65b8c2d --- /dev/null +++ b/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 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. \ No newline at end of file diff --git a/Version7.2/README.md b/Version7.2/README.md new file mode 100644 index 0000000..23665c4 --- /dev/null +++ b/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 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. \ No newline at end of file diff --git a/Version7.3/README.md b/Version7.3/README.md new file mode 100644 index 0000000..4819e7e --- /dev/null +++ b/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. \ No newline at end of file diff --git a/Version8.0/README.md b/Version8.0/README.md new file mode 100644 index 0000000..dcba133 --- /dev/null +++ b/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 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. \ No newline at end of file diff --git a/Version9.0/README.md b/Version9.0/README.md new file mode 100644 index 0000000..a83c559 --- /dev/null +++ b/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* 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 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. \ No newline at end of file