Quoi de neuf dans C# 10 ?
C# 10 a été publié en novembre 2021 avec Visual Studio 2022 et .NET 6. Il ajoute de nombreuses nouvelles fonctionnalités qui rendent son utilisation plus facile et plus pratique. Voici une visite guidée de certains des plugins les plus utiles et de la façon dont ils amélioreront votre flux de travail.
Espaces de noms de domaine de fichier
Commençons par l'un des changements les plus simples et peut-être les plus importants. Vous pouvez désormais appliquer un espace de noms à un fichier entier via une nouvelle option de syntaxe de mot-clé d'espace de noms. L'espace de noms restant sera automatiquement placé dans le fichier, même s'il n'est pas en retrait à l'intérieur du bloc d'espace de noms. Cela fonctionne de la même manière que les déclarations d'espace de noms en PHP.
En C# 9, j'avais besoin de ce code pour un espace de noms de classe :
namespace Démo { public classe Exemple { } }
En C# 10, vous pouvez utiliser ce qui suit à la place :
namespace Démo ; public classe Exemple { }
Cela vous permet d'économiser de l'espace horizontal dans votre éditeur en supprimant le niveau d'indentation. Si un fichier doit contenir plusieurs classes, vous pouvez toutes les écrire en commençant à la colonne zéro - la déclaration d'espace de noms s'applique à l'ensemble du fichier.
utilisations mondiales
Certains espaces de noms sont largement utilisés dans les projets. Cependant, vous devez toujours les inclure manuellement dans chaque fichier avec une instruction use.
C# 10 modifie cela pour prendre en charge une variable globale à l'aide de . Cela rendra l'espace de noms indiqué accessible dans tous les fichiers de votre projet.
de défis en utilisant Système;
Peut ajouter utilisations mondiales à n'importe quel fichier qui sera inclus dans votre assemblage. Il prend en charge toutes les fonctionnalités des instructions d'utilisation standard, y compris le mot-clé static et l'alias avec =.
L'adoption d'utilisations globales réduira le nombre de lignes que vous tapez, mais il est toujours préférable de le réserver aux espaces de noms couramment référencés qui offrent peu de risques de collisions de noms. Attention, le fait de s'appuyer sur une utilisation globale peut rendre votre code plus ambigu, car les nouveaux contributeurs peuvent ne pas réaliser immédiatement comment une ressource d'espace de noms a été incluse.
L'avantage associé aux usages globaux est celui des usages implicites. Cela crée automatiquement des instructions d'utilisation génériques adaptées à votre type de projet. La capacité est activée par défaut dans les modèles de projet .NET 6. Elle peut être désactivée à l'aide du paramètre ImplicitUsings dans votre fichier .csproj.
structures améliorées
Les structures ont reçu de nombreuses améliorations qui les rapprochent des classes. Cela inclut les constructeurs sans paramètre, les initialiseurs de champs, la prise en charge complète des expressions et la possibilité de créer des structures d'enregistrement :
public point d'enregistrement(int X, int Y);
Cet exemple crée une structure d'enregistrement.localiséoù les paramètres du constructeur X et Y deviennent des membres globaux implicites. Vous pouvez également définir des membres manuellement en utilisant la syntaxe actuelle :
public record struct Point { public int X { obtenez; init; } public int Y { obtenez; init; } }
La structure du journal doit être utilisée dans les scénarios où vous devez encapsuler certaines données sans inclure les comportements personnalisés en tant que méthodes pour votre classe. La structure du registre fournit des tests et des fonctionnalités d'équivalence Valeur intégrée Comme ToString(). Il peut être mutable ou immuable via le mot-clé en lecture seule.
Améliorations de l'expression lambda
C# 10 ajoute plusieurs améliorations aux expressions lambda couvrant leurs types et leur syntaxe. L'objectif est de rapprocher les lambdas des méthodes habituelles et des fonctions locales. La sélection de l'un d'entre eux sera désormais une expérience plus familière.
La notion de genre a été introduite.Naturel. Cela permet au compilateur de déduire un type lambda sans le convertir manuellement en délégué ou en expression. Cela crée un code plus lisible lors de l'affectation d'un lambda à une variable :
//C#9 Func<un magnifique, int> àInt = (un magnifique s) => int.Parse(s); //C#10 var àInt = (un magnifique s) => int.Parse(s)
Le compilateur déduira le type toInt comme Func Cela s'affichera lorsque le code sera affiché dans Visual Studio. Les inférences utiliseront les délégués Func, Action ou composés.
Les types naturels ne fonctionneront que lorsque l'expression lambda est déjà écrite en entier. Si vous omettez des types de paramètres, le compilateur ne pourra pas créer une définition de type compatible.
Un changement connexe est la prise en charge des types de retour explicites. Comme pour une fonction normale, le type de retour précède la liste des paramètres lambda :
var àInt = int (un magnifique s) => int.Parse(s)
Enfin, les lambdas peuvent désormais prendre des attributs au même titre que les méthodes et les fonctions. Ils sont placés au début d'une expression lambda, avant le type de retour et la liste de paramètres. Vous pouvez utiliser des attributs pour attacher des métadonnées supplémentaires à vos caractères lambda afin de faciliter une introspection et une analyse de code plus poussées.
var àInt = [DémoAttribut()] int (un magnifique s) => int.Parse(s)
Tâches polyvalentes et décousues
Les affectations de désassemblage peuvent désormais initialiser de nouvelles variables et affecter des valeurs aux variables sur la même ligne. Auparavant, j'avais besoin d'utiliser des désassemblages séparés pour ces opérations.
En C# 9, cela résultait en un code qui ressemblait à ceci :
int x = 0; int y = 0; (x, y) = point; (int z) = point;
Alors qu'en C# 10 vous pouvez faire ceci :
int x = 0; int y = 0; (x, y int z) = point;
x, y et z seront désormais initialisés avec des valeurs à l'aide de la tâche de désassemblage unique, réduisant ainsi la redondance dans le code.
Autres changements
L'interpolation des chaînes a été améliorée et fonctionne désormais également avec les chaînes statiques. Vous devez vous assurer que toutes les chaînes utilisées pour remplir les espaces réservés pendant l'interpolation sont elles-mêmes des valeurs constantes. À plus grande échelle, les améliorations de l'interpolation peuvent réduire l'utilisation de la mémoire et augmenter les performances grâce à l'utilisation de processeurs dédiés.
Les modèles de propriétés ont été simplifiés pour fournir un accès plus lisible aux propriétés imbriquées. Vous pouvez désormais utiliser la syntaxe à points pour accéder aux valeurs de propriété imbriquées, plutôt que plusieurs couches de parenthèses :
//C#9 { Train: {Heure d'arrivée: "10: 00"} } //C#10 { Train.Heure d'arrivée: "10: 00" }
Ailleurs, les optimisations du compilateur signifient que vous bénéficierez de moins de faux positifs lors des vérifications d'affectation et d'état nul. Plusieurs problèmes C#9 qui entraînaient de faux avertissements au moment de la compilation ont été résolus, ce qui a donné lieu à des vérifications plus précises et mieux équipées pour vous aider à déboguer les problèmes vraiment importants. Des problèmes étaient associés à l'utilisation d'expressions à intégration nulle et de constantes de covariable par rapport à des constantes booléennes.
Conclusion
C# 10 ajoute plusieurs nouvelles fonctionnalités qui aideront à rendre le développement plus simple. Cependant, il a De nombreuses autres nouvelles fonctionnalités ont été retournées Y compris le mot-clé de champ et les propriétés requises vers la prochaine version majeure. il a été complété Transformation d'attribut membres de résumé publics et statiques pour les interfaces à 10 mais toujours attachés à la balise d'aperçu.