Les nouveautés du langage CSharp 4.0.pdf

Les nouveauts du

langage C# 4.0 Version 1.1

James RAVAILLE

http://blogs.dotnet-france.com/jamesr

Dotnet France Association James RAVAILLE

2 Les nouveauts du langage C# 4.0

Sommaire

1 Introduction ..................................................................................................................................... 3

1.1 Prsentation ............................................................................................................................ 3

1.2 Pr-requis ................................................................................................................................ 3

2 Les paramtres nomms et optionnels ........................................................................................... 4

2.1 Prsentation ............................................................................................................................ 4

2.1.1 Les paramtres optionnels .............................................................................................. 4

2.1.2 Les paramtres nomms ................................................................................................. 4

2.1.3 Rsolution des conflits .................................................................................................... 5

3 Le typage dynamique ...................................................................................................................... 6

3.1 Prsentation ............................................................................................................................ 6

3.2 Exemples.................................................................................................................................. 6

4 La co-variance et la contre-variance ............................................................................................. 10

4.1 Co-variance et contre-variance sur les dlgus .................................................................. 11

4.1.1 La co-variance et les interfaces gnriques .................................................................. 12

4.1.2 La contre-variance et les interfaces gnriques ............................................................ 14

5 Conclusion ..................................................................................................................................... 17



1 Introduction

1.1 Prsentation Au dbut de lanne 2010, Microsoft proposera Visual Studio 10, la version 4.0 du

Framework .NET, ainsi quune nouvelle version du langage C# (version 4.0). Nous vous proposons

dans ce cours, de vous prsenter chacune des nouveauts de ce langage, avec pour chacune dentre

elles :

- Une partie thorique afin de vous expliquer en quoi elle consiste, et quel est son but, dans

quels cas il est ncessaire/conseill de lutiliser

- Une partie pratique avec des exemples de mise en uvre.

Ces nouveauts sont les suivantes :

- Les paramtres nomms et optionnels.

- Les instructions dynamiques.

- La co-variance et la contre-variance.

Aussi, ce cours est bas sur la version Beta 1 du Framework .NET 4.0 et Visual Studio 2010

Beta 1.

1.2 Pr-requis Avant de lire ce cours, vous devez avoir lu les prcdents cours sur le langage C# :

- Le langage C#.

- La programmation oriente objet avec le langage C#.

- Les nouveauts du langage C# 2.0.

- Les nouveauts du langage C# 3.0.



2 Les paramtres nomms et optionnels

2.1 Prsentation Le langage C# 4.0 autorise les paramtres nomms et les paramtres optionnels. Ils peuvent

tre utiliss lors de la dfinition de mthodes, constructeurs et indexeurs. Soit la mthode suivante,

permettant dafficher la somme de trois nombres passs en paramtre :

2.1.1 Les paramtres optionnels

La mthode Calculer accepte trois paramtres. Les deux derniers paramtres acceptent une

valeur par dfaut : il sagit de paramtres optionnels (aucun mot cl nest ncessaire). Ces valeurs

seront utilises si la mthode est appele, sans spcifier de valeur pour ces paramtres.

Une rgle dor respecter : dans une mthode, si un paramtre est dfini comme optionnel,

alors tous les autres paramtres doivent aussi tre dfinis comme optionnels.

Pour appeler cette mthode, il est possible dutiliser lune des instructions suivantes :

La premire instruction excute la mthode Calculer avec les valeurs respectives 5, 15 et 67.

Le nombre 87 est alors affich.

La seconde instruction excute la mthode Calculer avec les valeurs respectives 5, 42 et 67.


La troisime instruction excute la mthode Calculer avec les valeurs respectives 5, 42 et 11.


La dernire instruction excute la mthode Calculer avec les valeurs respectives 5, 15 et 11.


2.1.2 Les paramtres nomms

Pour appeler cette mthode, il est possible dutiliser les paramtres nomms. Leur utilisation

permet dappeler une mthode, en prcisant pour un paramtre son nom et une valeur, spar avec

le caractre : . Leur utilisation permet de ne pas respecter lordre des paramtres.

// C#

this.Calculer(5);

this.Calculer(5, 42);

this.Calculer(5, 42, 11);

this.Calculer(5, , 11);

// C#

public void Calculer(int x, int y = 15, int z = 67)

{

MessageBox.Show((x + y + z).ToString());

}



Voici quelques exemples dappels de la mthode Calculer :

La premire instruction excute la mthode Calculer avec les valeurs respectives suivantes :

5, 15 et 12. Le nombre 32 est alors affich.

