~/blog/2024/11/dotnet-9-und-csharp-13.md

.NET 9 und C# 13

5 min
Beitragsbild: .NET 9 und C# 13

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

  • .NET 9 erschien am 12. November 2024 als STS-Release mit 18 Monaten Support; .NET 8 bleibt das LTS-Release.
  • C# 13 bringt params mit Collections (etwa params ReadOnlySpan<T>), den Typ System.Threading.Lock, die Escape-Sequenz \e, ref und unsafe in Iteratoren und async-Methoden, allows ref struct und partielle Properties.
  • ASP.NET Core generiert OpenAPI-Dokumente selbst (Microsoft.AspNetCore.OpenApi), Swashbuckle ist aus den Vorlagen verschwunden; dazu kommt HybridCache.
  • Neu sind außerdem .NET Aspire 9 und die LINQ-Methoden CountBy, AggregateBy und Index.
  • Die BinaryFormatter-Implementierung wurde entfernt.

Kaum ein Release-Zyklus der letzten Jahre hat so zuverlässig funktioniert wie der von .NET: Jedes Jahr im November kommt eine neue Version, abwechselnd mit langem und mit kurzem Support. Im Dezember 2023 habe ich über .NET 8 geschrieben, das Langzeit-Release, auf dem bei mir vieles läuft. Jetzt ist .NET 9 da, seit dem 12. November, und die Frage ist wie jedes Jahr: Was davon brauche ich, und was darf warten?

Vorab die Einordnung. .NET 9 ist ein STS-Release (Standard Term Support) mit 18 Monaten Support. .NET 8 bleibt das LTS-Release. Für Anwendungen, die lange laufen sollen und bei denen man nicht jedes Jahr umziehen möchte, bleibt .NET 8 deshalb die vernünftige Basis. Für neue Projekte, die man ohnehin regelmäßig anfasst, ist 9 eine gute Wahl. Ich sehe es als das Release an, auf dem ich ausprobiere, was später im nächsten LTS landet.

C# 13: viele kleine Schritte

C# 13 ist keine Revolution, aber es sind einige Dinge dabei, die den Alltag aufräumen. Das Prägnanteste: params funktioniert nicht mehr nur mit Arrays, sondern mit Collections, auch mit Spans.

static int Summe(params ReadOnlySpan<int> werte)
{
    var summe = 0;
    foreach (var wert in werte)
        summe += wert;
    return summe;
}

var ergebnis = Summe(1, 2, 3);

Der Vorteil: Beim Aufruf muss kein Array auf dem Heap entstehen, der Compiler kann den Platz anders bereitstellen. Für Methoden in heißen Pfaden ist das eine nette Optimierung, für alle anderen zumindest eine Gelegenheit, die Signatur ehrlicher zu machen. Auch IEnumerable<T> und andere Collection-Typen sind möglich, das ist praktisch bei Bibliotheken, die bislang params T[] anboten und dafür Kopien in Kauf nahmen.

Dann der neue Typ System.Threading.Lock. Bisher hat man bei lock irgendein Objekt als Sperre genommen, meist ein privates object. Jetzt gibt es dafür einen eigenen Typ, und der Compiler erkennt ihn:

private readonly Lock _sperre = new();

public void Erhoehen()
{
    lock (_sperre)
    {
        _zaehler++;
    }
}

Die Syntax ändert sich nicht, aber der Typ ist klarer und kann effizienter arbeiten. Ich stelle mir vor, dass es sich bei neuem Code schnell einbürgert, und bei altem würde ich nur dort umstellen, wo ich ohnehin dran bin.

Es gibt außerdem die Escape-Sequenz \e für das ESC-Zeichen, praktisch für Konsolenausgaben mit Farben, bei denen man bisher \u001b geschrieben hat. Iteratoren und async-Methoden dürfen unter bestimmten Bedingungen ref-Variablen und unsafe-Code enthalten, ebenso gibt es allows ref struct als Einschränkung bei Generics, damit Typen wie Span<T> als Typargument zulässig werden. Das sind Themen für Bibliotheksautoren, in der Anwendungsentwicklung begegnet man ihnen eher indirekt. Hinzu kommen partielle Properties, die vor allem für Quellgeneratoren gedacht sind, weil man damit eine Deklaration und eine generierte Implementierung trennen kann.

ASP.NET Core: OpenAPI und Zwischenspeicher

In ASP.NET Core ist die auffälligste Änderung eine, die sich im ersten Moment nach Verlust anfühlt: Swashbuckle ist aus den Projektvorlagen verschwunden. Stattdessen gibt es eine eingebaute Erzeugung von OpenAPI-Dokumenten über das Paket Microsoft.AspNetCore.OpenApi. Die Einbindung ist schlank:

