Dot.Blog

C#, XAML, Xamarin, UWP/Android/iOS

C# 6 et ses petites nouveautés

[new:30/05/2014]C# va arriver en version 6. Chacune de ses versions a été l’occasion de petites ou de grandes avancées. Que nous réserve la 6ème cuvée ?

C# et Roslyn

C# Major ScaleComme je vous en ai déjà parlé je ferai court : Roslyn est un ensemble de compilateurs et d’API d’analyse Open Source releasé par Microsoft principalement autour de C# et de VB, donc sous .NET.

C# 6 qui sera releasé dans quelques temps reprendra ce que Roslyn aura apporté. Connaître l’un c’est donc prévoir ce que contiendra l’autre…

Roslyn n’est pas forcément une nouveauté, la première CTP datant d’octobre 2011… Le temps passe vite ! D’autres ont suivi. La dernière qui nous rapproche de la version finale date du Build de San Francisco en avril dernier, ce qui devient déjà plus “frais” comme information !

On sait d’ailleurs que Xamarin a annoncé à cette occasion que le nouveau compilateur et ses outils seront intégrés à Xamarin Studio.

Il existe un package Nuget pour VS 2013 qui permet de tester Roslyn (déjà téléchargé plus de 10.000 fois). Toutes les fonctionnalités ne sont pas encore implémentées toutefois. Ce qu’on sait en revanche c’est que Roslyn définit des features qui seront intégrées à C# 6 et à VB 13.

Un peu tôt pour s’avancer ?

Il est peut-être un peu tôt pour s’avancer sur les fonctionnalités qui seront, in fine, choisies et intégrées dans ces deux derniers langages, indépendamment de ce que Roslyn proposera. Mais ce n’est pas non plus jouer les Madame Irma que de lire dans les lignes de Roslyn le futur de C# 6 car les uns et les autres sont liés, voire destinés à n’être plus qu’un, un jour.

Quelques exemples

Puisque C# 6 n’existe pas encore et puisque Roslyn s’approche de la version finale, on peut tout de même se lancer à quelques prédictions. Dans tous les cas il s’agit d’un compilateur C# de Microsoft. Il a peu de chance qu’ils divergent beaucoup et certaines informations ont tout de même été données par des gens de Microsoft…

En annonçant C# 6 on peut se poser la question de savoir que peut-on _encore_ ajouter à C# ?

Et répondre est assez facile : pas grand chose…

Le langage a tellement évolué avec les expressions Lambda, Linq, et tout un tas de choses dont j’ai parlé en long et en large qu’il semble bien peu probable que C# 6 contienne des avancées fantastiques. C# est déjà fantastique.

C’est donc plutôt du côtés des “syntactic sugar”, ces petites gâteries syntaxiques qui facilitent l’écriture qu’il faut regarder. Les grandes nouveautés qui cassent la baraque ne font pas partie du lot des nouveautés, elles sont déjà dans C# 5 et ses prédécesseurs…

Toutefois le principe même de Roslyn et de ses API, son code Open Source, tout cela peut être vu comme un énorme changement pour C# et VB. Toutes les grandes avancées ne se traduisent pas forcément par l’ajout de nouveaux mots clé dans le langage.

Les propriétés

Les propriétés automatiques de C# sont très pratiques. J’avoue ne pas trop les utiliser car en MVVM on s’oblige plutôt à propager les changements de valeurs avec INPC et cela n’est pas possible avec des propriétés automatiques. Et c’est bien dommage.

Mais ce n’est pas cet ajout que nous réserve C# 6 mais plus simplement la possibilité d’initialiser la valeur d’une propriété automatique et read-only (cela limite un peu les cas) sans passer par du code dans le constructeur de la classe.

Ainsi le code suivant :

public int MaPropriété { get; } = 256;

permet de déclarer la propriété automatique “MaPropriété”, de type entier, possédant un getter et pas de setter (elle est donc bien read-only) tout en l’initialisant à la valeur 256.

Cela peut servir mais ce n’est pas “killer” je vous l’accorde.

Les initialisations

Initialiser des valeurs est souvent fastidieux. Alors autant en simplifier la syntaxe. Ainsi tout objet qui supporte un indexeur peut être initialisé en référençant directement les index. Par exemple un dictionnaire :

var d = new Dictionary<string,int>{ [“A”]=22, [“B”]=100, [“robert”]=0 };

Les entrées dans le dictionnaire pour les index “A”, “B” et “robert” sont créées et les valeurs indiquées sont affectées à ces nouvelles entrées. Pas besoin de passer une fois encore par le code du constructeur ou tout autre code d’initialisation.

L’accès aux propriétés indexées peut aussi se faire en utilisant plutôt une syntaxe de type propriété que index, le code suivant clarifiera cette phrase confuse … :

MonObjetIndexé[“toto”]=22;

s’écrira aussi MonObjetIndexé.$toto = 22;

La valeur de l’index précédée du signe dollar forme comme un nouveau nom de propriété et s’écrit précédée du point comme toute propriété.

Plus exotique est la classe définit par un code qui va créer automatiquement les propriétés et les initialiser. Ainsi :