La seconde instruction excute la mthode Calculer avec les valeurs respectives suivantes : 3,

47 et 43. Le nombre 93 est alors affich.

2.1.3 Rsolution des conflits

Soit les mthodes surcharges suivantes :

Lorsque nous crivons linstruction suivante :

Quelle mthode est appele ? Dans un premier temps, en observant les signatures des

mthodes, toutes peuvent correspondre. Dans cette instruction accepte un seul paramtre de type

int. Cette information rduit notre choix aux deux dernires mthodes. Parmi ces deux mthodes, la

mthodes sans le paramtre optionnel est prioritaire et sera donc excute.

De manire gnrale, la mthode excute est la mthode dont la signature correspond le

mieux aux paramtres passs, en sappuyant sur le nombre de paramtres et leurs types.

// C#

this.ExecuterTraitement(15);

// C#

public void ExecuterTraitement(string s, int i = 1) {}

public void ExecuterTraitement(object o){}

public void ExecuterTraitement(int i, string s = "Actif"){}

public void ExecuterTraitement(int i){}

// C#

this.Calculer(5, z:12);

this.Calculer(z:43, y:47, x:3);



3 Le typage dynamique

3.1 Prsentation Le typage dynamique des objets permet de crer des instructions dynamiques. Ces

instructions permettent dclarer des variables locales, des paramtres de mthodes ou des attributs

de classe, qui seront typs lors de lexcution de lapplication (on parle dans ce cas de liaisons

tardives). Elles peuvent aussi tre utilises comme type de retour de mthodes.

Le typage dynamique exploite une nouvelle fonctionnalit de la CLR, appele la DLR

(Dynamic Language Runtime). Cette fonctionnalit permet dexcuter dans la CLR des langages

dynamiques tels que le langage IronPython ( Python pour .NET).

Une fois dclare dynamiquement, il est possible dutiliser ces membres, sans quaucune

vrification ne soit effectue par le compilateur.

Les intrts des instructions dynamiques sont les suivants :

- Utiliser plus facilement des objets venant de langage de programmation dynamique tels que

les langages IronPhyton et IronRuby.

- Faciliter laccs et lutilisation dobjets COM.

- Proposer une alternative la rflexion (mcanismes dintrospection de code MSIL, ).

Toutefois, attention lutilisation des instructions dynamiques. Utilises mauvais escient,

elles rendront les applications moins robustes lors de leur excution, en provoquant des erreurs

uniquement lors de lexcution (le compilateur ne connat pas le type des objets manipuls). Dans

des cas trs prcis, elles permettent de simplifier le dveloppement.

Pour mettre en uvre le typage dynamique, nous utiliserons le mot cl dynamic.

3.2 Exemples Soit le bloc dinstructions ci-dessous, que nous pouvons excuter dans une application

Windows Forms :

La premire instruction permet de dclarer une variable nomme var1, et de la typer (lors de

lexcution) en chane de caractres (type string), ce type tant dduit de la valeur daffectation

"abc".

La seconde instruction permet dappliquer (dynamiquement) la mthode ToUpper cette

variable, de manire transformer sa valeur en chane de caractres majuscules.

La troisime instruction permet dafficher dans une boite de message le contenu de la

variable VAR1.

// C#

dynamic var1 = "abc";

string VAR1 = var1.ToUpper();

MessageBox.Show(VAR1);



Voici un second exemple. Soit les deux classes suivantes :

