Les nouveautés de C#6

Visual Studio 2015 nous arrive avec une version 6 de son langage de programmation phare qui propose quelques nouvelles fonctionnalités plutôt sympathiques.

L’objectif de cet article et de faire un état des lieux et de montrer des cas d’utilisation courantes de ces nouveautés.

Le mot clé nameof

Le mot clé nameof renvoie le nom d’un paramètre, d’un membre ou d’un type sous la forme d’une chaîne de caractères.

L’exemple ci-dessous montre la validation des paramètres obligatoire en entrée d’une méthode publique à l’épreuve du rename-refactoring :

https://gist.github.com/PendingChanges/2d9c8b2bae530958cb69

Il est aussi possible de l’utiliser avec le nom d’une méthode, un delegate, etc. Très utile pour logguer le nom d’une méthode par exemple et d’éviter d’avoir un déphasage entre ce qui est loggué et le nom de la méthode après un renommage de celle-ci :

https://gist.github.com/PendingChanges/34d4333e91ed488e456f

Interpolation de chaînes de caractères

L’interpolation de chaînes de caractères qui s’apparente à la méthode String.Format, permet en préfixant une chaîne du caractère $ de remplacer certaines parties de celle-ci par le contenu d’une variable. La syntaxe est moins lourde que le String.Format et semble plus naturelle :

https://gist.github.com/PendingChanges/267dc4909a214041f462

Opérateur de condition null

L’opérateur de condition null, fonctionnalité très intéressante. Cet opérateur « ?. » permet de propager null lors de l’accès aux membres d’un objet si cet objet est lui même null.

https://gist.github.com/PendingChanges/eab07b462b6242f29d69

Cependant, il faut prendre cet opérateur avec des pincettes. Si son utilisation est séduisante, il fait perdre l’habitude ancestrale du test de nullité sur un objet dont on ne connait pas l’initialisation. Même si la finalité reste la même, ce qui se cache derrière l’opérateur « ?. » saute quand même moins aux yeux qu’un bon vieux test de nullité.

Propriétés en lecture seule

Les propriétés en lecture seule qui ont pour corps une seule expression se voient parées d’une nouvelle syntaxe simplifiée :

https://gist.github.com/PendingChanges/82b7875e9d37e18fe711

Propriétés automatiques

Les propriétés automatiques peuvent maintenant être initialisées et n’ont plus besoin de setter. Prenons l’exemple des collections publiques, généralement le setter est privé et la collection est initialisée dans le constructeur comme le montre l’exemple suivant :

https://gist.github.com/PendingChanges/6690112a8e5bd1b22682

La syntaxe se voit simplifiée et permet l’initialisation « in-line » de la propriété :

https://gist.github.com/PendingChanges/d26b6f52a6612be79416

Initialiseurs d’indexs

C#6 simplifie l’initialisation des dictionnaires en simplifiant la syntaxe amenée par C#3. Chaque paire clé-valeur du dictionnaire peut être ajouté à celui-ci de la manière suivante :

https://gist.github.com/PendingChanges/123ae45970051144d75c

Filtres d’exception

Un des ajout que j’affectionne  tout particulièrement. Il est désormais possible de filtrer les exceptions attrapées par un catch sur n’importe quelle condition. Cela permet de fluidifier la gestion des exceptions et même d’éviter la duplication d’une partie du code.

Avant C#6, pour effectuer une action différente en fonction d’une caractéristique propre à l’exception, il fallait écrire quelque chose comme ceci :

https://gist.github.com/PendingChanges/c4ed7029f5eed93592f4

Maintenant, les tests effectués sur l’exception peuvent s’écrire directement après le catch, permettant ainsi de supprimer la duplication de code gérant les erreurs inconnues (à noter que lorsque le sujet était à l’étude, il avait été question du mot clé if et non du mot clé when) :

https://gist.github.com/PendingChanges/9b7192689c6394536fb2

Directive « using static »

Pour le coup, je ne suis absolument pas fan de cet ajout qui me parait complètement dispensable. Il est maintenant possible d’écrire des directives using pour les classes statiques afin d’utiliser directement la méthode issue de cette classe. Un exemple avec le carré d’un nombre :

https://gist.github.com/PendingChanges/54162f2b89ec4284ced3

Await dans les blocs catch et finally

Tout est dans le titre. Il est maintenant possible d’utiliser le mot clé await dans les blocs catch et finally pour effectuer des actions asynchrones lorsqu’une exception est attrapée.

Cas d’utilisation courante : Il est donc possible maintenant d’afficher directement des messages d’erreur dans des application Windows Store sans passer par une solution de contournement tordue :

https://gist.github.com/PendingChanges/966e38d3d415c249e40e

Conclusion

Cette nouvelle version apporte son petit lot de nouveautés mais on se rend bien vite compte qu’elle ne bouleversera pas les méthodes de développement comme l’avait pu faire C#2 (généricité) ou C#5 (programmation asynchrone). Il s’agit plus d’ajouts venant simplifier la syntaxe et la maintenabilité du code que de grosses innovations.

Il faut quand même noter que cette nouvelle mouture de C# n’est pas dépendante d’objets introduits par une nouvelle version du framework .NET et ne nécessite pas d’évolution de la CLR. Il est donc tout à fait possible de profiter de ces nouvelles fonctionnalités sur des versions antérieures du runtime (il est possible de compiler un projet .NET 2.0 en utilisant nameof ou l’interpolation de chaînes). Un point positif pour les vieux applicatifs présents encore dans certaines entreprises.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.