1. Introduction

Cette troisième version du langage .Net le plus utilisé apporte un nombre intéressant de nouveautés. Je vais essayer de vous présenter les principales dans cet article. C# 3.0 a été livré en même temps que .Net 3.5 et Visual Studio 2008 et donc que LINQ.

Microsoft .Net 3.5



D'ailleurs beaucoup de ces nouveautés ont été apportées par (ou pour) LINQ. En effet LINQ étant une petite révolution dans le monde .Net il aura fallu ajouter de nouvelles fonctionnalités pour supporter cette technologie de requêtage multi-sources. Avant d'entrer plus dans les détails faisons pour commencer un rapide tour des évolutions majeures. Au de cet article menu nous avons :

  • L'inférence de type
  • Les initialiseurs d'objets
  • Les types anonymes
  • Les propriétés simplifiées
  • Les méthodes d'extension

2. L'inférence de type

L'inférence de type est un mécanisme qui permet de déduire le type d'une variable en fonction de sa déclaration. Avec C# 3.0 il est désormais possible de déclarer une variable locale sans donner son type, on utilise alors le mot clé var. Concrètement nous allons écrire le code suivant :

Inférence de type
Sélectionnez

        var s = "Bonjour";
        var ms = new MemoryStream();

Il s'agit donc d'une astuce syntaxique qui permet de rendre le code un petit peu plus lisible. L'inférence de type fonctionne sur des types simples mais également complexe comme des listes, des tableaux ou autre. Une autre raison d'être de l'inférence de type est une autre nouveauté de C# 3.0, les types anonymes qui effet l'utilisent.

L'inférence de type est vraiment facile à utiliser puisque même l'IntelliSense dans Visual Studio 2008 est mis à jour avec les bonnes propriétés et méthodes relatives au type inféré. Une variable déclaré avec le mot clé var est donc utilisable comme si l'on avait déclaré la variable avec son type "réel".

3. Les initialiseurs d'objets

Jusqu'à maintenant pour instancier un objet il n'y avait qu'une seule manière, appeler le new puis ensuite remplir les propriétés souhaitées. Ces fameuses propriétés pouvaient être renseignées directement dans le constructeur (en paramètres) à condition d'avoir un constructeur surchargé prévu à cet effet.

Prenons un exemple concret, la classe Développeur suivante :

Classe 'Developpeur'
Sélectionnez

		/// <summary>
		/// Summary description for Developpeur
		/// </summary>
		public class Developpeur
		{
		
		    private string _nom;
		    private int _age;
		
		    public string Nom
		    {
		        get { return _nom; }
		        set { _nom = value; }
		    }
		
		
		    public int Age
		    {
		        get { return _age; }
		        set { _age = value; }
		    }
		
			public Developpeur()
			{
				
			}
		
		    public Developpeur(string nom, int age)
		    {
		        _nom = nom;
		        _age = age;
		    }
		
		   
		}

Avec C# 2.0 pour instancier un objet Développeur il était possible de procéder de la façon suivante :

Instancier un objet avec C# 2.0
Sélectionnez

        Developpeur dev = new Developpeur();
        dev.Nom = "Martin";
        dev.Age = 28;

Ou alors :

Instancier un objet C# 2.0
Sélectionnez

		Developpeur dev = new Developpeur("Martin", 28);

Maintenant avec C# 3.0 il est possible de procéder ainsi :

Instancier un objet avec C# 3.0
Sélectionnez

		Developpeur dev = new Developpeur { Nom = "Martin", Age = 28 };

Cela est possible à condition que les propriétés soient déclarées comme "public". Au passage vous remarquerez que cela nous évite de devoir coder des constructeurs surchargés s'ils n'avaient pour fonction que de mapper les paramètres dans les propriétés de l'objet, ce qui est toujours un petit gain de temps appréciable.

4. Les types anonymes

Les types anonymes permettent de créer des objets contenant un certain nombre de propriétés sans pour autant qu'ils correspondent à un type réellement implémenter. En fait les types anonymes permettent en quelque sorte de créer des classes qui n'auront pour utilité que de contenir des informations. Les types anonymes ont été crées pour LINQ, en effet la clause Select utilise les types anonymes pour créer une structure qui va contenir le sous ensemble retourné par la requête puisque par avance nous ne connaissons pas ce qui va être retourné.

