Ein Blog

Posts mit Tag "dotnet"

.NET 11. Neu u. A.:

  • C# 15, das u. A. union types hat
  • Opt-in fĂĽr Preview von runtime-async

Der Rest ist eher uninteressant.

Heute habe ich CBOR kennengelernt. Das ist quasi JSON, aber in binär. Gefunden, weil .NET 11 das jetzt in der Standardlibrary hat. Es ist auch deutlich besser standardisiert als JSON.

Mein erster Gedanke ist: Was ist mit BSON? Stellt sich heraus: BSON ist zwar binäres JSON, ist aber ausgelegt auf konkrete Verwendung in MongoDB.

.NET 11 Preview 7 ist da. Spannend find ich 2 Sachen:

  • In C#: Labelled break/continue fĂĽr Schleifen. Das Feature hat Java seit Ewigkeiten und mich wundert, dass sie das erst 2026 nachschieben, wo sie ständig irgendwelche Riesenfeatures desginen.
  • WinForms (ja, wirklich!):
    • Alle Controls bekommen einen neuen Style: “NET11”. Hab noch keinen Screenshot davon gesehen.
    • Forms können jetzt “warten”, bis alle Controls und Themes gesetzt sind, bevor sie das erste mal gerendert werden. So hat man am Anfang keinen Flash, wo sich dann plötzlich nochmal alles ändert
    • using (list.SuspendPainting(LayoutSuspendTraversal.Target)) fĂĽr Bulk-Operationen, um erst am Ende neu zu rendern. Sowas hab ich tatsächlich auch in HolzShots schonmal irgendwo selbst gebaut.
    • CheckBox und RadioButton bekommen einen “ToggleSwitch-Modus”. Da bin ich echt mal gespannt, wie das alles aussehen wird. Kann mir das nur echt schwer vorstellen.

Hat nichts mit .NET 11 zu tun, aber was ich neulich lernte: .NET hat auch einen Rune-Typen, ähnlich wie Go (aber nicht ganz so, siehe Artikel).

.NET 11 Preview 4 ist erschienen. Neu sind ein paar APIs in der Process-Klasse:

using System.Diagnostics;

// One-shot capture: stdout and stderr together, plus exit code.
ProcessTextOutput result = await Process.RunAndCaptureTextAsync(
    "git", ["status", "--porcelain"]);

Console.WriteLine(result.StandardOutput);
Console.WriteLine($"exit code: {result.ExitStatus.ExitCode}");

Andere Methoden: Process.Run, Process.RunAsync, Process.RunAndCaptureText, and Process.RunAndCaptureTextAsync.

Sehr handlich, das war immer unnötig kompliziert, das jedes Mal selbst zu bauen.

.NET 11 Preview 2 ist da. Neu ist vorallem eine Vorschau davon, wie sie Async-Code in die Runtime schieben. Aus async/await hat der Compiler bisher eine State-Machine gebaut und als IL emitted. Das könnte sich in zukunft ändern und von der Runtime übernommen werden.

.NET 10 bekommt ein neues GC-Feature: DATAS. War eigentlich schon bei .NET 9 da, aber das benutzen kaum welche, weil es nicht LTS ist.

.NET 10 ist in der ersten preview erschienen. Changelogs:

.NET 9 ist da. Hier sind die Performance-Verbesserungen.

Es ist ja gerade die Build-Konferenz von MS. In der Sessionliste habe ich eine Session gefunden, die ich vor 10 Jahren niemals in einer MS-Konferenz in 10 Jahren erwartet hätte:

What’s New with WinForms in .NET 9?

Wer sich die Stunde sparen will, hier ein paar Highlights:

  • Winforms bekommt Dark-Mode-Support
  • Graphics-Klasse kann jetzt abgerundete Rechtecke zeichnen
  • MVVM fĂĽr WinForms und generell mehr Data-Binding-Support, Command-Bindings
  • …und natĂĽrlich - I kid you not - KI-Integration fĂĽr diverse Controls. MakeIntelligent-Property auf einem Date-Input und der Textbox. Funktioniert ĂĽber semantic-kernel, also auch ĂĽber irgendwelche OpenAI-LLMs. harold.jpg

.NET 8 ist da.

C# 11 und .NET 7 sind da.

C# hat jetzt wirklich schon echt umfangreiches Pattern-Matching. Z. B. bei dieser Variante von AddAll sieht man das ganz gut:

  T AddAll<T>(params T[] elements) where T : IMonoid<T> =>
    elements switch
  {
      [] => T.Zero,
      [var first, ..var rest] => first + AddAll<T>(rest),
  };

