Konstante Interpolation in C# 10 und .NET 6 in 10 Minuten oder weniger

Einführung

In diesem Video erklärt Tim, wie interpolierte Zeichenketten - solche, die die bekannte Dollarzeichen-Syntax ($) verwenden - jetzt in konstanten Ausdrücken verwendet werden können, was vorher nicht möglich war. Diese kleine Änderung macht die Konstruktion konstanter Zeichenketten einfacher, sauberer und wartungsfreundlicher.

Erforschen von Konstanten in .NET 6

Tim öffnet eine .NET 6-Konsolenanwendung und entfernt den Boilerplate-Code, um sich ausschließlich auf Konstanten-Definitionen zu konzentrieren.

Er beginnt mit der grundlegenden Deklaration einer konstanten Zeichenfolge:

const string companyName = "Acme";

const string companyName = "Acme";

Dies ist ein einfaches String-Literal, das einem const-String zugewiesen ist. Konstanten wie diese werden bei der Kompilierung ausgewertet, was bedeutet, dass ihre Werte festgelegt und in das kompilierte Programm eingebettet sind.

Doch Tim kommt schnell auf die zentrale Frage zu sprechen: Was ist, wenn wir konstante Zeichenketten zusammenführen oder Werte direkt in andere Zeichenketten durch Interpolation einbetten wollen?

In C# 9 und früher war dies nicht möglich:

const string productName = $"{companyName} Anvils"; // Not allowed before C# 10

const string productName = $"{companyName} Anvils"; // Not allowed before C# 10

Diese Zeile würde einen Kompilierfehler auslösen, da die String-Interpolation für konstante Ausdrücke nicht unterstützt wird.

Konstante interpolierte Zeichenketten in C# 10

Wie Tim demonstriert, unterstützt der Compiler in C# 10 jetzt konstante interpolierte Strings - solange alle Interpolationsausdrücke darin selbst Konstanten sind.

Das folgende Beispiel funktioniert jetzt also perfekt:

const string productName = $"{companyName} Anvils";

const string productName = $"{companyName} Anvils";

Dies ist eine konstante interpolierte Zeichenkette, was bedeutet, dass der Compiler die interpolierte Zeichenkette zur Kompilierzeit und nicht zur Laufzeit auswertet. Bei der Ausführung des Programms findet keine zusätzliche String-Verkettung oder String-Formatierung statt - der Compiler erzeugt ein einzelnes konstantes String-Literal wie "Acme Anvils".

Tim erklärt, dass, wenn wir den Wert von companyName von "Acme" in "ABC" ändern, der Compiler automatisch "ABC Anvils" für productName erzeugt. Es handelt sich um eine String-Konstruktion während der Kompilierung, nicht um eine Interpolation während der Laufzeit.

Diese Verbesserung macht es viel einfacher, konstante Zeichenketten zusammenzuführen, ohne auf + Verkettung oder manuelle Wiederholung von Werten zurückgreifen zu müssen.

Geschachtelte konstante Interpolation

Tim geht mit einer anderen konstanten Definition noch einen Schritt weiter:

const string productDescription = $"{productName} are the best way to crush unsuspecting roadrunners.";

const string productDescription = $"{productName} are the best way to crush unsuspecting roadrunners.";

Dies ist ein Beispiel für eine verschachtelte Interpolation, bei der eine konstante interpolierte Zeichenfolge (productName) innerhalb einer anderen verwendet wird.

Der Compiler behandelt alle diese Begriffe als konstante Ausdrücke und erzeugt zur Kompilierungszeit eine einzige, unveränderliche String-Darstellung.

Wenn Tim das Programm ausführt, lautet die Ausgabe:

Acme Anvils are the best way to crush unsuspecting roadrunners.

Acme Anvils are the best way to crush unsuspecting roadrunners.

Dies bestätigt, dass die Interpolation von Konstanten nahtlos funktioniert, selbst bei mehreren Konstanten.

Warum Konstanten wichtig sind

An dieser Stelle macht Tim eine Pause, um zu erklären, warum Konstanten - und jetzt auch konstante interpolierte Zeichenketten - von Vorteil sind.

Er weist darauf hin, dass Konstanten extrem speichereffizient sind, da ihre Werte direkt im kompilierten Code und nicht als separate Instanzen im Speicher gespeichert werden.

Wenn Entwickler früher etwas Ähnliches benötigten, verwendeten sie oft schreibgeschützte Felder:

readonly string companyName = "Acme";

readonly string companyName = "Acme";

Tim weist jedoch darauf hin, dass Readonly-Felder nicht dasselbe sind wie Const-Felder - sie werden zur Laufzeit ausgewertet, was mehr Speicher verbraucht und eine Optimierung zur Kompilierzeit verhindert.

Mit konstanten interpolierten Zeichenketten können wir jetzt ausdrucksstarke und wiederverwendbare formatierte Zeichenketten schreiben, die zur Kompilierzeit Konstanten bleiben, was sowohl die Klarheit als auch die Leistung verbessert.

Praktisches Beispiel - Verwendung von Konstanten in Attributen

