Synthèse des fonctionnalités du langage C# par version

Pour avoir plus de détails sur la version du langage par rapport aux versions de framework, se reporter à Versions des composants .NET.

C# 6.0

    Visual Studio 2015

  • Version implémentée avec Roslyn.
  • Initialiseurs pour implémenter automatiquement les propriétés:
    public class ItemId
    { 
        public Guid Id { get; } = Guid.NewGuid();
    }
  • Utiliser des directives using static pour importer des membres statiques:
    using static System.Console;
    
    public class Driver
    {
        public static void Main()
        {
            WriteLine("Hello, World!");
        }
    }
  • Filtres d’exceptions:
    try
    {
        ...
    }
    catch (Exception ex) if (ex.Message.Contains("Invalid Operation Exception"))
    {
        ...
    }
    
    try
    {
        ...
    }
    catch (Exception ex) when (ex.Message.Contains("Invalid Operation Exception"))
    {
        ...
    }
  • Interpolation de chaines de caractères:
    En plus de la syntaxe utilisant string.Format() comme:

    class dto
    {
      public const string StringMember = "des mots";
      public const int IntMember = 34;
      public const bool BoolMember = false;
    }
    
    string s = string.Format("Chaine de caractères contenant {0} puis {1} et {2}.", 
      dto.StringMember, dto.IntMember, dto.BoolMember);

    On peut dorénavant utiliser une syntaxe plus claire:

    string s = $"Chaine de caractères contenant {dto.StringMember} puis {dto.IntMember} et {dto.BoolMember}.";
  • Initialisation indexée de membres:
    var indexedMemberDict = new Dictionary<string, string>()
    {
      ["apple"] = "pomme",
      ["tomato"] = "tomate",
      ["water"] = "eau"
    };
  • Possibilité d’utiliser await dans un bloc catch et finally,
  • Opérateur nameof: il permet de retourner le nom d’une variable ou d’une méthode sous forme de chaîne de caractères:
    Si on considère la classe:

    class SimpleClass
    {
      public static string SimpleMember { get; set; }
      public static int SimpleMethod { return -1; }
    }

    On peut obtenir directement le nom du membre SimpleMember en faisant:

    string memberName = nameof(SimpleClass.SimpleMember); // Retourne "SimpleMember"
    string methodName = nameof(SimpleClass.SimpleMethod); // Retourne "SimpleMethod"
  • Opérateur ?.:
    Cet opérateur est un équivalent de:

    string value = person != null ? person.Name : null;

    On peut dorénavant utiliser la syntaxe:

    string value = person?.person.Name;
C# 5.0

    Visual Studio 2012

  • Programmation asynchrone plus facile avec les mot-clés async et await,
  • Attribut permettant de connaître l’appelant:
    public void DoProcessing()
    {
        TraceMessage("Something happened.");
    }
    
    public void TraceMessage(string message, 
        [CallerMemberName] string memberName = "",
        [CallerFilePath] string sourceFilePath = "", 
        [CallerLineNumber] int sourceLineNumber = 0)
    { ... }
C# 4.0

    Visual Studio 2010

  • Typage dynamique avec dynamic,
  • Arguments nommés et facultatifs:
    static void Main()
    {
      MethodExample(status: "KO", size: 5);
      MethodExample(5);
    }
    
    static void MethodExample(int size, string status = "OK")
    { ... }
  • Covariance et contravariance pour les interfaces et les délégués génériques.
C# 3.0

    Visual Studio 2008

  • Ajout des mot-clés select, from et where pour la fonctionnalité LinQ,
  • Expressions Lambda:
    Action<int> deletePerson = (id) => { ... };
    Func<int, int, int> addNumbers = (a, b) => a + b;
  • Méthodes d’extension:
    public static class ListExtensionMethods
    {
        public static string GetString(this List<int> items)
        { ... }
    }
    
    // Utilisation de la méthode d'extension:
    List<int> items = new <int>();
    string listAsString = items.GetString();
  • Arbres d’expressions ("expression trees"):
    // Création d'un arbre d'expressions
    Expression<Func<int, bool>> exprTree = num => num < 5;
  • Type implicite avec var: var idList = new List();.
C# 2.0

    Visual Studio 2005

  • Types génériques:
    public class CustomList<TItem> 
    {...}
  • Méthodes anonymes:
    // Création d'un délégué
    delegate void AddNumbers(int x, int y);
    // Instantiation du délégué en utilisant une méthode anonyme
    AddNumbers d = delegate(int i, int j) { ... };
  • Types nullables: int? = null;
  • Nouvel itérateur avec le mot-clé yield.
Share on FacebookShare on Google+Tweet about this on TwitterShare on LinkedInEmail this to someonePrint this page

Leave a Reply