Was ist neu in C# 14.0?

C# 14.0 wird als Nachfolger von C# 13.0 zusammen mit .NET 10.0 am 11. November 2025 erschienen.

C# 14.0 wird offiziell von Microsoft erst ab .NET 10.0 unterstützt. Einige Sprachfeatures funktionieren aber auch in älteren .NET-Versionen, einschließlich .NET Framework, wenn man <langversion>latest</langversion> oder <langversion>preview</langversion> in die Projektdatei einträgt.

Roadmap: https://github.com/dotnet/roslyn/blob/main/docs/Language%20Feature%20Status.md

Neuerungen in C# 14.0 in Preview 1 und 2

• Extension Members: Erweitern von Klassen um statische Methoden und Properties (auf Instanzebene und statisch)
• Null-Conditional Assignment: obj?.Property = wert;
• Vereinfachung für nameof() mit generischen Typen
• Vereinfachungen bei Lambda-Ausdrücken
• Mehr Konvertierungen für Span<T> und ReadOnlySpan<T>
• Schlüsselwort field
• Partielle Konstruktoren und partielle Events

Extensions-Blöcke in C# 14.0

Die nachträgliche Erweiterbarkeit von Typen, auch wenn dies bereits anderenorts kompiliert sind (z.B. in den von Microsoft gelieferten Klassen in der .NET-Klassenbibliotheken), um zusätzliche Methoden gibt es unter dem Namen "Extension Methods" seit C#-Sprachversion 3.0, die zusammen mit .NET Framework 3.5 im Jahr 2007 erschienen ist. Man konnte dabei aber nur Instanzmethoden ergänzen. So musste man zwangsweise Konstrukte, die vom Namen her Properties waren als Methoden ausdrücken, siehe IsEmptyClassic() in Listing 1

Listing 1: Klassische Extension Methods
public static class StringExtensionClassic
{
public static string TruncateClassic(this string s, int count)
{
if (s == null) return "";
if (s.Length <= count) return s;
return s.Substring(0, count) + "...";
}

public static bool IsEmptyClassic(this string s)
=> String.IsNullOrEmpty(s);
}

In C# 14.0 gibt es nun mit dem neuen Block-Schlüsselwort extension eine verallgemeinerte Möglichkeit der Erweiterung bestehender Klassen. Das Schlüsselwort extension muss Teil einer statischen, nicht-generischen Klasse auf der obersten Ebene sein (also keine Nested Class). Nach dem Schlüsselwort extension deklariert man den zu erweiternden Typ, in Listing 2 die Klasse System.String (alternativ abgekürzt durch den eingebauten Typ string). Alle Methoden und Properties innerhalb des Extension-Blocks erweitern dann diesen Typen. Aktuell kann man in diesen Blöcken folgende Konstrukte verwenden:

• Instanz-Methoden
• Statische Methoden
• Instanz-Properties mit Getter
• Statische Properties mit Getter

Beim Versuch, einem Property einen Setter zu geben, meckert der Compiler leider mit der unzutreffenden Meldung "Extension declarations can include only methods or properties"

Listing 2: Extension für System.String mit C# 14.0
public static class StringExtension
{
extension(System.String s)
{

// Erweitern um eine Instanz-Methode
public string Truncate(int count)
{
if (s == null) return "";
if (s.Length <= count) return s;
return s.Substring(0, count) + string.Dots;
}
// Erweitern um eine Instanz-Eigenschaft
public bool IsEmpty => String.IsNullOrEmpty(s);

// Erweitern um eine statische Methode
public static string Create(int count, char c = '.')
{
return new string(c, count);
}

// Erweitern um eine statische Instanz-Eigenschaft
public static string Dots => "...";

}
}

Listing 3 zeigt den Aufruf der alten und neuen Erweiterungen. Entwicklerinnen und Entwickler haben die Wahl, für Extension Methods für alte oder die neue Syntax zu verwenden. Visual Studio wird Refactoring-Methoden zur Umwandlung zwischen beiden Syntaxformen anbieten. Zudem plant Microsoft in kommenden Preview-Versionen weitere Konstrukte in Extension-Blocks zu erlauben, z.B. Konstruktoren. Die in Syntax für Extension, die Microsoft für C# 13.0 in Arbeit hatte (public implicit extension Name for Typ) wurde verworfen.