Ces deux classes possdent un accesseur Nom (vous remarquerez lutilisation des accesseurs

simplifis, cf : cours sur les nouveauts du langage C# 3.0) en commun, ainsi quune mthode

nomme Deplacer.

Voici une autre mthode ayant un paramtre dfini dynamiquement, appliquant une

mthode Deplacer() cet objet, et affiche les informations retournes par cette mthode :

// C#

public class Personne

{

public string Nom { get; set; }

public string Prenom { get; set; }

public Personne(string aNom, string aPrenom)

{

this.Nom = aNom;

this.Prenom = aPrenom;

}

public string Deplacer()

{

// Bloc d'instructions.

// ...

return this.Nom + " " + this.Prenom + " est arriv

destination";

}

}

public class Animal

{


public string Race { get; set; }

public Animal(string aNom, string aRace)

{

this.Nom = aNom;

this.Race = aRace;

}

public Point Deplacer()

{

// Bloc d'instructions.

// ...

return new Point(20, 50);

}

}



Le bloc dinstructions cre une instance de la classe Personne, une autre de la classe Animal,

et excute deux fois la mthode ChangerPosition en passant successivement ces objets en

paramtre :

Linstruction this.ChangerPosition(oPersonne); affiche le message suivant :

Linstruction this.ChangerPosition(oAnimal); affiche le message suivant :

Ces deux exemples mettent en vidence que la mthode Deplacer est bien applique

dynamiquement un objet, dont le type de donnes nest pas explicitement dfini lors de la

compilation, mais lors de lexcution. Elle est applique sur un objet, quelque soit son type, tant que

cette mthode est dfinie au sein de la classe ou hrite dune classe de base. Cependant :

- Il nest pas possible dappliquer de cette manire les mthodes dextension (cf : cours sur les

nouveauts du langage C# 3.0).

// C#

private void button1_Click(object sender, EventArgs e)

{

Personne oPersonne = new Personne("RAVAILLE", "James");

Animal oAnimal = new Animal("Mdor", "Chien");

this.ChangerPosition(oPersonne);

this.ChangerPosition(oAnimal);

}

// C#

public void ChangerPosition(dynamic aObjet)

{

MessageBox.Show(aObjet.Deplacer().ToString());

}



- Il nest pas possible dutiliser les expressions lambda (cf : cours sur les nouveauts du langage

C# 3.0) comme paramtre des mthodes.

Voici une mthode nomme Embaucher, acceptant un paramtre dfini dynamiquement, et

affichant le Nom et le Prenom de lobjet pass en paramtre :

Comme nous lavons vu, il est alors possible dappeler cette mthode en passant un objet

cr partir de nimporte quelle classe exposant des proprits Nom et Prenom. Mais cet objet peut

aussi avoir t cr partir dun type anonyme (cf : cours sur les nouveauts du langage C# 3.0) :

Linstruction this.Embaucher(oPersonne); affiche le message suivant :

Linstruction this.Embaucher(oPersonne1); affiche le message suivant :

// C#

private void button1_Click(object sender, EventArgs e)

{

Personne oPersonne = new Personne("RAVAILLE", "James");

var oPersonne1 = new { Nom = "VERGNAULT", Prenom = "Bertrand" };

this.Embaucher(oPersonne);

this.Embaucher(oPersonne1);

}

// C#

public void Embaucher(dynamic aPersonne)

{

MessageBox.Show(aPersonne.Nom + " " + aPersonne.Prenom + " a t

embauch le " + DateTime.Now.ToShortDateString());

}



4 La co-variance et la contre-variance La co-variance et la contre-variance nest pas un nouveau concept. En C# 2.0, il tait possible

de les appliquer sur des dlgus. Le langage C# 4.0 tend la co-variance et la contre-variance aux

interfaces gnriques.

Pour illustrer en quoi consiste la co-variance et la contre-variance, nous allons nous baser sur

le diagramme de classes suivant :

La classe Personne est caractrise par un nom et un prnom. La classe Employe spcialise la

classe Personne, et dfinit un attribut supplmentaire : le salaire.

Voici limplmentation de ces deux classes :

// C#

public class Personne

{


public string Prenom { get; set; }

public Personne(string aNom, string aPrenom)

{

this.Nom = aNom;

this.Prenom = aPrenom;

}

}

public class Employe : Personne

{

public double Salaire { get; set; }

public Employe(string aNom, string aPrenom, double aSalaire) :

base(aNom, aPrenom)

{

this.Salaire = aSalaire;

}

}



4.1 Co-variance et contre-variance sur les dlgus Nous allons commencer par expliciter les notions de co-variance et de contre-variance sur les

dlgus, notions dj existantes dans le langage C# 2.0.

Dans lexemple prsent ci-dessus, la classe Employe drive de la classe Personne. En C# 2.0,

on peut alors crire le bloc de code suivant :

Dtaillons ce bloc de code :

- Dans un premier temps, nous dclarons un dlgu nomm PersonneHandler. Pour rappel, il

sagit dun type de donnes permettant de crer des objets pointant vers une mthode. Ce

dlgu permet donc de crer des objets pointant vers une mthode, acceptant un employ

en paramtre et retournant une personne.

- Puis nous dclarons deux mthodes ayant des signatures diffrentes. La mthode Embaucher

accepte une personne en paramtre et retourne une personne. La mthode Licencier

accepte un employ en paramtre et retourne aussi une personne.

- Dans la mthode DemoVariance :

o Nous dclarons une instance du dlgu nomme oDelegue1 pointant vers la

mthode Licencier, bien que cette mthode ne respecte pas strictement la signature

du dlgu : elle retourne un objet de type Employe au lieu de Personne. Lutilisation

de la co-variance permet lcriture de cette instruction.

o Puis nous dclarons une autre instance du dlgu nomme oDelegue2 pointant vers

la mthode Embaucher, bien que cette mthode ne respecte pas strictement la

signature du dlgu : elle accepte en paramtre de type Personne et non Employe.

Lutilisation de la contre-variance permet lcriture de cette instruction.

Lutilisation de la co-variance et de la contre-variance permettent aussi dcrire ces

instructions, ntant quune volution des dlgus (toujours valable partir de C# 2.0) :

// C#

Func oFunc1 = Embaucher;

Func oFunc2 = Licencier;

// C#

private delegate Personne PersonneHandler(Employe aEmploye);

private Employe Licencier(Employe aEmploye)

{

return null;

}

private Personne Embaucher(Personne aPersonne)

{

return null;

}

private void DemoVariance(object sender, EventArgs e)

{

PersonneHandler oDelegue1 = Licencier;

PersonneHandler oDelegue2 = Embaucher;

}



Lobjet oFunc1 pointe vers la mthode Embaucher. Lobjet oFunc2 pointe vers la mthode

Licencier.

4.1.1 La co-variance et les interfaces gnriques

Dans le Framework .NET 4.0, les interfaces gnriques IEnumerable et IEnumerator sont

dfinies de la manire suivante :

Vous remarquez lutilisation du mot cl out avant le type gnrique, qui permet de signifier

que le type T, pourra uniquement tre utilis comme type de retour des mthodes dfinies dans ces

interfaces. On dit alors que cette interface est covariante du type T. Ainsi toute numration

dobjets de type A (IEnumerable) pourra tre considre comme une numration dobjets de

type B (IEnumerable), condition que tout objet A puisse tre converti en objet de type B.

Appliquons maintenant ce principe sur un cas pratique : voici un bloc de code permettant de

crer une liste demploys :

Maintenant, en C# 3.0, si nous crivons ces instructions :

// C#

// Variables locales;

IList oListeEmployes;

// Cration et alimentation de la liste des employes.

oListeEmployes = new List()

{

new Employe("DURAND", "Alain", 2321.81),

new Employe("VIRON", "Karl", 1398.22),

new Employe("HOIN", "Pierre", 1210.09),

new Employe("HILL", "Tony", 3211.45),

new Employe("FROT", "Elise", 3232.90),

new Employe("ZERA", "Laurence", 2129.98)

};

// C#

public interface IEnumerable : IEnumerable

{

IEnumerator GetEnumerator();

}

public interface IEnumerator : IEnumerator

{

bool MoveNext();

T Current { get; }

}



Nous obtenons le message derreur suivant Argument d'instance : conversion impossible de

'System.Collections.Generic.IList' en

'System.Collections.Generic.IEnumerable' .

Dans le langage C# 4.0, la co-variance permet de convertir une liste dobjets de type T en

une numration dobjets de type T1, si et seulement si une conversion est possible. En appliquant

ce principe notre exemple, la classe Employe drivant de la classe Personne, il est maintenant

possible de convertir une liste demploys en une numration de personnes. Ce constat permet

alors dcrire et dexcuter en C# 4.0 les instructions suivantes :

Plus concrtement, cette nouveaut se rvle pratique dans le cas suivant. Voici un bloc

dinstructions permettant de crer deux listes dobjets distinctes : lune de personnes et lautre

demploys. Puis de fusionner ces deux listes pour nen former quune seule, et dafficher le nombre

dobjets quelle contient :

La co-variance est utilise dans linstruction var oListeFusion = oListePersonnes.Union (oListeEmployes); en permettant de convertir la liste oListeEmployes en IEnumerable. Voici le rsultat obtenu :

// C#

IList oListePersonnes = new List()

{

new Personne("RAVAILLE", "James"),

new Personne("DOLLON", "Julien"),

new Personne("VERGNAULT", "Laurent")

};

IList oListeEmployes = new List()

{

new Employe("ASSIS-RANTES", "Laurent", 2239.34),

new Employe("DORDOLO", "Matthieu", 1989.99)

};

var oListeFusion = oListePersonnes.Union(oListeEmployes);

MessageBox.Show("Nombre d'lments : " +

oListeFusion.Count().ToString());

// C#

List oListePersonnes;

oListePersonnes = oListeEmployes.ToList();

// C#

IEnumerable oListePersonnes;

oListePersonnes = oListeEmployes.ToList();



4.1.2 La contre-variance et les interfaces gnriques

Dans le Framework .NET 4.0, linterface gnrique IEqualityComparer est dfinie de la

manire suivante :

Vous remarquez lutilisation du mot cl in avant le type gnrique, qui permet de signifier

que le type T, pourra uniquement tre utilis comme type des paramtres des mthodes de cette

interface.

Grce cette criture, un objet cr partir dune classe implmentant linterface

IEqualityComparer, pourra tre considr comme un objet de type

IEqualityComparer.

Dfinissons alors une classe nomme PersonneComparer, implmentant linterface

IEqualityComparer. Cette classe permet de dterminer si deux instances de la classe

Personne dsigne la mme personne :

// C#

public interface IEqualityComparer

{

bool Equals(T x, T y);

int GetHashCode(T obj);

}



// C#

public int GetHashCode(Personne aPersonne)

{

// Variables locales.

int iResult;

// Initialisation.

iResult = 0;

// On vrifie que l'objet est diffrent de null.

if (aPersonne != null)

{

// On ontient le HashCode du prnom s'il est diffrent de null.

int iHashCodePrenom = 0;

if (aPersonne.Prenom != null)

iHashCodePrenom = aPersonne.Prenom.GetHashCode();

// Calcul du hashCode du nom;

int iHashCodeNom = 0;

if (aPersonne.Nom != null)

iHashCodeNom = aPersonne.Nom.GetHashCode();

// Calcul du hascode de la personne partir du nom et du prnom.

iResult = iHashCodePrenom ^ iHashCodeNom;

}

return iResult;

}

}

// C#

public class PersonneComparer : IEqualityComparer

{

public bool Equals(Personne aPersonne1, Personne aPersonne2)

{

// Variables locales.

bool bResult;

// Initialisation.

bResult = true;

// Comparaison des rfrences des deux personnes.

if (aPersonne1 != aPersonne2)

{

// Cas des objets NULL.

if (aPersonne1 == null || aPersonne2 == null)

bResult = false;

else

// Les deux objets reprsentent la mme personne s'ils ont le

mme nom et mme prnom.

bResult = aPersonne1.Prenom == aPersonne2.Prenom &&

aPersonne1.Nom == aPersonne2.Nom;

}

return bResult;

}



Toute classe implmentant une interface doit proposer une implmentation des membres

dfinis dans cette interface. En implmentant linterface gnrique IEqualityComparer,

nous devons donc implmenter les membres :

- Equals : retourne une valeur boolenne indiquant si deux objets de type Personne reprsente

la mme personne. Ainsi, elle retourne True si les deux personnes passes en paramtre

pointent vers la mme instance ou sils ont le mme nom et le mme prnom.

- GetHashCode : permet dobtenir le HashCode de lobjet de type Personne pass en

paramtre, partir de son nom et son prnom.

Voici un bloc dinstructions permettant de crer une liste demploys, puis de lapurer afin

denlever les doublons, et dafficher le nombre demploys obtenus :

Pour appliquer le concept de la contre-variance prsent ci-dessus, nous avons utilis une

instance de la classe PersonneComparer, permettant de comparer deux personnes, afin de comparer

deux employs. Cette contre-variance est applicable car la classe Employe drive de la classe

Personne.

Lexcution du code ci-dessus affiche la boite de message suivante :

// C#

private void CmdContreVariance_Click(object sender, EventArgs e)

{

// Cration de la liste des employs.

List oListeEmployes = new List()

{

new Employe("ASSIS-ARANTES", "Laurent", 2239.34),

new Employe("ASSIS-ARANTES", "Laurent", 2306.01),

new Employe("DORDOLO", "Matthieu", 1989.99)

};

// Suppression des doublons.

IEnumerable oListeEmpl =

oListeEmployes.Distinct(new PersonneComparer());

// Affichage du nombre d'employs distincts.

MessageBox.Show(oListeEmpl.Count().ToString() + " employs.");

}



5 Conclusion Ce cours vous a prsent les principales nouveauts du langage C# 4.0 :

- Les paramtres nomms et les paramtres optionnels.

- Le typage dynamique.

- La co-variance et la contre-variance sur les classes gnriques.

Ces nouveauts vous offriront plus de possibilits dans le dveloppement de vos applications

.NET avec le langage C#. Attention toutefois au typage dynamique : il est important de ne pas en

abuser, au risque de crer des applications dans lesquelles des exceptions sont souvent leves

Les nouveautés du langage CSharp 4.0.pdf

Documents

Transcript of Les nouveautés du langage CSharp 4.0.pdf