async Task Main()
Les mots clés async et await, qui ont été apportés par C # 5.0 facilitent l’écriture du code qui appelle des systèmes externes, ou fait des E/S, sans bloquer un thread. Cela rend les applications Web évolutives et conserve la réactivité des IU d’applications.
Cependant, une fois qu'une partie de votre code est asynchrone, tout ce qui implique ce code doit également devenir asynchrone. Lorsque votre application d'hébergement est une application de console ou un service Windows, cela pose un problème. Vous pouvez écrire async void Main, mais cela signifie que, dès que vous arrivez à votre premier await, l’application entière se termine.
La raison ? async void, qui agit comme un mécanisme de prévention des incendies. Étant donné que vous ne pouvez pas retourner une Task de Main, vous devrez utiliser quelque chose comme AsyncContext depuis la bibliothèque AsyncEx.
Microsoft explique que cela ne sera plus nécessaire : le compilateur et le framework reconnaîtront et exécuteront correctement une méthode Async Task Main.
Les expressions default :
Il s'agit simplement d'une amélioration de quelque chose qui a été supporté depuis C # 2.0 et l'avènement des génériques, en 2005. Il est sous forme de default (T), où T est bien sûr un type. Pour les types de référence, il représente null, et pour les types de valeurs tels que int, il représente la valeur par défaut, non initialisée, de ce type.
La nouvelle fonctionnalité est que, lorsque le type de T peut être déduite, il n'est plus nécessaire de le spécifier.
En clair, au lieu d’écrire ceci
Code C# : | Sélectionner tout |
int x = default(int);
Vous pourrez écrire ceci
Code C# : | Sélectionner tout |
int x = default;
Bien sûr, cela s'étend également à d'autres usages de default, tels que les déclarations de retour, les valeurs par défaut pour les arguments, et, en développant le point précédent, les expressions ternaires.
Pour illustrer, ceci sera valide dans une future version de C #
Code C# : | Sélectionner tout |
var x = flag ? 1: default;
Déduction des tuples
Supposons que vous voulez créer le tuple (string Nom, string Prenom) et que vous avez déjà des variables locales appelées Nom et Prenom. Vous devez écrire quelque chose comme ceci :
var t = (fNom: Prenom, SecondNom: SecondPrenom);
Cette fonctionnalité va déduire les noms des éléments de tuple à partir de leur expression d'initialisation, un peu comme ce que vous pouvez faire avec des types anonymes.
Code C# : | Sélectionner tout |
1 2 3 | var t = (Nom, SecondNom); Console.WriteLine($"Salut, {t.Nom}!"); |
C # 7.2
Références read-only
Ici, il s’agit de donner à C # la possibilité d'utiliser des paramètres const-like pour améliorer les performances. Connu sous le nom de « paramètres réellement définis » ou « paramètres » simples, ceux-ci permettent de transmettre de grandes structures par référence tout en ne permettant pas qu'elles soient mutées.
C # 8.0
Types de référence nullables
L'équipe responsable du développement de C # a, pour l'instant, choisi de faire en sorte que tous les types de référence deviendront non annulables par défaut, et vous pouvez faire en sorte qu’un type de variable soit nullable en vous servant de “?”. L'utilisation d'une variable non nulle qui pourrait être nulle (car vous ne l'avez pas vérifiée si elle avait déjà pris cette valeur) entraînera un avertissement, tout en attribuant la valeur d'une variable nulle à celle qui n'est pas nullable.
Petit exemple d’illustration
Code C# : | Sélectionner tout |
1 2 3 4 5 6 7 | // bar est nullable parce que son type est string? void Foo(string? bar) { string baz = bar; // ceci va générer un avertissement parce que baz est non-nullable // mais bar est nullable } |
Code C# : | Sélectionner tout |
1 2 3 4 5 6 7 | void Foo(string? bar) { if (bar == null) throw new ArgumentNullException(nameof(bar)); string baz = bar; } |
Source : feuille de route