A chaque nouvelle version de C#, son lot d’évolutions. Il y en a qui sont utiles, d’autres superflues, chacun jugera. Avouons quand même que depuis la C#3, il n’y a rien eu de révolutionnaire. C’est sans doute le signe que ce langage a atteint la maturité. Voyons ce que nous propose C# 7:
Les variables out
Il est désormais possible de déclarer les variables out lors de leur utilisation. Au lieu d’écrire:
int result;
if (int.TryParse("41", out result));
Console.WriteLine(result); // affiche 41
On peut écrire:
if (int.TryParse("41", out int result));
Console.WriteLine(result); // affiche 41
Plus besoin de déclarer les variables de sortie out avant de les utiliser. Pas révolutionnaire mais plus élégant.
Les séparateurs
Les séparateurs apportent de la lisibilité lorsqu’on utilise de grands nombres. Seul l’affichage change, les valeurs restent les même. L’underscore (_) pourra désormais jouer le rôle de séparateurs entre les chiffres.
Par exemple:
var dec = 123_456; var hex = 0xABC_DEF_123; var bin = 0b1010_1011_1100_1101_1110_1111;
Pattern matching
C# 7 permet l’utilisation de pattern. Un pattern permet de tester qu’une variable correspond à un certain modèle. Aujourd’hui, il existe :
- des pattern constante. On vérifie que la variable correspond à la valeur testée
string s;
if(s is null) Console.WriteLine("OK"); // affiche OK, car s est null
- des pattern type. On vérifie que notre variable est d’un type particulier et si oui on crée une nouvelle variable à laquelle on affecte la valeur de la précédente.
object i = 5; if(i is int j) Console.WriteLine(j); // affiche 5
Là où les pattern seront très utiles c’est dans les switchs. Désormais:
- on peut utiliser n’importe quel type avec les switchs et plus uniquement les types primitifs
- on peut utiliser les patterns sur les switchs
- on peut ajouter d’autres conditions à la clause case
switch(forme)
{
case Cercle c:
WriteLine($"cercle de rayon {c.Radius}");
break;
case Rectangle s when (s.Length == s.Height):
WriteLine($"Carré {s.Length} x {s.Height}");
break;
case Rectangle r:
WriteLine($"Rectangle {r.Length} x {r.Height}");
break;
default:
WriteLine("Forme inconnue");
break;
case null:
throw new ArgumentNullException(nameof(shape));
}
Les tuples
Avant C# 7, pour qu’une fonction retourne plusieurs valeurs, on pouvait:
- créer une classe ou une structure
- utiliser le type Tuple
- utiliser des paramètres out…
Désormais avec les Tuples de C# 7, nos fonctions pourront renvoyer plusieurs valeurs typées et nommées.
public (int sum, int count) MaFonction(IEnumerable<int> values)
{
var res = (sum: 0, count: 0);
foreach(var value in values)
{
res.sum += value;
res.count++;
}
return res;
}
/* ... */
// utilisation de la MaFonction
List<int> values = new List<int>();
values.Add(1);
values.Add(2);
var res = MaFonction(values);
Console.WriteLine($"nombre={res.count}"); // affiche nombre=2
Console.WriteLine($"somme={res.sum}"); // affiche somme=3
Les fonctions locales
Il arrive qu’on ait besoin de créer une fonction qui ne sera utilisée que dans une autre. Pour ce type de problème, C# 7 propose les fonctions locales. Il est désormais possibles de créer une fonction dans une autre fonction.
public int MaFonction(int nombre)
{
int MultipliePar2()
{
return nombre*2;
}
return MultipliePar2();
}
/* ... */
// utilisation de MaFonction
Console.WriteLine(MaFonction(3)); // affiche 6
Les paramètres et variables de la fonction MaFonction sont accessibles à la fonction locale.
Conclusion
Cet article nous a permis de faire un petit tour d’horizon des nouveautés de C# 7. En résumé, pas de gros changements mais fonctionnalités qui faciliterons la vie des développeurs. La plus intéressante pour moi est le pattern matching.
Laisser un commentaire