Anschließend stellt Tim ein reales Szenario vor, in dem diese neue Funktion zum Tragen kommt: Attribute.

Er definiert eine einfache lokale Methode innerhalb von Main():

void SayHi() { }

void SayHi() { }

Dann versucht er, das Attribut [Obsolete] mit einer String-Nachricht anzuwenden, die auf eine Variable verweist:

string myCompany = "Tim's Company";
[Obsolete($"This is no longer used for {myCompany}")]

string myCompany = "Tim's Company";
[Obsolete($"This is no longer used for {myCompany}")]

Dies scheitert daran, dass Attribute nur konstante Ausdrücke als Parameter akzeptieren können. Der Compiler erzeugt einen Fehler, da myCompany eine Variable und keine Konstante ist.

Tim erklärt, dass die Nachricht des Attributs zur Kompilierzeit konstant sein muss - sie darf nicht von Laufzeitwerten oder Instanzvariablen abhängen.

Dank der konstanten interpolierten Zeichenketten in C# 10 können wir dies nun sicher tun:

const string productName = $"{companyName} Anvils";
[Obsolete($"This is no longer used for {productName}")]

const string productName = $"{companyName} Anvils";
[Obsolete($"This is no longer used for {productName}")]

Hier erkennt der Compiler, dass sowohl companyName als auch productName Konstanten sind, sodass die gesamte interpolierte Zeichenfolge ein konstanter Ausdruck ist.

Der Compiler generiert die formatierte Zeichenkette zur Kompilierzeit und macht sie innerhalb des Attributs gültig.

Dieses Beispiel verdeutlicht perfekt, warum die konstante Interpolation nicht nur syntaktischer Zucker ist - sie ermöglicht neue Szenarien wie die Verwendung von formatierten Compile-Time-Strings direkt in Attributen oder Metadaten.

Behind the Scenes - Wie der Compiler es macht

Tim geht in dem Video nicht auf die Interna des Compilers ein, aber das Konzept ist eng mit der Funktionsweise von interpolierten String-Handlern in C# 10 verknüpft.

Wenn der Compiler auf eine interpolierte Zeichenkette stößt, erstellt er im Allgemeinen einen Code, der einer Operation zur Formatierung von Zeichenketten ähnelt, indem er hinter den Kulissen Aufrufe wie AppendLiteral() und AppendFormatted() erzeugt.

Beim Umgang mit konstanten interpolierten Strings wertet der Compiler jedoch alles zur Kompilierzeit aus - im generierten IL-Code wird kein interpolierter String-Handler oder Methodenaufruf ausgegeben.

Das bedeutet, dass sich der resultierende Wert genau wie ein beliebiges String-Literal verhält, aber Sie können ihn dennoch mit eingebetteten Ausdrücken aus anderen Konstanten zusammensetzen.

Es handelt sich um ein elegantes Gleichgewicht zwischen Ausdruckskraft und Effizienz - der Compiler verarbeitet die String-Konstruktion statisch, sodass keine Laufzeitkosten entstehen.

Wann werden konstante interpolierte Zeichenketten verwendet

Tim ist sich bewusst, dass nicht jeder diese Funktion jeden Tag nutzen wird. Entwickler, die selten Konstanten definieren oder Attribute schreiben, profitieren möglicherweise nicht sofort davon.

Für diejenigen, die viele Compile-Time-Definitionen, Konstantenmeldungen oder Attribut-Metadaten erstellen, vereinfacht diese Funktion den Code und verhindert ein Durcheinander bei der String-Verkettung.

Außerdem ist es sicherer - da Konstanten unveränderlich sind und vom Compiler überprüft werden, werden Fehler durch dynamisch verkettete Zeichenketten oder falsch verwaltete Variablen vermieden.

Dadurch wird Ihr Code robuster, lesbarer und leichter zu pflegen.

Abschluss

Zum Abschluss seines Videos fordert Tim die Entwickler auf, darüber nachzudenken, ob sie in ihren Projekten konstante interpolierte Zeichenketten verwenden werden. Einige werden sie für saubere, kompilierte und formatierte Zeichenketten für unverzichtbar halten, während andere sie vielleicht als eine kleine Annehmlichkeit betrachten.

Wie auch immer, Tims Demonstration zeigt genau, wie und wo diese Funktion effektiv eingesetzt werden kann.

Zusammengefasst:

• Konstante interpolierte Zeichenketten ermöglichen Interpolationsausdrücke innerhalb von Konstanten.

• Sie werden bei der Kompilierung ausgewertet und erzeugen effiziente String-Literale.

• Sie ersetzen die sich wiederholende String-Verkettung durch eine sauberere Syntax.

• Sie sind besonders nützlich bei Attributen, konstantenbasierter Konfiguration und Metadatenmeldungen.

Durch die Kombination von Lesbarkeit und Kompiliersicherheit ist die Konstanteninterpolation von C# 10 ein weiterer Schritt in Richtung ausdrucksstarke und effiziente C#-Programmierung - wie das Beispiel von Tim Corey deutlich zeigt.