public class UnPoint(int x, int y) { }

est un raccourci plutôt amusant pour le code suivant :

public class UnPoint
{
  private int x,y;
  public UnPoint(int x, int y)
  {
   this.x = x;
   this.y = y;
  }
}

Amusant non ?

Bon comme je l’annonçais ça ne casse pas la baraque, c’est vrai.

Et que dire que de :

var b = new Button { OnClick+=monGestionnaireDeClic};

Ce code créée une nouvelle instance de Button et attribue en même temps l’adresse de “monGestionnaireDeClic” (qu’on suppose définit ailleurs bien entendu) à l’év��nement OnClick… On dirait presque du JavaScript, ce qui en ravira certains et fera faire la moue à d’autres comme moi.

Expressions et littéraux

Si les astuces précédentes ne vous feront peut-être pas sauter de joie, celle qui vient saura peut-être vous convaincre de l’intérêt de ces nouvelles syntaxes de C# 6 :

var x = (var y=rnd(10);y*y);

Bizarre non ? C’est l’utilisation du point virgule qui fait tout ici. Il permet de chaîner des expressions, la valeur finale étant celle de la dernière.

Dans le code exemple cela attribuera à x la valeur du carré d’un nombre aléatoire (en supposant rnd() une fonction retournant un tel nombre).

L’intérêt ? Comme on le voit dans cet exemple il n’est pas toujours possible d’attribuer à une variable le résultat d’une suite d’opérations sans passer par un code intermédiaire. Ici effectuer le carré dans rnd() n’aurait pas la même signification, de même faire un rnd(10*rnd(10) effectuerait deux tirages au sort ce qui est très différent.

En chaînant les opérations par un point virgule on peut définir des valeurs complexes en faisant l’économie de plusieurs lignes de code “intermédiaire”.

Pas fantastique mais pouvant ajouter de la clarté au code.

Dans un même esprit :

var y =  (int x = 3) * 3 ;

Ce code attribuera la valeur “9” à y en définissant “x” à 3…

C# 6 ajoutera comme Roslyn les littéraux binaires. Cela est parfois utile. On pourra donc écrire
var b = 0b0100; pour définir b à “100” binaire, soit 4 en décimal.

Comme le binaire ou l’hexadécimal sont généralement des valeurs qu’on peut découper en unités ayant un sens (par demi octet, octet, double, etc) il sera possible d’ajouter des soulignés pour séparer les groupes sans perdre le caractère numérique du littéral : int x = 0xFF_00_0A_A0 ; est plus lisible sans erreur que 0XFF000AA0;

On notera enfin que les méthodes statiques seront plus faciles à utiliser ce qui sera une vraie simplification. Prenons le code suivant :

var b = Math.Sin(Math.Sqrt(5));

Il sera plus agréable d’écrire (et plus facile à lire) :

using System.Maths;

var b = Sin(Sqrt(5));

Exceptions

Normalement C# 6 devrait introduire la possibilité d’appeler du code asynchrone dans les parties  Catch et Finally des blocs Try :

try
{
  … code …
}
catch {
await cleanUp(yyy); }
finally {
await cleanUp(xxx); }

Une autre possibilité intéressante consistera à pouvoir utiliser des filtres dans les Catch :

try { code… } catch(Exception e) if (e.xxx=22) { …bloc catch… }

Ou en est-on ?

Il ne s’agit pour l’instant que de simples exemples de ce que devrait contenir C# 6. Pour savoir où en est l’implémentation de Roslyn et ce qui sera surement - ou pas - intégré à C# et VB on peut consulter la page “language feature implementation status” – le statut de l’implémentation des possibilités du langage – en accédant sur CodePlex via une URL très longue que je vous propose en format raccourci : http://goo.gl/pi0jIA

Conclusion

C# 6 sera une cuvée sage, avec quelques petits su-sucres syntaxiques pas forcément tous utiles mais dont on deviendra certainement addict de l’un ou de l’autre…

C# est un langage qui est arrivé à une maturité étonnante, il a su grandir sans exploser, mais il arrive maintenant à un plateau : faire beaucoup mieux que la version précédente va devenir de plus en plus difficile.

En général c’est là qu’un produit meurt en informatique. Il y a une certaine connerie partagée, n’ayons pas peur des mots, qui veut que si une plateforme ou un langage n’apporte pas de nouvelles fonctionnalités “awesome” c’est qu’il “stagne”, donc qu’il est mort.

C’est une connerie disais-je parce que bien entendu cela signifie juste que le produit est mature et peut enfin être pleinement utilisé en toute sérénité pour faire des choses intelligentes avec…

C# arrive à ce point.

L’intelligence qui consistera à s’en servir pour faire de beaux logiciels l’emportera-t-elle sur la connerie qui voudra y voir un langage “en panne”, “hasbeen” ?

Je connais trop mon métier pour me risquer à une prévision !  Et vous ?

PS: Pour les curieux, la portée qu’on découvre en début d’article est la gamme de do dièse majeur, donc C# en notation américaine…

Stay Tuned !

blog comments powered by Disqus