~/blog/2023/12/dotnet-8-was-sich-lohnt.md

.NET 8: Was sich lohnt

6 min
Beitragsbild: .NET 8: Was sich lohnt

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

  • .NET 8 erschien am 14. November 2023 als LTS mit drei Jahren Support; .NET 6 läuft bis November 2024, .NET 7 bis Mai 2024.
  • C# 12 bringt primäre Konstruktoren für Klassen und Structs, Collection Expressions mit Spread, Standardwerte für Lambda-Parameter und Aliase für beliebige Typen.
  • Native AOT wird erweitert, unter anderem für ASP.NET Core Minimal APIs, mit Einschränkungen.
  • Blazor bekommt statisches Server-Rendering und wählbare Render-Modi; .NET Aspire ist eine Vorschau.
  • Praktisch: TimeProvider, FrozenDictionary, Verbesserungen bei System.Text.Json und Container-Images ohne Root-Benutzer.

Ich gestehe, dass ich bei Release-Notes meist zuerst nach den Dingen suche, die mir Arbeit abnehmen, und erst danach nach den großen Ankündigungen. Bei .NET 8, das am 14. November erschienen ist, fällt diese Suche überraschend ergiebig aus. Nicht jede Neuerung muss man sofort anfassen, aber ein paar davon würde ich nicht aufschieben. Hier meine Auswahl, geordnet danach, wie viel Alltag drinsteckt. Vorweg: Das ist eine persönliche Sicht, keine vollständige Liste. Wer die ganze Palette sehen will, findet sie in den offiziellen Hinweisen zum Release, und die sind lang. Mir geht es eher darum, wo ich beim Umstellen zuerst hinsehen würde und was ich bewusst liegen lasse, bis es sich gesetzt hat.

Erst die Lage: LTS und Zeitplan

.NET 8 ist ein LTS-Release mit drei Jahren Support. Die Daten, die für die Planung zählen: .NET 6, ebenfalls LTS, wird bis November 2024 unterstützt, .NET 7 als Release mit kurzem Support bis Mai 2024. Wer noch auf 7 sitzt, hat also den knappsten Zeitplan und sollte die Umstellung nicht auf die lange Bank schieben. Wer auf 6 ist, hat ein Jahr Luft, was erfahrungsgemäß schneller vergeht, als man denkt.

Als ich 2019 über .NET Core 3.0 geschrieben habe, ging es noch darum, ob man dem neuen Weg überhaupt vertrauen kann. Heute ist das keine Frage mehr, und 2018, als ich C# unter Linux ausprobiert habe, hätte ich nicht gedacht, dass das mal so selbstverständlich werden würde. Das Umstellen ist inzwischen meistens unspektakulär: Zielframework ändern, bauen, Warnungen lesen.

C# 12: Die kleinen Dinge

C# 12 bringt ein paar Sprachänderungen, die den Code kürzer machen, ohne ihn zu verschleiern. Am meisten Aufmerksamkeit bekommen die primären Konstruktoren, die es bisher nur bei Records gab. Jetzt funktionieren sie auch bei normalen Klassen und Structs:

public class BestellService(IBestellRepository repository, ILogger<BestellService> logger)
{
    public Bestellung? Hole(int id)
    {
        logger.LogInformation("Lade Bestellung {Id}", id);
        return repository.Finde(id);
    }
}

Die Parameter stehen im ganzen Klassenkörper zur Verfügung. Das spart die üblichen Felder und die Zuweisungen im Konstruktor, die bei Dependency Injection jede Klasse aufblähen. Ein Haken: Die Parameter sind veränderbar und keine readonly-Felder. Wer Wert darauf legt, sollte sich das bewusst machen. Ich finde den Gewinn trotzdem deutlich.

Die zweite Neuerung sind Collection Expressions:

int[] a = [1, 2, 3];
List<int> b = [..a, 4, 5];

Eckige Klammern für Arrays, Listen, Spans und weitere Sammlungen, dazu der Spread-Operator .., der andere Sammlungen einfügt. Das wirkt unspektakulär, ersetzt aber eine Menge Schreibarbeit und die Frage, welche Initialisierungsform man gerade braucht.

Weiter gibt es Standardwerte für Lambda-Parameter, etwa var addiere = (int x, int schritt = 1) => x + schritt;, einen Alias mit using für beliebige Typen, etwa Tupel, und Inline Arrays, die vor allem für performancekritischen Code gedacht sind. Letztere werden die meisten von uns vermutlich nie direkt schreiben, sondern höchstens indirekt über Bibliotheken nutzen.

Native AOT und der Blick auf Web

