Interpolation constante en C# 10 et .NET 6 en 10 minutes ou moins

Chaînes interpolées constantes en C# 10

Comme le démontre Tim, dans C# 10, le compilateur prend désormais en charge les chaînes interpolées constantes - à condition que toutes les expressions d'interpolation à l'intérieur soient elles-mêmes des constantes.

L'exemple suivant fonctionne donc parfaitement :

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

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

Il s'agit d'une chaîne interpolée constante, ce qui signifie que le compilateur évalue la chaîne interpolée au moment de la compilation et non de l'exécution. Aucune concaténation ou formatage de chaîne supplémentaire n'a lieu lors de l'exécution du programme - le compilateur génère une chaîne littérale constante unique comme "Acme Anvils".

Tim explique que si nous changeons la valeur de companyName de "Acme" à "ABC", le compilateur génère automatiquement "ABC Anvils" pour productName. Il s'agit d'une construction de chaîne au moment de la compilation, et non d'une interpolation au moment de l'exécution.

Cette amélioration facilite grandement la fusion de chaînes de caractères constantes sans avoir recours à la concaténation + ou à la répétition manuelle des valeurs.

Interpolation constante imbriquée

Tim va encore plus loin avec une autre définition constante :

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

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

Il s'agit d'un exemple d'interpolation imbriquée, où une chaîne interpolée constante (productName) est utilisée à l'intérieur d'une autre.

Le compilateur traite tous ces éléments comme des expressions constantes, générant une représentation unique et immuable de la chaîne au moment de la compilation.

Lorsque Tim exécute le programme, le résultat est le suivant :

Acme Anvils are the best way to crush unsuspecting roadrunners.

Acme Anvils are the best way to crush unsuspecting roadrunners.

Cela confirme que l'interpolation constante fonctionne de manière transparente, même avec plusieurs constantes.

Pourquoi les constantes sont importantes

À ce stade, Tim fait une pause pour expliquer pourquoi les constantes - et maintenant les chaînes interpolées constantes - sont bénéfiques.

Il souligne que les constantes sont extrêmement efficaces en termes de mémoire, car leurs valeurs sont stockées directement dans le code compilé, et non en tant qu'instances distinctes dans la mémoire.

En revanche, lorsque les développeurs avaient auparavant besoin de quelque chose de similaire, ils utilisaient souvent des champs en lecture seule :

readonly string companyName = "Acme";

readonly string companyName = "Acme";

Mais Tim fait remarquer que les champs en lecture seule ne sont pas identiques aux const. Ils sont évalués au moment de l'exécution, ce qui consomme plus de mémoire et empêche l'optimisation au moment de la compilation.

Grâce aux chaînes interpolées constantes, nous pouvons désormais écrire des chaînes formatées expressives et réutilisables qui restent des constantes au moment de la compilation, ce qui améliore à la fois la clarté et les performances.

Exemple pratique - Utilisation de constantes dans les attributs

Tim présente ensuite un scénario du monde réel dans lequel cette nouvelle fonctionnalité brille - les attributs.

Il définit une méthode locale simple à l'intérieur de Main() :

void SayHi() { }

void SayHi() { }

Il tente ensuite d'appliquer l'attribut [Obsolete] à un message sous forme de chaîne qui fait référence à une variable :

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}")]

L'échec est dû au fait que les attributs ne peuvent accepter que des expressions constantes en tant que paramètres. Le compilateur génère une erreur car myCompany est une variable et non une constante.

Tim explique que le message de l'attribut doit être constant au moment de la compilation - il ne peut pas dépendre de valeurs d'exécution ou de variables d'instance.

Cependant, grâce aux chaînes interpolées constantes dans C# 10, nous pouvons désormais le faire en toute sécurité :

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}")]

Ici, le compilateur reconnaît que CompanyName et ProductName sont des constantes, de sorte que l'ensemble de la chaîne interpolée est une expression constante.

Le compilateur génère la chaîne formatée au moment de la compilation, ce qui la rend valide à l'intérieur de l'attribut.

Cet exemple montre parfaitement pourquoi l'interpolation constante n'est pas qu'un simple sucre syntaxique - elle permet de nouveaux scénarios tels que l'utilisation de chaînes formatées au moment de la compilation directement dans les attributs ou les métadonnées.

En coulisses - Comment le compilateur s'en occupe

Tim n'entre pas dans les détails internes du compilateur dans la vidéo, mais le concept est étroitement lié au fonctionnement des gestionnaires de chaînes interpolées dans C# 10.

En général, lorsque le compilateur rencontre une chaîne interpolée, il crée un code similaire à une opération de formatage de chaîne, générant des appels tels que AppendLiteral() et AppendFormatted() en arrière-plan.

Mais lorsqu'il s'agit de chaînes interpolées constantes, le compilateur évalue tout au moment de la compilation - aucun gestionnaire de chaînes interpolées ou appel de méthode n'est émis dans le code IL généré.

Cela signifie que la valeur résultante se comporte exactement comme n'importe quelle chaîne littérale, mais vous pouvez toujours la composer à l'aide d'expressions intégrées provenant d'autres constantes.

Il s'agit d'un équilibre élégant entre l'expressivité et l'efficacité - le compilateur gère la construction de la chaîne de manière statique, ce qui garantit un coût d'exécution nul.

Quand utiliser les chaînes interpolées constantes

Tim reconnaît que tout le monde n'utilisera pas cette fonctionnalité tous les jours. Les développeurs qui définissent rarement des constantes ou écrivent des attributs peuvent ne pas en bénéficier immédiatement.

Toutefois, pour ceux qui créent de nombreuses définitions au moment de la compilation, des messages de constantes ou des métadonnées d'attributs, cette fonctionnalité simplifie le code et évite l'encombrement de la concaténation de chaînes de caractères.

Les constantes étant immuables et vérifiées par le compilateur, vous éliminez les erreurs dues à des chaînes de caractères concaténées dynamiquement ou à des variables mal gérées.

Votre code sera ainsi plus robuste, plus lisible et plus facile à maintenir.

Conclusion

En conclusion de sa vidéo, Tim invite les développeurs à se demander s'ils utiliseront des chaînes interpolées constantes dans leurs projets. Certains les trouveront essentiels pour obtenir des chaînes formatées plus propres à la compilation, tandis que d'autres les considéreront comme une commodité mineure.

Quoi qu'il en soit, la démonstration de Tim montre exactement comment mettre en œuvre cette fonctionnalité et où l'appliquer efficacement.

En résumé :

• Les chaînes interpolées constantes permettent des expressions d'interpolation à l'intérieur des constantes.

• Ils sont évalués au moment de la compilation, ce qui permet de produire des chaînes de caractères efficaces.

• Ils remplacent la concaténation répétitive de chaînes de caractères par une syntaxe plus propre.

• Ils sont particulièrement utiles pour les attributs, la configuration basée sur des constantes et les messages de métadonnées.

En combinant lisibilité et sécurité à la compilation, l'interpolation constante de C# 10 est un pas de plus vers une programmation C# expressive et efficace - comme le montre clairement l'exemple de Tim Corey.