Ein Blog

Posts mit Tag "c-sharp"

.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.

.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).

Unter einem Artikel ĂĽber Fixed-Integer-Width-Vektoren (hier) stand ein netter Hinweis, den ich hier mal zitiere:

Instead of doing stuff like (word >> bit_offset) & self.mask, in C or C++ I usually write _bextr_u64, or when using modern C# Bmi1.X64.BitFieldExtract. Note however these intrinsics compile into 2 instructions not one, because the CPU instruction takes start/length arguments from lower/higher bytes of a single 16-bit number.

Geht seit Haswell (~2013), cool!

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

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

TIL: Das scoped-Keyword.

Lesetipp: Why Checked Exceptions Failed Dazu gibt es noch einen Artikel mit Anders Hejlsberg (C#-Erfinder, wo es keine checked exceptions gibt): The Trouble with Checked Exceptions

Preview-Features von C# 12. Die haben echt eine Geschwindigkeit drauf. C# 11 ist gefĂĽhlt erst seit 2 Tagen drauĂźen.

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.

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.

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.