Native AOT war in .NET 7 eher ein Randthema. In .NET 8 wird es breiter. Eine Anwendung wird vorab in nativen Code übersetzt, startet schneller und braucht weniger Speicher, braucht dafür aber keine laufende JIT-Umgebung. Der Preis sind Einschränkungen: Reflection ist nur begrenzt nutzbar, dynamisches Laden von Assemblies geht nicht, und nicht jede Bibliothek ist dafür vorbereitet.

Unterstützt wird Native AOT jetzt unter anderem für ASP.NET Core Minimal APIs. Ich würde es für kleine Dienste und Werkzeuge ausprobieren, bei denen der Start zählt, etwa in Containern. Für größere Anwendungen mit viel Reflection oder Dritt-Bibliotheken sehe ich es eher skeptisch. Hier gilt: ausprobieren, nicht blind vertrauen. Die Warnungen des Trimmers sind eine ehrliche Auskunft, ob der eigene Code mitspielt.

Blazor: Ein Modell, mehrere Modi

Bei Blazor hat sich konzeptionell am meisten getan. Bisher musste man sich früh zwischen Blazor Server und Blazor WebAssembly entscheiden. Mit .NET 8 gibt es statisches Server-Rendering, bei dem Seiten auf dem Server erzeugt und als HTML ausgeliefert werden, und die Möglichkeit, Render-Modi pro Seite oder Komponente zu wählen. Interaktivität lässt sich also gezielt dort einschalten, wo man sie braucht, und entfällt, wo eine einfache Seite reicht.

Ich halte das für die sinnvollste Änderung an Blazor seit Langem, denn sie nimmt die Entweder-oder-Entscheidung aus dem Projektstart. Wie sich das in großen Projekten anfühlt, kann ich nicht beurteilen. Aus meiner Sicht lohnt es sich, ein kleines Projekt damit aufzusetzen und die Modi auszuprobieren, bevor man Bestehendes anfasst.

Als Vorschau ist außerdem .NET Aspire dabei, ein Satz an Bausteinen für verteilte, cloudfähige Anwendungen: Dienste, Datenbanken und Konfiguration lassen sich in einem Modell beschreiben, mit Dashboard und Telemetrie. Es ist eine Vorschau, und ich würde dort nichts Produktives drauf bauen. Als Richtungsanzeige finde ich es aber interessant.

Die unscheinbaren Verbesserungen

Die Dinge, die mir am meisten im Alltag helfen werden, stehen eher unten auf der Liste.

TimeProvider. Wer Code testen will, der die aktuelle Zeit liest, hat bisher eigene Abstraktionen gebaut, jeder auf seine Art. Jetzt gibt es eine Basisklasse dafür, die sich per Dependency Injection einsetzen lässt. Das ist so ein Fall, bei dem ich mich frage, warum es das nicht längst gab.

FrozenDictionary und FrozenSet. Sammlungen, die einmal aufgebaut und danach nur noch gelesen werden, etwa Konfigurationstabellen. Sie sind auf schnelles Nachschlagen optimiert, dafür ist das Erstellen teurer. Wie groß der Unterschied ist, müsste man im eigenen Fall messen.

System.Text.Json. Es gibt weitere Verbesserungen, etwa bei der Serialisierung mit Source-Generatoren und beim Umgang mit Vorgabewerten. Wer bisher bei Newtonsoft.Json geblieben ist, weil System.Text.Json Lücken hatte, sollte noch einmal nachsehen.

Container ohne Root. Die offiziellen Container-Images laufen standardmäßig als Nicht-Root-Benutzer. Aus Sicherheitsgründen ist das vernünftig, kann aber Überraschungen bringen, etwa bei Dateirechten oder bei Ports unterhalb von 1024. Das würde ich beim Umstellen im Blick behalten.

Was ich zuerst anfassen würde

Wenn ich eine Reihenfolge vorschlagen sollte: Zuerst das Zielframework anheben und schauen, ob alles läuft. Danach die Kleinigkeiten, die kaum Risiko haben, nämlich primäre Konstruktoren und Collection Expressions in neuem Code, TimeProvider in Tests. Native AOT und die neuen Blazor-Modi als Experimente, getrennt vom Hauptprojekt. Aspire erst einmal beobachten.

Ich bin gespannt, wie schnell die großen Bibliotheken bei Native AOT aufholen. Das wird meiner Einschätzung nach darüber entscheiden, ob das Feature ein Nischenthema bleibt. Welche .NET-8-Neuerung habt ihr schon im Einsatz, und wo ist die Umstellung bei euch ins Stolpern geraten?

Beitragsbild: .NET-Logo von Microsoft, gemeinfrei (via Wikimedia Commons; unverändert auf eigenem Hintergrund). .NET 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.