Listing 3: Aufruf der Erweiterungen in Listing 1 und 2
public class StringExtensionDemo
{
public void Run()
{
string s1old = "Hello World";
string s1oldtruncated = s1old.TruncateClassic(5);
Console.WriteLine(s1oldtruncated); // Hello...
string s2old = null;
Console.WriteLine(s2old.IsEmptyClassic()); // true

string s1 = "Hello World";
string s1truncated = s1.Truncate(5);
Console.WriteLine(s1truncated); // Hello...

string s2 = null;
Console.WriteLine(s2.IsEmpty); // true

string s3 = string.Create(5, '#');
Console.WriteLine(s3); // "#####"
}
}

Null-Conditional Assignment in C# 14.0

Ein weiteres sehr hilfreiches neues Sprachkonstrukt in C# 14.0 nennt Microsoft Null-Conditional Assignment. Damit können Entwicklerinnen und Entwickler eine Zuweisung an ein Property machen ohne vorher zu prüfen, ob das Objekt null ist. Anstelle von

Website aktuelleDOTNETWebsite = Website.Load(123);
if (aktuelleDOTNETWebsite!= null)
{
// Aktualisieren der URL
aktuelleDOTNETWebsite.Url = "https://www.dotnet10.de";
}

Darf man nun verkürzt schreiben

aktuelleDOTNETWebsite?.Url = "https://www.dotnet10.de";

Dies führt zur Laufzeit zu keinem Fehler. Allerdings passiert auch nichts, wenn die Variable aktuelleDOTNETWebsite den Wert null hat.

Vereinfachungen bei Lambda-Ausdrücken

In Lambda-Ausdrücken kann man in C# 14.0 jetzt Parameter-Modifizierer wie scoped, ref, in, out und ref readonly verwenden, ohne dabei den Datentyp benennen zu müssen.

Beispiel: Für den Delegate
delegate bool Extract<T>(string text, out T result);
musste vor C# 14.0 schreiben:
Extract<int> ExtractOld = (string text, out int result) => Int32.TryParse(text, out result);
Jetzt in C# 14.0 können Entwicklerinnen und Entwickler im Lambda-Ausdruck die Nennung der Datentypen string und int weglassen, weil diese Datentypen aus dem Kontext bereits klar sind:
Extract<int> ExtractNew = (text, out result) => Int32.TryParse(text, out result);
Das geht allerdings nicht, wenn ein variadischer Parameter mit params zum Einsatz kommt:
Add<int> AddOld = (out int result, params List<int> data) => { result = data.Sum(); return true; };
Nicht möglich ist also diese Verkürzung:
Add<int> AddNew = (out result, params data) => { result = data.Sum(); return true; };

Vereinfachung für nameof() mit generischen Typen

Bisher musste man in C# immer konkrete Typparameter angeben, um den Operator nameof() auf generische Typen anzuwenden. Jetzt, in C# 14.0, kann man als kleine Syntaxvereinfachung auch die Typparameter im Code weglassen.

// BISHER
Console.WriteLine(nameof(List<int>)); // --> List
Console.WriteLine(nameof(System.Collections.Generic.LinkedListNode<int>)); // --> LinkedListNode
Console.WriteLine(nameof(System.Collections.Generic.KeyValuePair<int, string>)); // --> KeyValuePair

// NEU
Console.WriteLine(nameof(List<>)); // --> List
Console.WriteLine(nameof(System.Collections.Generic.LinkedListNode<>)); // --> LinkedListNode
Console.WriteLine(nameof(System.Collections.Generic.KeyValuePair<,>)); // --> KeyValuePair

Schlüsselwort field

Im Dokument "What's new in C# 14" https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-14 beschreibt Microsoft zudem das Schlüsselwort field, mit dem man sogenannte "Semi-Auto-Properties" erstellen kann. Auch dieses Sprachfeature gibt es allerdings auch schon in der stabilen Version von .NET 9.0 – darin aber im Status "Preview", d.h. man musste auch dafür schon <LangVersion>preview</LangVersion> setzen. Die Erwähnung in "What's new in C# 14" legt die Vermutung nahe, dass das Sprachfeature in C# 14.0 dann als stabil gelten wird.

Listing: Beispiel für ein Semi-Auto-Property mit dem Schlüsselwort field, das automatisch ein Field für das Property anlegt
/// <summary>
/// Semi-Auto Property
/// </summary>
public int ID
{
get;
set // init wäre hier auch erlaubt!
{
if (value < 0) throw new ArgumentOutOfRangeException();
if (field > 0) throw new ApplicationException("ID schon gesetzt");
field = value;
}
} = -1;

Weitere Informationen finden Sie in diesen Beiträgen:

.NET 10.0