Thomas Lebrun

[C#] Rappel: Les nouveautés de C# 3

J'ai reçu, en début de semaine, un mail très intéressant me demandant quelles étaient les nouvelles fonctionnalités apportées par C# 3. Même si je regrette que l'auteur de ce mail n'est pas pensé à rechercher sur Internet, je le remercie car cela me donne une bonne excuse pour en faire profiter tout le monde

Automatic properties (Propriétés automatiques):

Pour déclarer une propriété, en C#, vous devez utiliser une variable marquée comme private et utiliser des accesseurs pour y accéder:

Bien que très pratique, cette technique impose d'avoir autant de variables privées que de propriétés, ce qui n'est pas forcément idéal dans toutes les situations.

C# 3 introduit le concept de propriétés automatiques, qui vous permet de déclarer une propriété sans avoir besoin de déclarer de variables privées:

Cette technique, complètement fonctionnelle, possède cependant un inconvénient: vous êtes obligez de déclarer le set ET le get. Même si cela peut paraitre contraignant, c'est quelque chose à garder à l'esprit car cela peut se révéler très pratique dans certains cas (si vous souhaitez alléger votre code par exemple).

Object Initializers (Initialiseurs d'objet):

Lorsque l'on veut déclarer un objet, la syntaxe est généralement simple (et dépend des constructeurs disponibles):

Avec C# 3 et les initialiseurs d'objet, la syntaxe a été re-pensé: vous allez pouvoir instancier une instance d'un objet et définir, en même temps, une ou plusieurs valeurs de propriétés:

On notera au passage que l'Intellisense d'Orcas, le prochain Visual Studio, s'avère très pratique:

Bien sur, cela fonctionne avec la création d'objets mais également avec la création de collections:

Local variable type inference (Inférence de type d'une variable locale):

Pour déclarer une variable, en C#, il n'y a rien de plus simple que de faire:

Cependant, C# 3 apporte le concept d'inférence de type d'une variable locale. Techniquement, il peut arriver par moment que l'on ne sache pas le type de la variable que l'on veut déclarer: on sait par exemple que cela va être un IEnumerable<T> mais c'est tout. Grâce à ce concept, il est tout à fait envisageable d'écrire ceci:

Le type des variables déclarées est inféré/déduit lors de la compilation. Attention, étant donné que tout ce passe à la compilation, vous ne pouvez pas écrire:

Car cela provoque une erreur de compilation:

Anonymous types (Types anonymes):

C# 3 présente aussi la particularité de permettre l'utilisation de types anonymes. Pour faire simple, il s'agit de la création d'un objet, avec des propriétés particulières, sans connaitre son type de départ:

Ici, on a commencé à déclarer un objet "myself" de type Personne. On a ensuite déclarer un objet p, de type anonyme, et dont les propriétés sont celles indiqués lors de la déclaration.

Vous voyez ainsi que l'o peut réutiliser des propriétés déjà existantes mais également ajouter des propriétés qui n'existe pas: ici, j'ai ajouté, à l'objet p, la propriété Age et je peux ensuite l'utiliser dans le reste de mon application.

Lambda expressions (Expressions Lambda):

Les expressions Lambda sont, pour faire simple, une nouvelle façon d'écrire les méthodes anonymes.

Voici un code totalement fonctionnel en C# 2:

Et voici comment on pourrait écrire la même chose en utilisant C# 3 et les expressions lambda:

Assez sympa comme feature, vous ne trouvez pas

Extension methods (Méthodes d'extension):

La dernière nouvauté de la 3ème version de C# s'appelle les méthodes d'extension. Au jour d'aujourd'hui, il nous ait impossible de rajouter des méthodes aux classes dont on ne dispose pas du code source. On peut toujours trouver des parades (écrire une méthode qui prends un type en paramètre et qui renvoit un objet de ce même type, etc...) mais si je vous demandais d'ajouter une méthode à la classe String, vous me répondriez que ce n'est pas possible et vous auriez raison. Enfin, sauf si vous utilisez C# 3 et les méthodes d'extension.

Il s'agit de méthodes que vous allez pouvoir "greffer" sur un type déjà existant, comme le montre cette image:

Comme vous pouvez le voir, j'ai déclaré une chaîne de caractères et j'appelle ensuite la méthode StringToUpper. Cette méthode, vous en conviendrez, ne fait pas partit de la classe String et pourtant, je l'appelle comme toute les autres méthodes de cette classe.

Pour comprendre comment ca marche, il suffit de regarder la signature de la méthode StringToUpper: on remarque le mot clé this qui permet d'indiquer qu'il s'agit d'une méthode d'extension qui sera appliquée au type passé en paramètre.

Ainsi, il est tout à fait possible de faire ceci:

Et le résultat sera bien ce que l'on attend:

Conclusions:

Voila  pour ce petit rappel des nouveautés de C# 3. Cela n'avait pas pour but d'être une présentation exhaustive du sujet mais juste un petit mémo pour ceux qui n'aurait pas envie de chercher

Si vous voulez en savoir plus, vous pouvez jetter un oeil sur mon article: C# 3 et Linq

A+