Lors des Techdays 2015, Microsoft nous avait présenté les nouveautés du C# 6. Bonne nouvelle, cette nouvelle version du language est incluse dans dernière version du Framework .NET , 4.6, sortie en Juillet. Quoi de neuf ? Rien de bien excitant, mais toute nouveauté est bonne à prendre. Passons en revue, ces fonctionnalités.

Exception conditionnelle

Jusqu’à maintenant on pouvait « catcher » une exception en se basant sur son type. Désormais on pourra rajouter une condition.

try
{
    throw new Exception("Mon exception est trop cool");
} 
catch (Exception ex) when (ex.Message.Contains("cool"))
{
    throw ex;
}
catch (Exception ex)
{
    throw ex;
}

L’initialisation des indexeurs

C# 6 introduit une nouvelle manière d’initialiser les dictionnaires et les propriétés indexées.

var maFamille = new Dictionary<string, int>
{
    ["papa"] = 60,
    ["maman"] = 58,
    ["moi"] = 30
};

Prenons la classe indexée suivante:

class MaClasse
{
    private string[] prenoms = new string[10];

    public string this[int i]
    {
        get
          {
              return prenoms[i];
          }
        set
          {
              prenoms[i] = value;
          }
     }
}

On peut initialiser facilement les valeurs liées à l’index

MaClasse classe = new MaClasse {[1] = "jean",[2] = "pierre" };
Console.WriteLine(classe[2]); // affiche pierre

L’initialisation des auto propriétés

Avant il n’était pas possible d’initialiser les auto properties, ça c’était avant. La fonctionnalité a été ajoutée à C# 6.

public class CLient
{
    public string Nom { get; set; } = "Dupond";
    public string Prenom { get; set; } = "Jean";
}

Désormais, on peut aussi initialiser les propriétés en lecture seule:

public string Prenom { get; } = "Jean";

L’instruction nameof

Elle permet de retourner le nom d’une variable, d’un type ou d’un autre membre sous la forme d’une chaîne de caractère.

string s = nameof(MaClasse); // renvoie "MaClasse"
string s2 = nameof(Console.WriteLine); // renvoie "WriteLine"

Import statiques

Cette fonctionnalité permet d’appeler les méthodes statiques avec une syntaxe réduite. Ainsi pour appeler la méthode Sqrt du namespace System.Math, plus besoin d’écrire System.Math.Sqrt, Sqrt suffira.

using static System.Console;
using static System.Math;

namespace ConsoleApplication1
{
    class Program
    {
         static void Main(string[] args)
         {
              Console.Write(Sqrt(81));
        }
    }
}

Simplification de l’écriture des méthodes et fonctions

Désormais l’écriture des méthodes est simplifiée.

public void AfficherMessage(string msg)
{
    WriteLine(msg);
}

équivaut à

public static void AfficherMessage(string msg) => WriteLine(msg);

Une syntaxe qui rappelle les expressions lambda.

Le nouvel opérateur ?.

On passe notre vie de développeur à tester si un objet est null. Combien de fois on se mange des NullReferenceException, lorsqu’on oublie ce test. Avec le nouvel opérateur ?.

string nom= client?.Nom;

équivaut à

string nom = client!= null ? client.Nom : null;

Interpolation de string

Plus besoin de s’épuiser avec des String.format("{0} {1}..."). On pourra écrire directement les valeurs dans la chaîne de caractères.

Exemple:

string s = $"Nom du client {client.Nom} , prénom du client {client.Prenom}"; 

Penser à mettre le préfixe $, il indique qu’il s’agit d’une chaîne interpolée.

Loin d’être révolutionnaires, ces nouveautés faciliteront quand même la vie des développeurs. Mes fonctionnalités préférés : l’interpolation de string et les conditions dans les exceptions.

Sources:
http://tlevesque.developpez.com/tutoriels/csharp/les-nouveautes-de-csharp-6/
http://blogs.msdn.com/b/cdndevs/archive/2015/08/10/new-features-of-c-6.aspx
http://blogs.msdn.com/b/dotnet/archive/2015/07/20/announcing-net-framework-4-6.aspx