Connaissez-vous les nouveautés introduites dans le langage C# version 3 ? Elles sont très intéressantes pour gagner en efficacité et pour rédiger du code plus clair.
Je vous propose d’en découvrir quelques éléments :
- Les propriétés simplifiées
- Les inférences de type
- Les initialiseurs d’objets
- Les types anonymes
- Les méthodes d’extension
Les propriétés simplifiées
Les propriétés sont, en général, utilisées pour publier certains champs privés d’une classe. Elles permettent de mieux gérer les accès en lecture et en écriture.
Avec C# 3, une nouvelle manière de déclarer les propriétés fait sont apparition. Elle permet de déclarer automatiquement la champ privé de la classe du même type que la propriété.
Il est ainsi possible de faire ceci :
[csharp] class MaClasse{
public string ProprieteA { get; set; }
public string ProprieteB { get; private set; }
public int ProprieteC { get; set; }
}
[/csharp]
Ce morceau de code fait les choses suivantes :
- Le compilateur crée automatiquement deux champs privés pour ProprieteA et pour ProprieteB ;
- La propriété ProprieteA sera accessible en lecture et en écriture par tous ;
- La propriété ProprieteB sera accessible en lecture par tous et en écriture seulement par la classe ;
Vous remarquerez donc, qu’il est possible d’ajouter des modificateurs du type private ou protected sur les get et set. Ce qui est intéressant pour faire de la lecture/écriture avec des accès différents.
Les inférences de type
Selon Wikipedia, « l’inférence de types est un mécanisme qui permet à un compilateur ou un interpréteur de rechercher automatiquement les types associés à des expressions, sans qu’ils soient indiqués explicitement dans le code source ».
En C#, vous pouvez utiliser l’inférence très simplement grâce au mot clé « var« , ce qui permettra de déclarer une variable sans spécifier son type explicitement.
[csharp] // Le type obj est déduit de MaClassevar obj = new MaClasse();
// Le type de "chaine" est déduit grâce à ProprieteA
var chaine = obj.ProprieteA;
[/csharp]
L’inférence permet d’écrire du code plus simple et plus facile à maintenir.
Les initialiseurs d’objets
Voici encore un mécanisme de simplification d’écriture introduit dans cette version du langage.
Généralement pour créer un objet, il faut tout d’abord utiliser « new » pour créer une instance en passant éventuellement quelques paramètres au constructeur et ensuite il faut définir certaines propriétés sur l’objet nouvellement crée.
La nouvelle syntaxe introduite permet de faire ces étapes en une seule opération. Voici un exemple :
[csharp] var obj = new MaClasse(){
ProprieteA = "valeur 1",
ProprieteC = 10
};
[/csharp]
Dans cet exemple, je crée une nouvelle instance de MaClasse et je définis des valeurs à ProprieteA et à ProprieteC.
Les types anonymes
C# propose à nouveau un mécanisme permettant de créer des types anonymes de manière très simple. Ces types pourront être utilisés ensuite pour transmettre des paramètres à une méthode.
[csharp] void MaMethod(object unType){
// code qui utilse unType
}
void Main()
{
MaMethode(new {
Titre = "Hello",
Price= 10,
Quantity = 2
});
}
[/csharp]
Dans cet exemple, j’appelle la méthode MaMethode en lui passant un type anonyme crée spécifiquement pour cet appel. La classe crée contiendra les champs Titre, Price, Quantity. Elle pourra ensuite être utilisé dans MaMethode en utilisant la réflexion par exemple (pour lister les champs).
Les méthodes d’extension
Grâce aux méthodes d’extension, il est désormais possible d’ajouter des méthodes à des classes existantes. En réalité, il s’agit plutôt d’une syntaxe car la classe elle-même n’est pas modifiée !
Cette syntaxe permet de faire un appel en passant un paramètre explicite. Je vous propose de découvrir l’exemple suivant qui sera plus parlant :
[csharp] public static MaClasseExensions{
public static string GetDisplayString(this MaClasse maClasse)
{
return String.Format("MaClasse: A={0}, B={1}, C={2}",
maClasse.ProprieteA,
maClasse.ProprieteB,
maClasse.ProprieteC);
}
}
// dans une autre classe :
void Main()
{
var obj = new MaClasse()
{
ProprieteA = "valeur 1",
ProprieteC = 10
};
// appel de la méthode d’extension
var output = obj.GetDisplayString();
Console.WriteLine(output);
}
[/csharp]
L’appel de la méthode d’extension est équivalent à faire quelque chose comme ceci :
[csharp] var output = GetDisplayString(obj);[/csharp]
Conclusion
Nous venons de parcourir rapidement quelques nouveautés de C#3. Vous avez vu qu’il y a des nouveautés surtout au niveau de l’écriture afin de simplifier le travail du développeur.
Désormais, c’est à vous d’essayer et d’utiliser ces nouveautés.
N’hésitez pas à me faire un retour sur ce que vous appréciez ou pas !