builder.Services.AddOpenApi();

var app = builder.Build();
app.MapOpenApi();

Damit liefert die Anwendung ein OpenAPI-Dokument aus. Eine Oberfläche zum Ausprobieren, wie man sie von Swagger UI kennt, liefert das Paket nicht mit. Wer sie braucht, bindet ein passendes Werkzeug zusätzlich ein. Das ist konsequent, bedeutet aber für Projekte, die bisher auf Swashbuckle gesetzt haben, dass man sich bewusst entscheiden muss. Swashbuckle gibt es weiterhin, es ist nur nicht mehr der Standard der Vorlagen. Ich würde bestehende Projekte nicht zwingend umstellen, sondern bei neuen den eingebauten Weg ausprobieren.

Dazu kommt HybridCache, eine Abstraktion, die lokalen Speicher und verteilten Zwischenspeicher kombiniert und dabei eine Sache gleich mitlöst, die man sonst selbst bauen muss: Wenn viele Anfragen gleichzeitig denselben fehlenden Eintrag wollen, soll der Wert nur einmal berechnet werden. Was man früher mit etwas Sperrcode selbst gebaut hat, wird so zu einer Bibliotheksfunktion. Ich habe es erst angesehen und nicht im Ernst eingesetzt, deshalb ohne Urteil.

Aspire, LINQ und Aufräumen

.NET Aspire ist in Version 9 angekommen. Es ist ein Rahmen, mit dem man verteilte Anwendungen aus mehreren Diensten lokal startet und beobachtet, mit Dashboard für Logs und Traces. Ich sehe den Nutzen vor allem in der Entwicklungsumgebung, wo das Zusammenstecken mehrerer Dienste nervig sein kann. Ob es für den Betrieb etwas taugt, hängt davon ab, wie ein Team seine Bereitstellung organisiert, und dazu habe ich keine belastbaren Erfahrungen.

In LINQ kamen neue Methoden hinzu, die ich sofort gebrauchen kann. CountBy zählt Elemente nach einem Schlüssel, AggregateBy aggregiert nach Schlüssel, und Index liefert Elemente mit ihrer Position:

var woerter = new[] { "Apfel", "Birne", "Kiwi", "Banane" };

foreach (var (laenge, anzahl) in woerter.CountBy(w => w.Length))
    Console.WriteLine($"{laenge}: {anzahl}");

foreach (var (position, wort) in woerter.Index())
    Console.WriteLine($"{position}: {wort}");

Das ersetzt das, was man bisher mit GroupBy(...).Select(g => (g.Key, g.Count())) hingeschrieben hat, und das mit dem Index ersetzt die bekannte Konstruktion mit Select((x, i) => ...). Kleine Dinge, aber man schreibt sie so oft, dass sie sich lohnen.

Auf der Aufräumseite wurde die Implementierung des BinaryFormatter entfernt. Das ist eine Entscheidung, die lange angekündigt war, weil das Verfahren sicherheitstechnisch als problematisch gilt. Wer es in Altcode noch verwendet, bekommt jetzt keinen funktionierenden Ersatz mehr mitgeliefert. Eine Suche im Code nach dem Typ vor dem Umstieg lohnt sich, denn Serialisierung ist so eine Stelle, an der Fehler erst im Betrieb auffallen.

Wie ich vorgehe

Mein Vorgehen ist wenig aufregend. Ich lasse produktive Dienste auf .NET 8, probiere .NET 9 in neuen oder unkritischen Projekten und lese die Hinweise zu Breaking Changes, bevor ich eine Zielversion hochsetze. Der Wechsel selbst geht meist glatt, die Überraschungen sitzen in Paketen und im Verhalten kleiner Details. Ein Test mit der kompletten Pipeline sagt mehr als jede Ankündigung.

Spannend finde ich, in welche Richtung sich die Plattform bewegt: weniger Fremdpakete für Standardaufgaben (OpenAPI, Zwischenspeicher), mehr Unterstützung für effizienten Code, ohne dass man ständig mit Spans jonglieren muss. Das gefällt mir, auch wenn ich nicht jede Neuerung brauche.

Was habt ihr vor: auf 9 gehen oder bei 8 bleiben? Mich würde besonders interessieren, wie ihr mit dem Wegfall von Swashbuckle in den Vorlagen umgeht.

Beitragsbild: Visual-Studio-2022-Icon von Microsoft, gemeinfrei (via Wikimedia Commons; unverändert auf eigenem Hintergrund). Visual Studio ist eine Marke der Microsoft Corporation.

$ whoami
Christian Ackermann

Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.