Die List-Patterns lassen code auch schon sehr kompakt (aber zumindest fĂĽr C# sehr ungewohnt) schreiben und funktionieren auch auf Strings und Char-Spans:

void MatchMessage(string message)
{
    var result = message is ['a' or 'A', .. var s, 'a' or 'A']
        ? $"Message {message} matches; inner part is {s}."
        : $"Message {message} doesn't match.";
    Console.WriteLine(result);
}

MatchMessage("aBBA");  // output: Message aBBA matches; inner part is BB.
MatchMessage("apron");  // output: Message apron doesn't match.

void Validate(int[] numbers)
{
    var result = numbers is [< 0, .. { Length: 2 or 4 }, > 0] ? "valid" : "not valid";
    Console.WriteLine(result);
}

Validate(new[] { -1, 0, 1 });  // output: not valid
Validate(new[] { -1, 0, 0, 1 });  // output: valid

Zu .NET 7 hab ich ja schon einiges hier, vieles davon ist im AnkĂĽndigungspost auch noch mal drin.

Weil ich den fĂĽr .NET 6 auch verlinkt habe: Performance Improvements in .NET 7.

Wie immer beeindruckend.

.NET 7 Preview 7 ist da. Interessante Neuerungen:

  • Support fĂĽr Unix File-Modes
  • Ein Ersatz fĂĽr DllImport (FFI), der Source Generators verwendet: LibraryImport

Wo wir gerade bei .NET 7 waren:

Die neue Preview (Preview 5) hat jetzt Support für “Generic Math”.

Das wird ermöglicht durch:

  • Statische, abstrakte Interface-Member
  • Dadurch OperatorĂĽberladung, die in Interfaces spezifiziert ist

Interfaces konnten bis C# 11 keine statischen Member von einem Typen verlangen. So war es z. B. nicht möglich, zu verlangen, dass eine Klasse den +-Operator implementiert. Auch nicht mit einem Type-Constraint. Auch das bekannte Muster Parse und TryParse war mehr Konvention als irgendwie erzwingbar, weil beide Methoden statisch sind. Aus dem Grund war eine Lösung, Klassen zu erstellen, von denen es nur eine Instanz gibt. Anders konnte man keinen Type-Constraint erfüllen, der durch Interfaces kam. Darüber habe ich schonmal berichtet.

Jetzt ist das ganze ist jetzt schon deutlich konkreter geworden. Die neuen Interfaces dazu sehen sehr cool aus. Man kann damit jetzt den Großteil der Rechenoperationen abstrahieren. Den Nutzen kann man gut sehen, weil sie in der LINQ die Min/Max-Funktionen damit ersetzen konnten. Es fällt echt viel doppelter Code weg. Es liegt jetzt natürlich nah, diese Interfaces auch bei den Vector-Typen aus System.Numerics zu implementieren. Laut den Kommentaren in dem Artikel dazu wird das nicht mehr in .NET 7 passieren.

Auch neu: .NET hat jetzt eine API, um TARs zu entpacken. Wenn man das mit dem bereits existierenden GZipStream kombiniert, kann man also ganz leicht ohne externe Libraries jetzt eine tar.gz entpacken. Deflate und Brotli gibt es dort ĂĽbrigens auch.

System.Text.Json kann jetzt anhand von einem Diskriminator-Feld zwischen in verschiedene Basisklassen deserialisieren:

[JsonDerivedType(typeof(Base), typeDiscriminator: "base")]
[JsonDerivedType(typeof(Derived), typeDiscriminator: "derived")]
public class Base
{
    public int X { get; set; }
}

public class Derived : Base
{
    public int Y { get; set; }
}
// ...
Base value = JsonSerializer.Deserialize<Base>(@"{ ""$type"" : ""derived"", ""X"" : 0, ""Y"" : 0 }");
// value is a Derived instance

Was in dem Blogpost nicht steht, aber in der Issue zu der Änderung: Man kann die Property, auf die geschaut wird, wie folgt definieren:

[JsonPolymorphic(CustomTypeDiscriminatorPropertyName = "$case")]

(standardmäßig ist es "$type")

System.IO.Stream hat jetzt ReadExactly und ReadAtLeast. Das ist cool, weil das normale Read möglicherweise weniger Daten zurückgibt. Dann muss man eigene Logik bauen, um den Rest auch noch zu lesen. Das ist manchmal echt nervig gewesen. Um das etwas zu entkoppeln, gibt es übrigens noch was anderes: System.IO.Pipelines.

Wenn Ihr eine Library baut, gibt’s noch eine interessante Neuerung: Das StringSyntaxAttribute. Das kann man an Member und Parameter kleben, um anzugeben, was der entsprechende String so für Daten enthält. So kann man z. B. sagen, dass soein String ein Regex-Pattern oder JSON enthält. Die IDE kann dann entsprechend highlighten und generell ne bessere Editing-Experience geben.

VS gibt’s jetzt auch für ARM64.

MS hat in .NET 5 schon deutliche Performancegewinne bei RegEx erzielen können.

Das ist in .NET 7 noch mal interessanter geworden.

Erste interessante Sache: Sie haben einen Source-Generator fĂĽr RegEx gemacht. Damit wird das RegEx-Pattern zur Compile-Time der Anwendung schon kompiliert. Das spart Zeit bei dem initialen Aufruf und bietet ggf. noch Raum fĂĽr mehr Optimierungen, weil es nicht zwangsweise schnell gehen muss. Dieser Generator ist allerdings Opt-In, weil man das RegEx-Objekt dafĂĽr auf eine bestimmte Art anlegen muss.

RegEx-Engines verwenden in der Praxis üblicherweise Backtracking, um nach Matches zu suchen. Ein Mensch der theoretischen Informatik würde jetzt fragen “warum das?”. Der Hintergrund ist, dass RegEx in den meisten Sprachen doch etwas mehr kann, als reguläre Ausdrücke einer regulären Sprache (z. B. Lookback References).

Verwendet man in seinem Pattern solche Konstrukte (Liste davon ist im verlinkten Blogpost) nicht, kann man alternativ eine RegEx-Engine verwenden, die einen DFA bzw. NFA konstruiert. Also das, was man im TI-Unterricht auch so lernt. Der Vorteil davon: Die können in manchen Use-Cases schneller sein. Das sollte man abhängig von seinem Pattern und den Daten machen. Hilfe beim Entscheiden gibt einem der Blogpost. Man sollte jetzt also nicht hingehen und überall Backtracking entfernen. Backtracking wurde schon gut optimiert.

Ein paar weitere Änderungen sind SIMD-Vektorisierung und Support für Span<T>.

Heute kam eine Folge von DotNetRocks zu 20 Jahren C# mit Anders Hejlsberg.

TIL es gibt ein IAsyncDisposable, das einfach ein IDisposable ist, dessen Dispose-Methode asynchron ist.

Wiedermal ein schöner API-gotcha, dieses Mal in C#/.NET:

Path.GetTempFileName() gibt den Pfad zu einer einzigartigen Datei zurück. Dabei wird diese Datei auch gleich (ohne Inhalt) angelegt. Sehr praktisch also! Man kann die Datei auch direkt löschen, wenn man weiß, dass man sie nicht mehr braucht.

Brauchst du etwas mehr, als eine einzige Datei? Es gibt praktischerweise auch Path.GetTempPath()!

Moment — diese Funktion gibt keinen eindeutigen Ordnernamen zurück, sondern den Pfad zum Temp-Verzeichnis des Nutzers. Wer gerade seinen Code refactored hat und davon ausging, dass man den Ordner sicher löschen kann, hat also vielleicht Pech. Wenn man darin dann Dateien mit gleichen Namen anliegt, wiegt sich auch in falscher Sicherheit. Nicht schön.

Dies ist ein schönes Beispiel, dass man Seiteneffekte immer deutlich machen soll. Schon bei GetTempFileName hätte man noch irgendwo ein Create in den Namen tun müssen, damit man sieht, dass diese Funktion auch tatsächlich noch etwas anderes macht, als einen String zurückzugeben. Alternativ hätte man auch bei GetTempPath noch einen anderen Namen finden können.

Naming things is hard.

C# wird ja immer weiterentwickelt. Das geht seit Roslyn so schnell, dass manche Sachen dort vielleicht untergegangen sind. Z. B. hat C# mittlerweile zwei neue Access-Modifiers, die noch “so üblich” sind:

  • protected internal: The type or member can be accessed by any code in the assembly in which it’s declared, or from within a derived class in another assembly.
  • private protected: The type or member can be accessed only within its declaring assembly, by code in the same class or in a type that is derived from that class.

Wenn Ihr frĂĽher .NET gemacht habt, kennt Ihr vielleicht noch pinvoke.net. Das ist eine Wiki-artige Plattform, auf der im Prinzip Code gesammelt wurde, um mit der Win32-API ĂĽber P/Invokes (das ist das FFI von .NET) zu arbeiten.

Jedes Programm hatte dann diese P/Invoke-Signaturen zu sich hinkopiert. Es gab magische Konstanten, die von irgendwo herkamen und keinen Namen hatten. Wie das halt so mit altem Code, der durch 3 Generationen weitergereicht wird, so ist.

Vor kurzem bin ich auf dotnet/pinvoke gestoßen. Das ist genau das, nur von Microsoft selbst (+ Community Contributions), als einheitliche Dependency, die über NuGet installierbar ist. Zugegeben NuGet gab’s vor 15 Jahren noch nicht wirklich in der Form. Aber genau sowas hätte MS auch schon damals bereitstellen sollen - das hätte alles einfacher gemacht. So ähnlich wie mit dem WinAPICodePack, welches dann auf einmal von allen MS-Seiten verschwand (vermutlich wegen Metro/UWP?).

Jedenfalls dachte ich gerade: Geil! Damit kann ich endlich in meiner Software die handgeschriebenen P/Invokes ablösen und die fehlenden nach upstream contributen. Weniger Wartung für mich und alle haben was davon und so.

Dann habe ich aber diese Issue gesehen. Vor einiger Zeit habe ich hier auch etwas zu den Source-Generators in C# geschrieben. Diese Source-Generators lösen genau diese Library jetzt ab. Und zwar hat das Win32-Team Metadata-Dateien erstellt, aus denen die P/Invokes on-demand erstellt werden können. Dieser Source-Generator verwendet das. Man muss damit also keine Dependencys mit riesigen Win32-Import-Ansammlungen mitschleppen, sondern generiert sich genau die, die man benötigt.

File IO improvements in .NET 6.

Also ich weiß ja nicht, was der Fall ist. Entweder war .NET vorher im Vergleich derbe langsam, oder jetzt, wo es open source ist, kommen da viele Wunderkinder aus den Ecken und optimieren an jeder Stelle, was das Zeug hält. Wie auch immer die solche Performanceverbesserungen aus dem Hut zaubern.

Vielleicht sind es aber auch die Low-Level-Features, die C# seit neustem eins nach dem Anderen dazubekommt, was dazu fĂĽhrt, dass man jetzt solche Optimierungen machen kann. War eigentlich kein Fan davon, weil es in Zukunft immer mehr Wege gibt, Dinge zu tun. Aber ich kann schon verstehen, warum man das will, wenn man damit solche Verbesserungen herzaubern kann.

Interessant ist auch die neue “Thread-Safe File IO”:

We recognized the need for thread-safe File IO. To make this possible, stateless and offset-based APIs have been introduced in #53669 which was part of .NET 6 Preview 7:

An einigen Stellen scheinen sie jetzt auch “am Betriebssystem vorbei” zu gehen (siehe Anmerkung über den File-Offset).

MS hat hier zusammengetragen, was es fĂĽr Performanceverbesserungen in .NET 6 gibt.

Insgesamt echt beeindruckend, alleine schon das Volumen des Posts. Habe jetzt nicht alles einzeln gelesen, nur grob ĂĽberflogen. Eine Sache ist mir aber aufgefallen:

Most of the Math methods can now participate in constant folding, so if their inputs end up as constants for whatever reason, the results can become constants as well […] dotnet/runtime#42831 from @nathan-moore ensured that the Length of an array created from a constant could be propagated as a constant. […] […] dotnet/runtime#55745, which enables the JIT to fold TimeSpan.FromSeconds(constant) (and other such From methods) into a single instruction.

Nice! Offenbar ist die Compilerinfrastruktur bei .NET jetzt so gut, dass solche Verbesserungen von random GitHub-Leuten eingereicht werden können.

Ich habe vor einiger Zeit mal den Vorschlag gemacht, CTFE in C# zu machen. Das ist jetzt definitiv obsolet. Nahezu jedes Beispiel aus dem Proposal wird jetzt vom Constant-Folding optimiert (was ich auch fĂĽr den besseren Ansatz halte).

Die verbleibenden Use-Cases könnten von generischen Const-Parametern abgefertigt werden. In meinem Proposal werden auch const structs angedeutet (also structs, die zur Compile-Time schon einen Wert haben und sich nicht mehr ändern). Da gibt es auch ein separates Proposal zu. Der Vorteil davon wäre, dass man z. B. DateTimes als “richtige” Konstante haben kann (nicht nur als Shared-Readonly) und es eigentlich keinen Grund gibt, das nicht zu tun, weil das intern auch nur ein Int64 und sonst immutable ist.

Gerade ist eine neue .NET-Preview veröffentlich worden. Bis auf ein paar Library-Neuerungen ist vor allem eines neu: Statische Interface-Member.

Damit kann man diverse Patterns, wie z. B. Parse + TryParse jetzt als Interface-Methoden definieren (das ging vorher nicht, weil die beiden Methoden statisch sind und Interfaces auf Instanzmethoden beschränkt waren). Jetzt geht das.

Damit lässt sich jetzt sehr viel machen, z. B. mathematische Operatoren über generische Interfaces zu definieren. Dann kann einer Library egal sein, welchen Typ man reinwirft, hauptsache er “kann Addition” (überladene Operatoren sind auch statische Methoden, deshalb ging das bisher nicht). Natürlich gehen auch Vergleichsoperatoren, die bisher über das IComparable<T>-Interface liefen.

Wenn man da jetzt die Mathematiker drauf lässt, bekommt man sicher ganz viele Gruppen, Monoiden, Ringe, Körper und noch ganz andere viele Dinge. Ich hoffe, dass der JIT damit ordentlich umgehen kann. Bei den Gleichheitsoperatoren fällt mir jetzt auf, dass sie nicht zwischen Partieller Gleichheit und totaler Gleichheit unterscheiden, wie Rust das macht. Generell wirkt es etwas, wie Concepts aus C++. Vielleicht ein bisschen weniger mächtig.

Gerade hat Microsoft ihre Entwicklerkonferenz BUILD. Da kam jetzt auch eine neue Preview-Version von .NET 6 raus. Hier gibt es einen Artikel ĂĽber die Neuerungen. Viel cooles dabei. Am meisten freuen mich die neuen Funktionen in der LINQ.

Seit .NET 5 gibt es in C# ein Sprachfeature, mit dem man Code generieren kann, basierend auf dem C#-Code, der schon da ist.

Das öffnet vielen Dingen die Tore, z. B.:

  • Dependency Injection zur Compiletime (statt Runtime); dadurch schnellere Startzeit
  • Spezialisierte (JSON-)Serialisierungs-Typen, die genau einen bestimmten Typen (De-)Serialisieren können
  • Ganz viel Reflection fällt weg

Eigentlich ist Code-Generation gar nicht so toll. Man hat am Ende Zeug, das man nicht ordentlich debuggen kann und im Zweifelsfall ist der Fehler im Code-Generator. Sowas ist auch immer ein Zeichen dafür, dass die Sprache nicht ausdrucksstark genug ist. Außerdem habe ich bisher schlechte Erfahrungen damit gemacht (ok, eigentlich nur in Java). Da hat man immer mal wieder das Problem, dass generierter Code (z. B. von immutables.org) “noch nicht da ist” und die IDE dann meckert, warum man eine nicht-existente Klasse verwendet (in diesem Fall z. B. der Builder für einen unveränderlichen Typen).

Man sieht aber trotzdem den Use-Case für solche Dinge. Da C# sich aktuell stark darauf hinentwickelt, Ahead-Of-Time-Compile-fähig zu sein, ergibt dieses Feature Sinn. Z.B. ist Reflection bei AOT-Kompilierung ein Dorn im Auge, da man nicht weiß, welche Typen/Codeteile man aus der fertigen Assembly rausschmeißen kann. Man kann außerdem sehr schön optimieren, wenn man konkreten Code mit ordentlichen Typen statt Reflection hat.

Vermutlich werden viele Dinge, die C# vor ein paar Jahren noch als eigenes Feature gebaut hätte, jetzt als Source-Generator implementiert. Letztendlich ist das ja auch nur ein Compiler-Plugin, das Lowering betreibt. Hoffentlich wird es die Sprache nicht allzu krass verwässern. Die Befürchtung habe ich ja schon.

Hier ist eine Liste mit Source-Generatoren, die man sich in einer freien Minute anschauen kann. Viel Zeug dabei, das man nicht braucht. Aber auch viel nĂĽtzliches.