Voici un exemple de type anonyme pour voir plus clair sur cette nouveauté qui est assez déroutante pour les développeurs .Net.

Déclarer un type anonyme
Sélectionnez

		var developpeur = new { Nom = "Martin", Technologie = ".Net", Age = 28 };

Comme vous le voyez, on crée un type "Developpeur" et ses propriétés sont immédiatement accessibles dans l'IntelliSense, le compilateur va alors attribuer un type " fictif " à notre type anonyme et celui-ci ne sera connu que du compilateur lui-même. Les champs de notre type anonymes seront typés grâce à l'inférence de type.

Au-delà de l'utilisation des types anonymes dans LINQ, ils pourront être utilisés quand il est nécessaire d'utiliser un certain nombre de propriétés en même temps, en clair ils pourront servir de "structure porteuse".

5. Les propriétés simplifiées

Vous savez autant que moi à quel point il peut être ennuyeux de créer des propriétés à la chaine, et même avec les fonctions de refactorisation de Visual Studio 2008 cela est toujours très long. Microsoft à eu la bonne idée avec cette nouvelle version du langage C# de nous simplifier un petit peu la tache en ajoutant une fonctionnalité qui même si elle n'est pas forcément hallucinante peut faire gagner quelques secondes. Jusqu'à maintenant pour créer une propriété il fallait avoir un champ privé vers lequel les accesseurs (get et set) aller pointer, maintenant cela n'est plus forcément nécessaire, le simple fait de déclarer un get et un set va faire que le compilateur C# va créer automatiquement le champ privé (et bien oui y a pas de magie, il faut bien un champ privé à un moment ou a un autre...). Concrètement cela donne cela :

Déclarer une propiété avec C# 3.0
Sélectionnez

	public string UnePropriete { get; set; }
	public int UneAutrePropriete { get; set; }

Et voilà comment l'on peut écrire une propriété très rapidement en C# 3.0. Pas la peine d'écrire de champs privés que l'on aurait ensuite mappés dans nos propriétés.

6. Les méthodes d'extension

Les méthodes d'extension sont une autre nouveauté surprenante de la version 3 de C#. Grâce aux méthodes d'extension il est possible d'ajouter des méthodes à un type donné sans le modifier, le dériver ou même en posséder le code source. Une fois de plus cette nouveauté a été impulsée par les besoins de LINQ, définitivement LINQ est vraiment LA nouveauté de .Net 3.5, C# 3.0 et VB9 !

Grâce à une syntaxe particulière l'on pourra greffer une nouvelle méthode à un objet existant. Attention cependant il y à quelques limitations qui permettent d'éviter le "n'importe quoi". Il n'est pas possible à ce nouveau code d'accéder aux membres privés d'une classe, de plus les méthodes d'extension seront forcément statiques.

Pour créer une méthode d'extension c'est très simple, il faut tout d'abord créer une classe statique, y placer la méthode que l'on souhaite ajouter, déclarer cette méthode comme statique. Il faut de plus ajouter le mot clé "this" juste avant le premier paramètre qui doit être du type que l'on souhaite étendre. Voici un exemple concret :

Ajouter une méthode avec C# 3.0
Sélectionnez

public static class StringClassExtension
{
    // Cette méthode retourne la longueur de la chaine 
	// (je sais, la propriété Lenght fait déjà  cela... :))
    public static int GetLenght(this String oneString)
    {
        return oneString.Length;
    }
}

L'IntelliSense est immédiatement mis à jour et il n'est pas nécessaire de recompiler le code pour bénéficier de cette nouvelle méthode dans la classe String comme le montre l'exemple ci-dessus. Pour faire la différence dans l'IntelliSense une nouvelle icône a été ajoutée pour montrer qu'il s'agit d'une méthode d'extension et non une méthode classique.

7. Conclusion

Voilà j'espère que ce tour d'horizon des principales nouveautés apportées par le langage C# 3.0 vous aura convaincu de les utiliser. Comme nous l'avons vu beaucoup de ces nouveautés sont reliées à LINQ qui a demandé une grande évolution des langages et de leur syntaxe pour être aussi facilement utilisable.

Ces évolutions bien qu'utile principalement dans le cadre de l'utilisation de LINQ pourrons aussi être utiles dans de nombreuses situations et pourront permettre d'avoir un code plus court et plus lisible, donc d'augmenter encore la productivité des développeurs .Net.

Ressources