Csharp Part 2

Un langage trs orient objet
Classes, objets et mthodes Polymorphisme d'objets Polymorphisme de mthodes Polymorphisme d'interfaces Classe de dlgation Traitement d'exceptions Processus et multi-threading
Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
124
Classes, objets et mthodes
Plan gnral:
1. Les classes C# : des nouveaux types

1.1 Dclaration d'une classe 1.2 Une classe est un type en C# 1.3 Toutes les classes ont le mme anctre - hritage 1.4 Encapsulation des classes 1.5 Exemple de classe imbrique dans une autre classe 1.6 Exemple de classe inclue dans un mme espace de noms 1.7 Mthodes abstraites 1.8 Classe abstraite, Interface
2. Les objets : des rfrences ou des valeurs

2.1 Modle de la rfrence 2.2 Les constructeurs d'objets rfrence ou valeurs 2.3 Utilisation du constructeur d'objet par dfaut 2.4 Utilisation d'un constructeur d'objet personnalis 2.5 Le mot clef this- cas de la rfrence seulement
3. Variables et mthodes
3.1 Variables dans une classe en gnral 3.2 Variables et mthodes d'instance 3.3 Variables et mthodes de classe - static 3.4 Bilan et exemple d'utilisation
- Rm di Scala
page
125
Introduction
Nous proposons des comparaisons entre les syntaxes de C# et Delphi et/ou Java, lorsque les dfinitions sont semblables. Tableau des limitations des niveaux de visibilit fourni par microsoft :
Modification de visibilit Rappelons les classiques modificateurs de visibilit des variables et des mthodes dans les langages orients objets, dont C# dispose : Les mots clef (modularit public-priv)
par dfaut (aucun mot clef) Les variables et les mthodes d'une classe non prcdes d'un mot clef sont private et ne sont visibles que dans la classe seulement. Les variables et les mthodes d'une classe prcdes du mot clef public sont visibles par toutes les classes de tous les modules. Les variables et les mthodes d'une classe prcdes du mot clef private ne sont visibles que dans la classe seulement. Les variables et les mthodes d'une classe prcdes du mot clef protected sont visibles par toutes les classes drives de cette classe. Les variables et les mthodes d'une classe prcdes du mot clef internal sont visibles par toutes les classes
- Rm di Scala
public
private
protected internal
page
126
inclues dans le mme assembly.
Les attributs d'accessibilit public, private, protected sont identiques ceux de Delphi et Java, pour les classes nous donnons ci-dessous des informations sur leur utilisation. L'attribut internal joue peu prs le rle (au niveau de l'assembly) des classes Java dclares sans mot clef dans le mme package, ou des classes Delphi dclares dans la mme unit (classes amies). Toutefois pour des raisons de scurit C# ne possde pas la notion de classe amie.
1. Les classes : des nouveaux types

Rappelons un point fondamental dj indiqu : tout programme C# contient une ou plusieurs classes prcdes ou non d'une dclaration d'utilisation dautres classes contenues dans des bibliothques (clause using) ou dans un package complet compos de nombreuses classes. La notion de module en C# est reprsente par l'espace de noms (clause namespace) semblable au package Java, en C# vous pouvez omettre de spcifier un namespace, par dfaut les classes dclares le sont automatiquement dans un espace 'sans nom' (gnralement qualifi de global) et tout identificateur de classe dclar dans cet espace global sans nom est disponible pour tre utilis dans un espace de noms nomm. Contrairement Java, en C# les classes non qualifies par un modificateur de visibilit (dclares sans rien devant) sont internal. Delphi
Unit Biblio; interface // les dclarations des classes implementation // les implmentations des classes end. si pas de nom de package alors automatiquement dans : package java.lang; } si pas de nom d'espace de noms alors automatiquement dans l'espace global.
Java
package Biblio;
C#
namespace Biblio { // les dclarations et implmentation des classes
// les dclarations et implmentation des classes
1.1 Dclaration d'une classe En C#, nous n'avons pas comme en Delphi, une partie dclaration de la classe et une partie implmentation spares l'une de l'autre. La classe avec ses attributs et ses mthodes sont dclars et implments un seul endroit comme en Java.
- Rm di Scala
page
127
Delphi
interface uses biblio; type Exemple = class x : real; y : integer; function F1(a,b:integer): real; procedure P2; end; implementation function F1(a,b:integer): real; begin ...........code de F1 end; procedure P2; begin ...........code de P2 end; end. import biblio;
Java
using biblio;
C#
class Exemple { float x; int y; float F1(int a, int b) { ...........code de F1 } void P2( ) { ...........code de P2 } }
namespace Machin { class Exemple { float x; int y; float F1(int a, int b) { ...........code de F1 } void P2( ) { ...........code de P2 } } }
1.2 Une classe est un type en C# Comme en Delphi et Java, une classe C# peut tre considre comme un nouveau type dans le programme et donc des variables d'objets peuvent tre dclares selon ce nouveau "type". Une dclaration de programme comprenant 3 classes : Delphi
interface type Un = class ... end; Deux = class ... end; Appli3Classes = class x : Un; y : Deux; public procedure main; end; implementation procedure Appli3Classes.main; var x : Un; y : Deux; begin ... end; end.
Java
class Appli3Classes { Un x; Deux y; public static void main(String [ ] arg) { Un x; Deux y; ... } } class Un { ... } class Deux { ... }
C#
class Appli3Classes { Un x; Deux y; static void Main(String [ ] arg) { Un x; Deux y; ... } } class Un { ... } class Deux { ... }
- Rm di Scala
page
128
1.3 Toutes les classes ont le mme anctre - hritage Comme en Delphi et en Java, toutes les classes C# drivent automatiquement d'une seule et mme classe anctre : la classe Object. En C# le mot-clef pour indiquer la drivation (hritage) partir d'une autre classe est le symbole deux points ':', lorsqu'il est omis c'est donc que la classe hrite automatiquement de la classe Object : Les deux dclarations de classe ci-dessous sont quivalentes : Delphi
type Exemple = class ( TObject ) ...... end; type Exemple = class ...... end;
Java
class Exemple extends Object { ....... } class Exemple { ....... }
C#
class Exemple : Object { ....... } class Exemple { ....... }
L'hritage en C# est tout fait classiquement de l'hritage simple comme en Delphi et en Java. Une classe fille qui drive d'une seule classe mre, hrite de sa classe mre toutes ses mthodes et tous ses champs. En C# la syntaxe de l'hritage fait intervenir le symbole clef ':', comme dans "class Exemple : Object". Une dclaration du type : class ClasseFille : ClasseMere { } signifie que la classe ClasseFille dispose de tous les attributs et de toutes les mthodes de la classe ClasseMere. Comparaison hritage : Delphi
type ClasseMere = class // champs de ClasseMere // mthodes de ClasseMere end; ClasseFille = class ( ClasseMere )
// hrite des champs de ClasseMere // hrite des mthodes de ClasseMere
Java
class ClasseMere { // champs de ClasseMere // mthodes de ClasseMere } class ClasseFille extends ClasseMere {
C#
class ClasseMere { // champs de ClasseMere // mthodes de ClasseMere } class ClasseFille : ClasseMere {
end;
Bien entendu une classe fille peut dfinir de nouveaux champs et de nouvelles mthodes qui lui sont propres.
- Rm di Scala
page
129
1.4 Encapsulation des classes La visibilit et la protection des classes en Delphi est apporte par le module Unit o toutes les classes sont visibles dans le module en entier et ds que la unit est utilise les classes sont visibles partout. Il n'y a pas de possibilit d'imbriquer une classe dans une autre. En C#, nous avons la possibilit d'imbriquer des classes dans d'autres classes (classes internes), par consquent la visibilit de bloc s'applique aussi aux classes. Remarque La notion de classe interne de C# (qui n'existe pas en Delphi) est sensiblement diffrente de celle de Java (pas de classe locale et pas de classe anonyme mais des mthodes anonymes), elle correspond la notion de classe membre de Java.
Mots clefs pour la protection des classes et leur visibilit : Une classe C# peut se voir attribuer un modificateur de comportement sous la forme d'un mot clef devant la dclaration de classe. Par dfaut si aucun mot clef n'est indiqu la classe est visible dans tout le namespace dans lequel elle est dfinie. Il y a 4 qualificateurs possibles pour modifier le comportement de visibilit d'une classe selon sa position (imbrique ou non) : public, private, protected, internal (dnomms modificateurs d'accs) et abstract (qualificateur d'abstraction pouvant tre associ l'un des 3 autres modificateurs d'accs). On rappelle que sans qualificateur public, private, internal ou protected, une classe C# est automatiquement internal. Le nom du fichier source dans lequel plusieurs classes C# sont stockes n'a aucun rapport avec le nom d'une des classes dclares dans le texte source, il est laiss au libre choix du dveloppeur et peut ventuellement tre celui d'une classe du namespace etc...
Tableau des possibilits fourni par microsoft :
Attention
Programmer objet .Net avec C# - ( rv. 17.10..2007 ) page
- Rm di Scala
130
Par dfaut dans une classe tous les membres sans qualificateur de visibilit (classes internes inclues) sont private.
C# mot clef abstract : abstract class ApplicationClasse1 { ... } mot clef public : public class ApplicationClasse2 { ... } mot clef protected : protected class ApplicationClasse3 { ... } mot clef internal : internal class ApplicationClasse4 { ... } mot clef private : private class ApplicationClasse5 { ... } pas de mot clef : class ApplicationClasse6 { ... } - sauf si c'est une classe interne
Explication classe abstraite non instanciable. Aucun objet ne peut tre cr. classe visible par n'importe quel programme d'un autre namespace classe visible seulement par toutes les autres classes hritant de la classe conteneur de cette classe.
classe visible seulement par toutes les autres classes du mme assembly. classe visible seulement par toutes les autres classes du mme namespace o elle est dfinie.
qualifie internal -si c'est une classe interne elle est alors qualifie private.
Nous remarquons donc qu'une classe ds qu'elle est dclare dans lespace de noms est toujours visible dans tout l'assembly, que le mot clef internal soit prsent ou non. Les mots clefs abstract et protected n'ont de l'influence que pour l'hritage. Remarque La notion de classe sealed en C# correspond strictement la notion de classe final de Java : ce sont des classes non hritables.
Nous tudions ci-aprs la visibilit des classes prcdentes dans deux contextes diffrents.
1.5 Exemple de classes imbriques dans une autre classe Dans le premier contexte, ces six classes sont utilises en tant intgres (imbriques) une classe publique. La classe ApplicationClasses : C# Explication
- Rm di Scala
page
131
namespace Exemple { public class ApplicationClasses { abstract class ApplicationClasse1 { ... } public class ApplicationClasse2 { ... } protected class ApplicationClasse3 { ... } internal class ApplicationClasse4 { ... } private class ApplicationClasse5 { ... } class ApplicationClasse6 { ... } } }
Ces 6 "sous-classes" sont visibles ou non, partir de l'accs la classe englobante "ApplicationClasses", elles peuvent donc tre utilises dans tout programme qui utilise la classe "ApplicationClasses".
Par dfaut la classe ApplicationClasse6 est ici private.
Un programme utilisant la classe ApplicationClasses : C# Explication
Le programme de gauche "class AppliTestClasses" utilise la classe prcdente ApplicationClasses et ses sous-classes. La notation uniforme de chemin de classe est standard.
namespace Exemple { class AppliTestClasses { ApplicationClasses.ApplicationClasse2 a2; } }
Seule la classe interne ApplicationClasse2 est visible et permet d'instancier un objet.
1.6 Mme exemple de classes non imbriques situes dans le mme espace de noms Dans ce second exemple, ces mmes 6 classes sont utilises en tant incluses dans le mme namespace.
- Rm di Scala
page
132
C#
Explication
Une classe dans un espace de nom ne peut pas tre qualifie protected ou private (si elle est imbrique comme ci-haut cela est possible): Les classes ApplicationClasse3 et ApplicationClasse5 ne peuvent donc pas faire partie du mme namespace Exemple. La classe ApplicationClasse1 est ici abstraite et public, donc visible. La classe ApplicationClasse2 est public, donc visible. La classe ApplicationClasse4 n'est visible que dans le mme assembly. Par dfaut la classe ApplicationClasse6 est ici public, donc visible.
namespace Exemple { abstract class ApplicationClasse1 { ... } public class ApplicationClasse2 { ... } protected class ApplicationClasse3 { ... } internal class ApplicationClasse4 { ... } private class ApplicationClasse5 { ... } class ApplicationClasse6 { ... } }
Un programme AppliTestClasses utilisant ces 4 classes : C# dans deux namespace diffrents Explication
Le programme de gauche "class AppliTestClasses" utilise les classes qui composent le namespace Exemple.
Cette classe AppliTestClasses est dfinie dans un autre namespace dnomm Essai qui est suppos ne pas faire partie du mme assembly que le namespace Exemple. Elle ne voit donc pas la classe ApplicationClasse4 (visible dans le mme assembly seulement).
using Exemple; namespace Essai { class AppliTestClasses{ ApplicationClasse2 a2; ApplicationClasse6 a6; } }
Si l'on veut instancier des objets, seules les classes ApplicationClasse2 et ApplicationClasse6 sont de bonnes candidates, car la classe ApplicationClasse1 bien qu'elle soit visible est abstraite.
- Rm di Scala
page
133
C# dans le mme namespace
Explication
Le programme de gauche "class AppliTestClasses" utilise les classes qui composent le namespace Exemple.
La classe AppliTestClasses est dfinie dans le mme namespace Exemple que les 4 autres classes. Toutes les classes du mme namespace sont visibles entre elles. namespace Exemple { class AppliTestClasses{ ApplicationClasse1 a1; ApplicationClasse2 a2; ApplicationClasse4 a4; ApplicationClasse6 a6; } } Ici toutes les 4 classes sont visibles pour la classe AppliTestClasses.
Remarque pratique : Selon sa situation imbrique ou non imbrique, une classe peut ou ne peut pas tre qualifie par les divers modificateurs de visibilit. En cas de doute le compilateur fournit un diagnostique clair, comme ci-dessous : [C# Erreur] Class.cs(nn): Les lments namespace ne peuvent pas tre dclars explicitement comme private, protected ou protected internal.
1.7 Mthodes abstraites Le mot clef abstract est utilis pour reprsenter une classe ou une mthode abstraite. Quel est l'intrt de cette notion ? Avoir des modles gnriques permettant de dfinir ultrieurement des actions spcifiques.
Une mthode dclare en abstract dans une classe mre : N'a pas de corps de mthode. N'est pas excutable.
- Rm di Scala
page
134
Doit obligatoirement tre redfinie dans une classe fille.
Une mthode abstraite n'est qu'une signature de mthode sans implmentation dans la classe. Exemple de mthode abstraite : class Etre_Vivant { } La classe Etre_Vivant est une classe mre gnrale pour les tres vivants sur la plante, chaque catgorie d'tre vivant peut tre reprsente par une classe drive (classe fille de cette classe) : class Serpent : Etre_Vivant { } class Oiseau : Etre_Vivant { } class Homme : Etre_Vivant { } Tous ces tres se dplacent d'une manire gnrale, donc une mthode SeDeplacer est commune toutes les classes drives, toutefois chaque espce excute cette action d'une manire diffrente et donc on ne peut pas dire que se dplacer est une notion concrte mais une notion abstraite que chaque sous-classe prcisera concrtement. En C#, les mthodes abstraites sont automatiquement virtuelles, elles ne peuvent tre dclares que public ou protected, enfin elles doivent tre redfinies avec le qualificateur override. Cidessous deux dclarations possibles pour le dplacement des tres vivants :
abstract class Etre_Vivant { public abstract void SeDeplacer( ); } class Serpent : Etre_Vivant { public override void SeDeplacer( ) { //.....en rampant } } class Oiseau : Etre_Vivant { public override void SeDeplacer( ) { //.....en volant } } class Homme : Etre_Vivant { public override void SeDeplacer( ) { //.....en marchant } }
abstract class Etre_Vivant { protected abstract void SeDeplacer( ); } class Serpent : Etre_Vivant { protected override void SeDeplacer( ) { //.....en rampant } } class Oiseau : Etre_Vivant { protected override void SeDeplacer( ) { //.....en volant } } class Homme : Etre_Vivant { protected override void SeDeplacer( ) { //.....en marchant } }
Comparaison de dclaration d'abstraction de mthode en Delphi et C# : Delphi

type Etre_Vivant = class
C#
abstract class Etre_Vivant { public abstract void SeDeplacer( );
- Rm di Scala
page
135
procedure SeDeplacer;virtual; abstract ; end; Serpent = class ( Etre_Vivant ) procedure SeDeplacer; override; end; Oiseau = class ( Etre_Vivant ) procedure SeDeplacer; override; end; Homme = class ( Etre_Vivant ) procedure SeDeplacer; override; end;
} class Serpent : Etre_Vivant { public override void SeDeplacer( ) { //.....en rampant } } class Oiseau : Etre_Vivant { public override void SeDeplacer( ) { //.....en volant } } class Homme : Etre_Vivant { public override void SeDeplacer( ) { //.....en marchant } }
En C# une mthode abstraite est une mthode virtuelle nayant pas dimplmentation dans la classe o elle est dclare. Son implmentation est dlgue une classe drive. Les mthodes abstraites doivent tre dclares en spcifiant la directive abstract .
1.8 Classe abstraite, Interface Classe abstraite Comme nous venons de le voir dans l'exemple prcdent, une classe C# peut tre prcde du mot clef abstract, ce qui signifie alors que cette classe est abstraite, nous avons les contraintes de dfinition suivantes pour une classe abstraite en C# : Si une classe contient au moins une mthode abstract, elle doit imprativement tre dclare en classe abstract elle-mme. C'est ce que nous avons crit au paragraphe prcdent pour la classe Etre_Vivant que nous avons dclare abstract parce qu'elle contenait la mthode abstraite SeDeplacer. Une classe abstract ne peut pas tre instancie directement, seule une classe drive (sous-classe) qui redfinit obligatoirement toutes les mthodes abstract de la classe mre peut tre instancie. Consquence du paragraphe prcdent, une classe drive qui redfinit toutes les mthodes abstract de la classe mre sauf une (ou plus d'une) ne peut pas tre instancie et subit la mme rgle que la classe mre : elle contient au moins une mthode abstraite donc elle est aussi une classe abstraite et doit donc tre dclare en abstract. Une classe abstract peut contenir des mthodes non abstraites et donc implantes dans la classe. Une classe abstract peut mme ne pas contenir du tout de mthodes abstraites, dans ce cas une classe fille n'a pas la ncessit de redfinir les mthodes de la classe mre pour tre instancie. Delphi contrairement C# et Java, ne possde pas ce jour le modle de la classe abstraite, seule la version Delphi2005 pour le Net Framework possde les mmes caractristiques que C#. Interface Lorsqu'une classe est dclare en abstract et que toutes ses mthodes sont dclares en abstract, on appelle en C# une telle classe une Interface.
- Rm di Scala
page
136
Rappel classes abstraites-interfaces
Les interfaces ressemblent aux classes abstraites sur un seul point : elles contiennent des membres expliquant certains comportements sans les implmenter. Les classes abstraites et les interfaces se diffrencient principalement par le fait qu'une classe peut implmenter un nombre quelconque d'interfaces, alors qu'une classe abstraite ne peut hriter que d'une seule classe abstraite ou non.
Vocabulaire et concepts :

Une interface est un contrat, elle peut contenir des proprits, des mthodes et des vnements mais ne doit contenir aucun champ ou attribut. Une interface ne peut pas contenir des mthodes dj implmentes. Une interface doit contenir des mthodes non implmentes. Une interface est hritable. On peut contsruire une hirarchie d'interfaces. Pour pouvoir construire un objet partir d'une interface, il faut dfinir une classe non abstraite implmentant toutes les mthodes de l'interface.
Une classe peut implmenter plusieurs interfaces. Dans ce cas nous avons une excellente alternative l'hritage multiple. Lorsque l'on cre une interface, on fournit un ensemble de dfinitions et de comportements qui ne devraient plus tre modifis. Cette attitude de constance dans les dfinitions, protge les applications crites pour utiliser cette interface. Les variables de types interface respectent les mmes rgles de transtypage que les variables de types classe. Les objets de type classe clA peuvent tre transtyps et refrencs par des variables d'interface IntfA dans la mesure o la classe clA implmente linterface IntfA. (cf. polymorphisme d'objet)
Si vous voulez utiliser la notion d'interface pour fournir un polymorphisme une famille de classes, elles doivent toutes implmenter cette interface, comme dans l'exemple ci-dessous. Exemple : Ll'interface Vhicule dfinissant 3 mthodes (abstraites) Demarrer, RpartirPassagers de
- Rm di Scala
page
137
rpartition des passagers bord du vhicule (fonction de la forme, du nombre de places, du personnel charg de s'occuper de faire fonctionner le vhicule...), et PriodicitMaintenance renvoyant la priodicit de la maintenance obligatoire du vhicule (fonction du nombre de km ou miles parcourus, du nombre d'heures d'activits,...) Soit l'interface Vhicule dfinissant ces 3 mthodes : interface IVehicule{ void Demarrer( ); void RpartirPassager( ); void PriodicitMaintenance( ); } Soient les deux classes Vhicule terrestre et Vhicule marin, qui implmentent partiellement chacune l'interface Vhicule , ainsi que trois classes voiture, voilier et croiseur hritant de ces deux classes :
Les trois mthodes de l'interface Vhicule sont abstraites et publiques par dfinition. Les classes Vhicule terrestre et Vhicule marin sont abstraites, car la mthode abstraite Demarrer de l'interface Vhicule n'est pas implmente elle reste comme "modle" aux futures classes. C'est dans les classes voiture, voilier et croiseur que l'on implmente le comportement prcis du genre de dmarrage.
Dans cette vision de la hirarchie on a suppos que les classes abstraites Vhicule terrestre et Vhicule marin savent comment rpartir leur ventuels passagers et quand effectuer une maintenance du vhicule. Les classes voiture, voilier et croiseur , n'ont plus qu' implmenter chacune son propre comportement de dmarrage.
Une interface C# peut tre qualifie par un des 4 modificateur public, protected, internal, private.
- Rm di Scala
page
138
Contrairement Java, une classe abstraite C# qui implmente une interface doit obligatoirement dclarer toutes les mthodes de l'interface, celles qui ne sont pas implmentes dans la classe abstraite doivent tre dclares abstract. C'est le cas dans l'exemple ci-dessous pour la mthode abstraite Demarrer , nous proposons deux critures possibles pour cette hirarchie de classe : C# mthode abstraite sans corps
interface IVehicule{ void Demarrer( ); void RpartirPassager( ); void PriodicitMaintenance( ); } abstract class Terrestre : IVehicule { public abstract void Demarrer( ); public virtual void RpartirPassager( ){...} public virtual void PriodicitMaintenance( ){...} } class Voiture : Terrestre { override public void Demarrer( ){...} } abstract class Marin : IVehicule { public abstract void Demarrer( ); public virtual void RpartirPassager( ){...} public virtual void PriodicitMaintenance( ){...} } class Voilier : Marin { override public void Demarrer( ){...} } class Croiseur : Marin { override public void Demarrer( ){...} }
C# mthode virtuelle corps vide

interface IVehicule{ void Demarrer( ); void RpartirPassager( ); void PriodicitMaintenance( ); } abstract class Terrestre : IVehicule { public virtual void Demarrer( ){} public virtual void RpartirPassager( ){...} public virtual void PriodicitMaintenance( ){...} } class Voiture : Terrestre { override public void Demarrer( ){...} } abstract class Marin : IVehicule { public virtual void Demarrer( ) {} public virtual void RpartirPassager( ){...} public virtual void PriodicitMaintenance( ){...} } class Voilier : Marin { override public void Demarrer( ){...} } class Croiseur : Marin { override public void Demarrer( ){...} }
Les mthodes RpartirPassagers, PriodicitMaintenance et Demarrer sont implantes en virtual, soit comme des mthodes liaison dynamique, afin de laisser la possibilit pour des classes enfants de redfinir ces mthodes. Remarque : Attention le qualificateur new ne peut masquer que des membres non abstract. Un membre abstract doit imprativement tre redfini (implment) par le qualificateur override, car ce genre de membre est implicitement virtual en C#.
- Rm di Scala
page
139
Soit titre de comparaison, les deux mmes critures en Java de ces classes :
Java , mthode abstraite sans corps
Java mthode virtuelle corps vide
- Rm di Scala
page
140
2. Les objets : des rfrences ou des valeurs

Les classes sont des descripteurs d'objets, les objets sont les agents effectifs et "vivants" implantant les actions d'un programme. Les objets dans un programme ont une vie propre : Ils naissent (ils sont crs ou allous). Ils agissent (ils s'envoient des messages grce leurs mthodes). Ils meurent (ils sont dsallous, automatiquement en C#).
C'est dans le segment de mmoire du CLR de .NetFramework que s'effectuent l'allocation et la dsallocation d'objets. Objets type valeur Les classes encapsulant les types lmentaires dans .NET Framework sont des classes de type valeur du genre structures. Dans le CLS une classe de type valeur est telle que les allocations d'objets de cette classe se font directement dans la pile et non dans le tas, il n'y a donc pas de rfrence pour un objet de type valeur et lorsqu'un objet de type valeur est pass comme paramtre il est pass par valeur. Dans .NET Framework les classes-structures de type valeur sont dclares comme structures et ne sont pas drivables Objets type rfrence Le principe d'allocation et de reprsentation des objets type rfrence en C# est identique celui de Delphi il s'agit de la rfrence, qui est une encapsulation de la notion de pointeur. Dans .NET Framework les classes de type rfrence sont dclares comme des classes classiques et sont drivables. Afin d'clairer le lecteur prenons par exemple un objet x instanci partir d'une classe de type rfrence et un objet y instanci partir d'un classe de type valeur contenant les mmes membres que la classe par rfrence. Ci-dessous le schma d'allocation de chacun des deux catgories d'objets :
Pour les types valeurs, la gestion mmoire des objets est classiquement celle de la pile dynamique, un tel objet se comporte comme une variable locale de la mthode dans laquelle il est instanci et ne ncessite pas de gestion supplmentaire. Seuls les objets type rfrence instancis sur le tas, ncessitent une gestion mmoire spciale que nous dtaillons ci-aprs (dans un
- Rm di Scala
page
141
programme C# les types rfrences du dveloppeur reprsentent prs de 99% des objets du programme). 2.1 Modle de la rfrence en C# Rappelons que dans le modle de la rfrence chaque objet (reprsent par un identificateur de variable) est caractris par un couple (rfrence, bloc de donnes). Comme en Delphi, C# dcompose l'instanciation (allocation) d'un objet en deux tapes : La dclaration d'identificateur de variable type qui contiendra la rfrence, la cration de la structure de donnes elle-mme (bloc objet de donnes) avec new.
Delphi type Un = class ...... end; // la dclaration : var x , y : Un; .... // la cration : x := Un.create ; y := Un.create ; class Un { ... } // la dclaration : Un x , y ; .... // la cration : x = new Un( ); y = new Un( );
C#
Aprs excution du pseudo-programme prcdent, les variables x et y contiennent chacune une rfrence (adresse mmoire) vers un bloc objet diffrent:
Un programme C# est fait pour tre excut par l'environnement CLR de .NetFramework. Deux objets C# seront instancis dans le CLR de la manire suivante :
- Rm di Scala
page
142
Attitude rapprocher pour comparaison, celle dont Delphi gre les objets dans une pile d'excution de type LIFO et un tas :
Attention l'utilisation de l'affectation entre variables d'objets dans le modle de reprsentation par rfrence. L'affectation x = y ne recopie pas le bloc objet de donnes de y dans celui de x, mais seulement la rfrence (l'adresse) de y dans la rfrence de x. Visualisons cette remarque importante : Situation au dpart, avant affectation
Situation aprs l'affectation " x = y "
En C#, la dsallocation tant automatique, le bloc de donnes objet qui tait rfrenc par y avant
- Rm di Scala
page
143
l'affectation, n'est pas perdu, car le garbage collector se charge de restituer la mmoire libre au segment de mmoire du CLR
2.2 Les constructeurs d'objets rfrences ou valeurs Un constructeur est une mthode spciale d'une classe dont la seule fonction est d'instancier un objet (crer le bloc de donnes). Comme en Delphi une classe C# peut possder plusieurs constructeurs, il est possible de pratiquer des initialisations d'attributs dans un constructeur. Comme toutes les mthodes, un constructeur peut avoir ou ne pas avoir de paramtres formels. Si vous ne dclarez pas de constructeur spcifique pour une classe, par dfaut C# attribue automatiquement un constructeur sans paramtres formels, portant le mme nom que la classe. A la diffrence de Delphi o le nom du constructeur est quelconque, en C# le( ou les) constructeur doit obligatoirement porter le mme nom que la classe (majuscules et minuscules comprises). Un constructeur d'objet d'une classe n'a d'intrt que s'il est visible par tous les programmes qui veulent instancier des objets de cette classe, c'est pourquoi l'on mettra toujours le mot clef public devant la dclaration du constructeur. Un constructeur est une mthode spciale dont la fonction est de crer des objets, dans son en-tte il n'a pas de type de retour et le mot clef void n'est pas non plus utilis !
Soit une classe dnomme Un dans laquelle, comme nous l'avons fait jusqu' prsent nous n'indiquons aucun constructeur spcifique : class Un { int a; } Automatiquement C# attribue un constructeur public cette classe public Un ( ). C'est comme si C# avait introduit dans votre classe votre insu , une nouvelle mthode dnomme Un. Cette mthode "cache" n'a aucun paramtre et aucune instruction dans son corps. Ci-dessous un exemple de programme C# correct illustrant ce qui se passe : class Un { public Un ( ) { } int a; }
Vous pouvez programmer et personnaliser vos propres constructeurs. Une classe C# peut contenir plusieurs constructeurs dont les en-ttes diffrent uniquement par la liste des paramtres formels.
- Rm di Scala
page
144
Exemple de constructeur avec instructions : C# class Un { public Un ( ) { a = 100 } int a; } Explication
Le constructeur public Un sert ici initialiser 100 la valeur de l'attribut "int a" de chaque objet qui sera instanci.
Exemple de constructeur avec paramtre : C# class Un { public Un (int b ) { a = b; } int a; } Explication Le constructeur public Un sert ici initialiser la valeur de l'attribut "int a" de chaque objet qui sera instanci. Le paramtre int b contient cette valeur.
Exemple avec plusieurs constructeurs : C# class Un { public Un (int b ) { a = b; } public Un ( ) { a = 100; } public Un (float b ) { a = (int)b; } int a; } Explication
La classe Un possde 3 constructeurs servant initialiser chacun d'une manire diffrente le seul attribut int a.
Il est possible de rappeller un constructeur de la classe dans un autre constructeur, pour cela C# utilise comme Java le mot clef this, avec une syntaxe diffrente : Exemple avec un appel un constructeur de la mme classe: C# class Un { int a; public Un (int b ) { a = b; } public Un ( ) Explication La classe Un possde 3 constructeurs servant initialiser chacun d'une manire diffrente le seul attribut int a.
Soit le dernier constructeur : public Un (int x , float y ) : this(y)

- Rm di Scala
page
145
{ a = 100; } public Un (float b ) { a = (int)b; } public Un (int x , float y ) : this(y) { a += 100; } }
{ a += 100; } Ce constructeur appelle tout d'abord le constructeur Un (float y ) par l'intermdiaire de this(y), puis il excute le corps de mthode soit : a += 100; Ce qui revient calculer : a = (int)y + 100 ;
Comparaison Delphi - C# pour la dclaration de constructeurs Delphi class Un { int a; public Un ( ) { a = 100; } public Un (int b ) { a = b; } public Un (float b ) { a = (int)b; } public Un (int x , float y ) : this(y) { a += 100; } } C#
Un = class a : integer; public constructor creer; overload; constructor creer (b:integer); overload; constructor creer (b:real); overload; end; implementation constructor Un.creer; begin a := 100 end; constructor Un.creer(b:integer); begin a := b end; constructor Un.creer(b:real); begin a := trunc(b) end; constructor Un.creer(x:integer; y:real); begin self.creer(y); a := a+100; end;
En Delphi un constructeur a un nom quelconque, tous les constructeurs peuvent avoir des noms diffrents ou le mme nom comme en C#.
2.3 Utilisation du constructeur d'objet automatique (par dfaut) Le constructeur d'objet par dfaut de toute classe C# qu'elle soit de type valeur ou de type rfrence, comme nous l'avons signal plus haut est une mthode spciale sans paramtre, l'appel cette mthode spciale afin de construire un nouvel objet rpond une syntaxe spcifique par
- Rm di Scala
page
146
utilisation du mot clef new. Syntaxe Pour un constructeur sans paramtres formels, l'instruction d'instanciation d'un nouvel objet partir d'un identificateur de variable dclare selon un type de classe, s'crit syntaxiquement ainsi :
Exemple : (deux faons quivalentes de crer un objet x de classe Un) Un x ; x = new Un( );
Un x = new Un( )
Cette instruction cre dans le segment de mmoire, un nouvel objet de classe Un dont la rfrence (l'adresse) est mise dans la variable x, si x est de type rfrence, ou bien l'objet est directement cr dans la pile et mis dans la variable x, si x est de type valeur.
Soit Un une classe de type rfrence et Deux une autre classe de type valeur, ci-dessous une image des rsulats de l'instanciation d'un objet de chacune de ces deux classes : Un x = new Un( ) ; Deux y = new Deux ( ) ;
Dans l'exemple ci-dessous, nous utilisons le constructeur par dfaut de la classe Un , pour crer deux objets dans une autre classe : class Un { ... } class UnAutre {
- Rm di Scala
page
147
// la dclaration : Un x , y ; .... // la cration : x = new Un( ); y = new Un( ); } Un programme de 2 classes, illustrant l'affectation de rfrences : C#
class AppliClassesReferences { public static void Main(String [ ] arg) { Un x,y ; x = new Un( ); y = new Un( ); System.Console.WriteLine("x.a="+x.a); System.Console.WriteLine"y.a="+y.a); y = x; x.a =12; System.Console.WriteLine("x.a="+x.a); System.Console.WriteLine("y.a="+y.a); } } class Un { int a=10; }
Explication
Ce programme C# contient deux classes : class AppliClassesReferences et class Un La classe AppliClassesReferences est une classe excutable car elle contient la mthode main. C'est donc cette mthode qui agira ds l'excution du programme.
Dtaillons les instructions

Un x,y ; x = new Un( ); y = new Un( ); System.Console.WriteLine("x.a="+x.a); System.Console.WriteLine("y.a="+y.a);
Que se passe-t-il l'excution ?

Instanciation de 2 objets diffrents x et y de type Un. Affichage de : x.a = 10 y.a = 10 La rfrence de y est remplace par celle de x dans la variable y (y pointe donc vers le mme bloc que x). On change la valeur de l'attribut a de x, et l'on demande d'afficher les attributs de x et de y : x.a = 12 y.a = 12 Comme y pointe vers x, y et x sont maintenant le mme objet sous deux noms diffrents !
y = x;
x.a =12; System.Console.WriteLine("x.a="+x.a); System.Console.WriteLine("y.a="+y.a);
2.4 Utilisation d'un constructeur d'objet personnalis L'utilisation d'un constructeur personnalis d'une classe est semblable celle du constructeur par dfaut de la classe. La seule diffrence se trouve lors de l'instanciation : il faut fournir des paramtres effectifs lors de l'appel au constructeur.
- Rm di Scala
page
148
Syntaxe
Exemple avec plusieurs constructeurs : une classe C# class Un { int a ; public Un (int b ) { a=b; } public Un ( ) { a = 100 ; } public Un (float b ) { a = (int)b ; } public Un (int x , float y ) : this(y) { a += 100; } } Des objets crs Un obj1 = newUn( ); Un obj2 = new Un( 15 ); int k = 14; Un obj3 = new Un( k ); Un obj4 = new Un( 3.25f ); float r = -5.6; Un obj5 = new Un( r ); int x = 20; float y = -0.02; Un obj6 = new Un( x , y );
2.5 Le mot clef this - cas de la rfrence seulement Il est possible de dnommer dans les instructions d'une mthode de classe, un futur objet qui sera instanci plus tard. Le paramtre ou (mot clef) this est implicitement prsent dans chaque objet instanci et il contient la rfrence l'objet actuel. Il joue exactement le mme rle que le mot clef self en Delphi. Nous avons dj vu une de ses utilisations dans le cas des constructeurs. C# class Un { public Un ( ) { a = 100; } int a; } C# quivalent class Un { public Un ( ) { this.a = 100; } int a; }
Dans le programme de droite le mot clef this fait rfrence l'objet lui-mme, ce qui dans ce cas est superflu puisque la variable int a est un champ de l'objet. Montrons deux exemples d'utilisation pratique de this.
- Rm di Scala
page
149
Cas o l'objet est pass comme un paramtre dans une de ses mthodes : C#
class Un { public Un ( ) { a = 100; } public void methode1(Un x) { System.Console.WriteLine("champ a = " + x.a); } public void methode2( int b ) { a += b; methode1(this); } int a; }
Explications
La methode1(Un x) reoit un objet de type Un en paramtre et imprime son champ int a. La methode2( int b ) reoit un entier int b qu'elle additionne au champ int a de l'objet, puis elle appelle la mthode1 avec comme paramtre l'objet lui-mme.
Comparaison Delphi - C# sur cet exemple (similitude complte) Delphi

Un = class a : integer; public constructor creer; procedure methode1( x:Un ); procedure methode2 ( b:integer ); end; implementation constructor Un.creer; begin a := 100 end; procedure Un.methode1( x:Un ); begin showmessage( 'champ a ='+inttostr(x.a) ) end; procedure Un.methode2 ( b:integer ); begin a := a+b; methode1(self) end;
C#
class Un { public Un ( ) { a = 100; } public void methode1(Un x) { System.Console.WriteLine("champ a ="+x.a); } public void methode2( int b ) { a += b; methode1(this); } int a; }
Cas o le this sert outrepasser le masquage de visibilit : C#

class Un { int a; public void methode1(float a) { a = this.a + 7 ; } }
Explications
La methode1(float a) possde un paramtre float a dont le nom masque le nom du champ int a. Si nous voulons malgr tout accder au champ de l'objet, l'objet tant rfrenc par this, "this.a" est donc le champ int a de l'objet lui-mme.
Comparaison Delphi - C# sur ce second exemple (similitude complte aussi)

- Rm di Scala
page
150
Delphi Un = class a : integer; public procedure methode( a:real ); end; implementation procedure Un.methode( a:real );begin a = self.a + 7 ; end;
C# class Un { int a; public void methode(float a) { a = this.a + 7 ; } }
3. Variables et mthodes
Nous examinons dans ce paragraphe comment C# utilise les variables et les mthodes l'intrieur d'une classe. Il est possible de modifier des variables et des mthodes d'une classe ceci sera examin plus loin. En C#, les champs et les mthodes sont classs en deux catgories : Variables et mthodes de classe Variables et mthodes d'instance
3.1 Variables dans une classe en gnral Rappelons qu'en C#, nous pouvons dclarer dans un bloc (for, try,...) de nouvelles variables la condition qu'elles n'existent pas dj dans le corps de la mthode o elles sont dclares. Nous les dnommerons : variables locales de mthode. Exemple de variables locales de mthode : class Exemple { void calcul ( int x, int y ) {int a = 100; for ( int i = 1; i<10; i++ ) {char carlu;
System.Console.Write("Entrez un caractre : "); carlu = (char)System.Console.Read( );
La dfinition int a = 100; est locale la mthode en gnral La dfinition int i = 1; est locale la boucle for.
int b =15; a =.... ..... } }

Les dfinitions char carlu et int b sont locales au corps de la boucle for.
- Rm di Scala
page
151
C# ne connat pas la notion de variable globale au sens habituel donn cette dnomination, dans la mesure o toute variable ne peut tre dfinie qu' l'intrieur d'une classe, ou d'une mthode inclue dans une classe. Donc part les variables locales de mthode dfinies dans une mthode, C# reconnat une autre catgorie de variables, les variables dfinies dans une classe mais pas l'intrieur d'une mthode spcifique. Nous les dnommerons : attributs de classes parce que ces variables peuvent tre de deux catgories. Exemple de attributs de classe : class AppliVariableClasse { float r ; void calcul ( int x, int y ) { .... } int x =100; int valeur ( char x ) { ..... } long y; } Les attributs de classe peuvent tre soit de la catgorie des variables de classe, soit de la catgorie des variables d'instance. 3.2 Variables et mthodes d'instance C# se comporte comme un langage orient objet classique vis vis de ses variables et de ses mthodes. A chaque instanciation d'un nouvel objet d'une classe donne, la machine CLR enregistre le p-code des mthodes de la classe dans la zone de stockage des mthodes, elle alloue dans le segment de mmoire autant d'emplacements mmoire pour les variables que d'objet crs. C# dnomme cette catgorie les variables et les mthodes d'instance. une classe C# class AppliInstance { int x ; int y ; } Instanciation de 3 objets AppliInstance obj1 = new AppliInstance( ); AppliInstance obj2 = new AppliInstance( ); AppliInstance obj3 = new AppliInstance( ); Les variables float r , long y et int x sont des attributs de classe (ici en fait plus prcisment, des variables d'instance). La position de la dclaration de ces variables n'a aucune importance. Elles sont visibles dans tout le bloc classe (c'est dire visibles par toutes les mthodes de la classe).
Conseil : regroupez les variables de classe au dbut de la classe afin de mieux les grer.
Segment de mmoire associ ces 3 objets si la classe AppliInstance est de type rfrence :
- Rm di Scala
page
152
Segment de mmoire associ ces 3 objets si la classe AppliInstance tait de type valeur (pour mmoire):
struct AppliIn stance { int x ; int y ; }
Un programme C# 2 classes illustrant l'exemple prcdent (classe rfrence): Programme C# excutable class AppliInstance { public int x = -58 ; public int y = 20 ; } class Utilise { public static void Main( ) { AppliInstance obj1 = new AppliInstance( );
- Rm di Scala
page
153
AppliInstance obj2 = new AppliInstance( ); AppliInstance obj3 = new AppliInstance( ); System.Console.WriteLine( "obj1.x = " + obj1.x ); } }
3.3 Variables et mthodes de classe - static Variable de classe On identifie une variable ou une mthode de classe en prcdant sa dclaration du mot clef static. Nous avons dj pris la majorit de nos exemples simples avec de tels composants. Voici deux dclarations de variables de classe : static int x ; static int a = 5; Une variable de classe est accessible comme une variable d'instance (selon sa visibilit), mais aussi sans avoir instancier un objet de la classe, uniquement en rfrenant la variable par le nom de la classe dans la notation de chemin uniforme d'objet. une classe C# class AppliInstance { static int x ; int y ; } Instanciation de 3 objets AppliInstance obj1 = new AppliInstance( ); AppliInstance obj2 = newAppliInstance( ); AppliInstance obj3 = newAppliInstance( );
Voici une image du segment de mmoire associ ces 3 objets :
Exemple de variables de classe : class ApplistaticVar { public static int x =15 ; } La dfinition "static int x =15 ;" cre une variable de la classe ApplistaticVar, nomme x.
- Rm di Scala
page
154
class UtiliseApplistaticVar { int a ; void f( ) { a = ApplistaticVar.x ; ..... } }
L'instruction "a = ApplistaticVar.x ;" utilise la variable x comme variable de classe ApplistaticVar sans avoir instanci un objet de cette classe.
Nous pouvons utiliser la classe Math ( public sealed class Math ) qui contient des constantes et des fonctions mathmatiques courantes : public static const double E; // la constante e reprsente la base du logarithme nprien. public static const double PI; // la constante pi reprsente le rapport de la circonfrence d'un cercle son diamtre.
Mthode de classe Une mthode de classe est une mthode dont l'implmentation est la mme pour tous les objets de la classe, en fait la diffrence avec une mthode d'instance a lieu sur la catgorie des variables sur lesquelles ces mthodes agissent. De par leur dfinition les mthodes de classe ne peuvent travailler qu'avec des variables de classe, alors que les mthodes d'instances peuvent utiliser les deux catgories de variables. Un programme correct illustrant le discours : C#
class Exemple { public static int x ; int y ; public void f1(int a) { x = a; y = a; } public static void g1(int a) { x = a; } } class Utilise { public static void Main( ) { Exemple obj = new Exemple( ); obj.f1(10); System.Console.WriteLine("<f1(10)>obj.x="+ Exemple.x); Exemple.g1(50); System.Console.WriteLine("<g1(50)>obj.x="+ Exemple.x); } }
Explications
public void f1(int a) { x = a; //accs la variable de classe y = a ; //accs la variable d'instance } public static void g1(int a) { x = a; //accs la variable de classe y = a ; //engendrerait un erreur de compilation : accs une variable non static interdit ! } La mthode f1 accde toutes les variables de la classe Exemple, la mthode g1 n'accde qu'aux variables de classe (static et public). Aprs excution on obtient : <f1(10)>obj.x = 10 <g1(50)>obj.x = 50
Rsum pratique sur les membres de classe en C#

1) - Les mthodes et les variables de classe sont prcdes obligatoirement du mot clef static. Elles jouent un rle semblable celui qui est attribu aux variables et aux sousroutines globales dans un langage impratif classique. Programmer objet .Net avec C# - ( rv. 17.10..2007 ) - Rm di Scala
page
155
C# class Exemple1 { int a = 5; static int b = 19; void m1( ){...} static void m2( ) {...} }
Explications La variable a dans int a = 5; est une variable d'instance. La variable b dans static int b = 19; est une variable de classe. La mthode m2 dans static void m2( ) {...} est une mthode de classe.
2) - Pour utiliser une variable x1 ou une mthode meth1 de la classe Classe1, il suffit de d'crire Classe1.x1 ou bien Classe1.meth1.
C# class Exemple2 { public static int b = 19; public static void m2( ) {...} } class UtiliseExemple { Exemple2.b = 53; Exemple2.m2( ); ... }
Explications Dans la classe Exemple2, b est une variable de classe, m2 une mthode de classe. La classe UtiliseExemple fait appel la mthode m2 directement avec le nom de la classe, il en est de mme avec le champ b de la classe Exemple2
3) - Une variable de classe (prcde du mot clef static) est partage par tous les objets de la mme classe.
C#
Explications
- Rm di Scala
page
156
class AppliStatic { public static int x = -58 ; public int y = 20 ; ... } class Utilise { public static void Main(String [ ] arg) { AppliStatic obj1 = new AppliStatic( ); AppliStatic obj2 = new AppliStatic( ); AppliStatic obj3 = new AppliStatic( ); obj1.y = 100; AppliStatic.x = 101; System.Console.WriteLine("obj1.x="+ AppliStatic.x); System.Console.WriteLine("obj1.y="+obj1.y); System.Console.WriteLine("obj2.x="+ AppliStatic.x); System.Console.WriteLine("obj2.y="+obj2.y); System.Console.WriteLine("obj3.x="+ AppliStatic.x); System.Console.WriteLine("obj3.y="+obj3.y); AppliStatic.x = 99; System.Console.WriteLine("AppliStatic.x=" + AppliStatic.x); } }
Dans la classe AppliStatic x est une variable de classe, et y une variable d'instance. La classe Utilise cre 3 objets (obj1,obj2,obj3) de classe AppliStatic. L'instruction obj1.y = 100; est un accs au champ y de l'instance obj1. Ce n'est que le champ y de cet objet qui est modifi,les champs y des objets obj2 et obj3 restent inchangs Il ny a quune seule manire d'accder la variable static x, comme pour toute variable de classe, en utilisant le nom de la classe : AppliStatic.x = 101; Dans ce cas cette variable x est modifie globalement et donc tous les champs x de tous les objets obj1, obj2 et obj3 prennent la nouvelle valeur.
Au dbut lors de la cration des 3 objets, chacun des champs x vaut -58 et chacun des champs y vaut 20, l'affichage par System.Console.WriteLine(...) donne les rsultats suivants qui dmontrent le partage de la variable x par tous les objets. Aprs excution : obj1.x = 101 obj1.y = 100 obj2.x = 101 obj2.y = 20 obj3.x = 101 obj3.y = 20 AppliStatic.x = 99
4) - Une mthode de classe (prcde du mot clef static) ne peut utiliser que des variables de classe (prcdes du mot clef static) et jamais des variables d'instance.Une mthode d'instance peut accder aux deux catgories de variables
5) - Une mthode de classe (prcde du mot clef static) ne peut appeler (invoquer) que des mthodes de classe (prcdes du mot clef static).
C#
class AppliStatic { public static int x = -58 ; public int y = 20 ; public void f1(int a) { AppliStatic.x = a;
Explications
Nous reprenons l'exemple prcdent en ajoutant la classe AppliStatic une mthode interne f1 : public void f1(int a) { AppliStatic.x = a; y=6; } Cette mthode accde la variable de classe
- Rm di Scala
page
157
y=6; } } class Utilise { static void f2(int a) { AppliStatic.x = a; } public static void Main( ) { AppliStatic obj1 = new AppliStatic( ); AppliStatic obj2 = new AppliStatic( ); AppliStatic obj3 = new AppliStatic( ); obj1.y = 100; obj1.x = 101; AppliStatic.x = 99; f2(101); obj1.f1(102); } }
comme un champ d'objet. Nous rajoutons la classe Utilise, un mthode static (mthode de classe) note f2: static void f2(int a) { AppliStatic.x = a; } Cette mthode accde elle aussi la variable de classe parce qu c'est une mthode static. Nous avons donc trois manires d'accder la variable static x : soit directement comme une variable de classe proprement dite : AppliStatic.x = 99; soit indirectement par une mthode d'instance sur son champ : obj1.f1(102); soit indirectement par une mthode static (de classe) : f2(101);
Comme la mthode Main est static, elle peut invoquer la mthode f2 qui est aussi static.
Au paragraphe prcdent, nous avons indiqu que C# ne connaissait pas la notion de variable globale stricto sensu, mais en fait une variable static peut jouer le rle d'un variable globale pour un ensemble d'objets instancis partir de la mme classe.
Attention :
Contrairement Java qui autorise laccs une variable static partir dun nom dobjet la place du nom de la classe de dfinition, le compilateur C# impose une cohrence dans les dclarations, en refusant cette possibilit.
Depuis la version 2.0, une classe peut tre static, dans ce cas elle correspond un module de bibliothque de membres (mthodes et variables) obligatoirement tous static.
static class AppliStatic { public static int x = -58 ; public static int y = 20 ; public static void f1(int a) { x = a; y=6; } }
- Rm di Scala
page
158
- Rm di Scala
page
159
Polymorphisme d'objet en
Plan gnral:
Rappel des notions de base Polymorphisme d'objet en C# : dfinitions

1.1 Instanciation et utilisation dans le mme type 1.2 Polymorphisme d'objet implicite 1.3 Polymorphisme d'objet explicite par transtypage 1.4 Utilisation pratique du polymorphisme d'objet 1.5 Instanciation dans un type ascendant impossible
- Rm di Scala
page
160
Le polymorphisme en C#
Rappel utile sur les notions de bases Il existe un concept essentiel en POO dsignant la capacit d'une hirarchie de classes fournir diffrentes implmentations de mthodes portant le mme nom et par corollaire la capacit qu'ont des objets enfants de modifier les comportements hrits de leur parents. Ce concept d'adaptation diffrentes "situations" se dnomme le polymorphisme qui peut tre implment de diffrentes manires.
Polymorphisme d'objet C'est une interchangeabilit entre variables d'objets de classes de la mme hirarchie sous certaines conditions, que dnommons le polymorphisme d'objet.
Polymorphisme par hritage de mthode Lorsqu'une classe enfant hrite d'une classe mre, des mthodes supplmentaires nouvelles peuvent tre implmentes dans la classe enfant mais aussi des mthodes des parents peuvent tre substitues pour obtenir des implmentations diffrentes.
Polymorphisme par hritage de classes abstraites Une classe abstraite est une classe qui ne peut pas s'instancier elle-mme ; elle doit tre hrite. Certains membres de la classe peuvent ne pas tre implments, et c'est la classe qui hrite de fournir cette implmentation.
Polymorphisme par implmentation d'interfaces Une interface dcrit la signature complte des membres qu'une classe doit implmenter, mais elle laisse l'implmentation de tous ces membres la charge de la classe d'implmentation de l'interface.
Polymorphisme d'objet en C# Soit une classe Mere et une classe Fille hritant de la classe Mere :
- Rm di Scala
page
161
Les objets peuvent avoir des comportements polymorphes (s'adapter et se comporter diffrement selon leur utilisation) licites et des comportements polymorphes dangereux selon les langages. Dans un langage dont le modle objet est la rfrence (un objet est un couple : rfrence, bloc mmoire) comme C#, il y a dcouplage entre les actions statiques du compilateur et les actions dynamiques du systme d'excution, le compilateur protge statiquement des actions dynamiques sur les objets une fois crs. C'est la dclaration et l'utilisation des variables de rfrences qui autorise ou non les actions licites grce la compilation. Supposons que nous ayons dclar deux variables de rfrence, l'une de classe Mere, l'autre de classe Fille, une question qui se pose est la suivante : au cours du programme quel genre d'affectation et d'instanciation est-on autoris effectuer sur chacune de ces variables dans un programme C#.
En C# : public class Mere { ..... } public class Fille : Mere { ..... }
L'hritage permet une variabilit entre variables d'objets de classes de la mme hirarchie, c'est cette variabilit que dnommons le polymorphisme d'objet.
Nous envisageons toutes les situations possibles et les valuons, les exemples explicatifs sont crits en C# (lorsqu'il y a discordance avec java ou Delphi autres langages, celle-ci est mentionne explicitement), il existe 3 possibilits diffrentes illustres par le schma cidessous.
- Rm di Scala
page
162
L'instanciation et l'utilisation de rfrences dans le mme type L'affectation de rfrences : polymorphisme implicite L'affectation de rfrences : polymorphisme par transtypage d'objet La dernire de ces possibilits pose un problme d'excution lorsqu'elle mal employe !
1.1 instanciation dans le type initial et utilisation dans le mme type

Il s'agit ici d'une utilisation la plus classique qui soit, dans laquelle une variable de rfrence d'objet est utilise dans son type de dfinition initial (valable dans tous les LOO)
En C# : Mere x , u ; Fille y , w ; ..... x = new Mere( ) ; // instanciation dans le type initial u = x ; // affectation de rfrences du mme type y = new Fille( ) ; // instanciation dans le type initial w = y ; // affectation de rfrences du mme type
- Rm di Scala
page
163
1.2 Polymorphisme d'objet implicite
En C# : Mere x ; Fille ObjF = new Fille( ) ; x = ObjF; // affectation de rfrences du type descendant implicite
Nous pouvons en effet dire que x peut se rfrer implicitement tout objet de classe Mere ou de toute classe hritant de la classe Mere.
fig - 1
fig - 2
- Rm di Scala
page
164
Dans la figure fig-1 ci-dessus, une hirarchie de classes decendant toutes de la classe Mere, dans fig-2 ci-contre le schma montre une rfrence de type Mere qui peut 'pointer' vers n'importe quel objet de classe descendante (polymorphisme d'objet). D'une faon gnrale vous pourrez toujours crire des affectations entre deux rfrences d'objets :
En C# : Classe1 x ; Classe2 y ; .......... x=y; si et seulement si Classe2 est une classe descendante de Classe1.
Exemple pratique tir du schma prcdent 1) Le polymorphisme d'objet est typiquement fait pour reprsenter des situations pratiques figures ci-dessous :
Une hirarchie de classe de vhicules descendant toutes de la classe mre Vehicule, on peut noncer le fait suivant : Un vhicule peut tre de plusieurs sortes : soit un croiseur, soit une voiture, soit un vhicule terrestre etc... Traduit en termes informatiques, si l'on dclare une rfrence de type vhicule (vehicule x) elle pourra pointer vers n'importe quel objet d'une des classe filles de la classe vehicule.
En C# : public class Vehicule { .......... } public class terrestre : Vehicule{ .......... } public class voiture : terrestre { .......... } public class marin : Vehicule { .......... } public class voilier : marin { .......... } public class croiseur : marin { .......... }
- Rm di Scala
page
165
Mettons en oeuvre la dfinition du polymorphisme implicite : Polymorphisme implicite = cration d'objet de classe descendante rfrenc par une variable parent Ajoutons 2 classes la hirarchie des vhicules :
Partons de la situation pratique suivante : on cre un vhicule du type voiture, on cre une voiture de type berline, enfin on cre un break de type break
Traduit en termes informatiques : nous dclarons 3 rfrences x, y et z de type vehicule, voiture et break et nous crons 3 objets de classe voiture, berline et break. Comme il est possible de crer directement un objet de classe descendante partir d'une rfrence de classe mre, nous proposons les instanciations suivantes : on cre une voiture rfrence par la variable de classe vehicule, on cre une berline rfrence par la variable de classe voiture, enfin on cre un break rfrenc par la variable de classe break.
- Rm di Scala
page
166
En C# : public class berline : voiture { .......... } public class break : voiture { .......... }
public class Fabriquer { Vehicule x = new voiture ( ) ; voiture y = new berline ( ) ; break z = new break ( ); .......... }
1.3 Polymorphisme d'objet explicite par transtypage

La situation informatique est la suivante : on dclare une variable x de type Mere, on dclare une variable y de type Fille hritant de Mere, on instancie la variable x dans le type descendant Fille (polymorphisme implicite).
Il est alors possible de faire "pointer" la variable y (de type Fille) vers l'objet (de type Fille) auquel se rfre x en effectuant une affectation de rfrences : y = x ne sera pas accepte directement car statiquement les variables x et y ne sont pas du mme type, il faut indiquer au compilateur que l'on souhaite temporairement changer le type de la variable x afin de pouvoir effectuer l'affectation. Cette opration de changement temporaire, se dnomme le transtypage (note en C# : y = (Fille)x ) :
- Rm di Scala
page
167
En C# : Mere x ; Fille y ; Fille ObjF = new Fille( ) ; x = ObjF ; // x pointe vers un objet de type Fille y = (Fille) x ; // transtypage et affectation de rfrences du type ascendant explicite compatible dynamiquement.
Attention
La validit du transtypage n'est pas vrifie statiquement par le compilateur, donc si votre variable de rfrence pointe vers un objet qui n'a pas la mme nature que l'oprateur de transtypage, c'est lors de l'excution qu'il y aura production d'un message d'erreur indiquant le transtypage impossible. Il est donc impratif de tester l'appartenance la bonne classe de l'objet transtyper avant de le transtyper, les langages C#, Delphi et Java disposent d'un oprateur permettant de tester cette appartenance ou plutt l'appartenance une hirarchie de classes (oprateur is en C#). L'oprateur as est un oprateur de transtypage de rfrence d'objet semblable l'oprateur ( ). L'oprateur as fournit la valeur null en cas d'chec de conversion alors que l'oprateur ( ) lve une exception.
- Rm di Scala
page
168
En C# : Mere x ; Fille y ; x = new Mere( ) ; // instanciation dans le type initial { affectation de rfrences du type ascendant explicite mais dangereuse si x est uniquement Mere : } y = (Fille)x ; <--- erreur lors de l'excution ici {affectation accepte statiquement mais refuse dynamiquement, car x pointe vers un objet de type Mere }
En reprenant l'exemple pratique prcdant de la hirarchie des vhicules :
Puisque x pointe vers un objet de type voiture toute variable de rfrence acceptera de pointer vers cet objet, en particulier la variable voiture aprs transtypage de la rfrence de x. En C# l'affectation s'crirait par application de l'oprateur de transtypage :
y = ( voiture ) x;
Pour pallier cet inconvnient de programmation pouvant lever des exceptions lors de l'excution, C# offre au dveloppeur la possibilit de tester l'appartenance d'un objet rfrenc par une variable quelconque une classe ou plutt une hirarchie de classe ; en C# cet oprateur se dnote is : L'oprateur "is" de C# est identique celui de Delphi : L'oprateur is, qui effectue une vrification de type dynamique, est utilis pour vrifier quelle est effectivement la classe d'un objet l'excution. L'expression : objet is classeT renvoie True si objet est une instance de la classe dsigne par classeT ou de l'un de ses descendants, et False sinon. Si objet a la valeur nil, le rsultat est False.
- Rm di Scala
page
169
En C# : Mere x ; Fille y ; x = new Mere( ) ; // instanciation dans le type initial if ( x is Fille) // test d'appartenance de l'objet rfrenc par x la bonne classe y = (Fille)x ;
1.4 Utilisation pratique du polymorphisme d'objet

Le polymorphisme d'objet associ au transtypage est trs utile dans les paramtres des mthodes.
Lorsque vous dclarez une mthode meth avec un paramtre formel x de type ClasseT : void meth ( ClasseT x ) { ........ } Vous pouvez utiliser lors de l'appel de la mthode meth n'importe quel paramtre effectif de ClasseT ou bien d'une quelconque classe descendant de ClasseT et ensuite l'intrieur de la procdure vous transtypez le paramtre. Cet aspect est utilis en particulier en C# lors de la cration de gestionnaires d'vnements communs plusieurs composants :
private void meth1(object sender, System.EventArgs e) { if (sender is System.Windows.Forms.TextBox) (sender as TextBox).Text="Fin"; else if (sender is System.Windows.Forms.Label) (sender as Label).Text="ok"; // ou encore : if (sender is System.Windows.Forms.TextBox) ( (TextBox)sender ).Text="Fin"; else if (sender is System.Windows.Forms.Label) ( (Label)sender ).Text="ok";
} Autre exemple avec une mthode personnelle nomme meth2 sur la hirarchie prcdente des vhicules :
private void meth2 ( vehicule Sender ); { if (Sender is voiture) ((voiture)Sender). ....... ; else if (Sender is voilier) ((voilier)Sender). ....... ; ............ }
- Rm di Scala
page
170
instanciation dans un type ascendant ( impossible en C#)

Il s'agit ici d'une utilisation non licite qui n'est pas commune tous les langages LOO. Le compilateur C# comme le compilateur Java, refuse ce type de cration d'objet, les compilateurs C++ et Delphi acceptent ce genre d'instanciation en laissant au programmeur le soin de se dbrouiller avec les problmes de cohrence lorsqu'ils apparatront.
- Rm di Scala
page
171
Polymorphisme de mthode en
Plan gnral:
1. Le polymophisme de mthodes en C#
Rappel des notions de base 1.1 Surcharge et redfinition en C# 1.2 Liaison statique et masquage en C# 1.3 Liaison dynamique en C# 1.4 Comment opre le compilateur Rsum pratique
2. Accs la super classe en C#

2.1 Le mot clef base 2.2 Initialiseur de constructeur this et base 2.3 Comparaison C#, Delphi et Java sur un exemple 2.4 Traitement d'un exercice complet 2.5 Destructeur-finaliseur
- Rm di Scala
page
172
1. Le polymorphisme de mthode en C#
Nous avons vu au chapitre prcdent le polymorphisme d'objet, les mthodes peuvent tre elles aussi polymorphes. Nous voyons ici comment C# hrite pour une bonne part de Delphi pour ses comportements sur le polymorphisme d'objet et de mthode, et de la souplesse de Java pour l'criture. Rappel de base
Polymorphisme par hritage de mthode

Lorsqu'une classe enfant hrite d'une classe mre, des mthodes supplmentaires nouvelles peuvent tre implmentes dans la classe enfant, mais aussi des mthodes des parents substitues pour obtenir des implmentations diffrentes. L'objectif vis en terme de qualiti du logiciel est la rutilisabilit en particulier lorsque l'on ralise une mme opration sur des lments diffrents : opration = ouvrir ( ) ouvrir une fentre de texte, ouvrir un fichier, ouvrir une image etc ...
Surcharge et redfinition avec C#

En informatique ce vocable s'applique aux mthodes selon leur degr d'adaptabilit, nous distinguons alors deux dnominations :
le polymorphisme statique ou la surcharge de mthode le polymorphisme dynamique ou la redfinition de mthode ou encore la surcharge hrite.
1.1 Surcharge La surcharge de mthode (polymorphisme statique de mthode) est une fonctionnalit classique des langages trs volus et en particulier des langages orients objet dont C# fait partie; elle consiste dans le fait qu'une classe peut disposer de plusieurs mthodes ayant le mme nom, mais avec des paramtres formels diffrents ou ventuellement un type de retour diffrent. On dit alors que ces mthodes n'ont pas la mme signature
On rappelle que la signature d'une mthode est forme par l'en-tte de la mthode avec ses paramtres formels et leur type. Nous avons dj utilis cette fonctionnalit prcdement dans le paragraphe sur les constructeurs, o la classe Un disposait de quatre constructeurs surchargs (quatre signatures diffrentes du constructeur) :
class Un { int a; public Un ( ) { a = 100; } public Un (int b ) Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
173
{ a = b; } public Un (float b ) { a = (int)b; } public Un (int x , float y ) : this(y) { a += 100; } }
Mais cette surcharge est possible aussi pour n'importe quelle mthode de la classe autre que le constructeur.
Ci-contre deux exemplaires surchargs de la mthode ouvrir dans la classe PortesEtFenetres :
Le compilateur n'prouve aucune difficult lorsqu'il rencontre un appel l'une des versions surcharge d'une mthode, il cherche dans la dclaration de toutes les surcharges celle dont la signature (la dclaration des paramtres formels) concide avec les paramtres effectifs de l'appel. Remarque : Le polymorphisme statique (ou surcharge) de C# est syntaxiquement semblable celui de Java.
Programme C# excutable
class Un { public int a; public Un (int b ) { a = b; } public void f ( ) { a *=10; } public void f ( int x ) { a +=10*x; } public int f ( int x, char y ) { a = x+(int)y; return a; } } class AppliSurcharge { public static void Main(String [ ] arg) { Un obj = new Un(15); System.Console.WriteLine("<cration> a ="+obj.a); obj.f( ); System.Console.WriteLine("<obj.f()> a ="+obj.a); obj.f(2); System.Console.WriteLine("<obj.f()> a ="+obj.a); obj.f(50,'a'); System.Console.WriteLine("<obj.f()> a ="+obj.a); } }
Explications
La mthode f de la classe Un est surcharge trois fois : public void f ( ) { a *=10; } public void f ( int x ) { a +=10*x; } public int f ( int x, char y ) { a = x+(int)y; return a; } La mthode f de la classe Un peut donc tre appele par un objet instanci de cette classe sous l'une quelconque des trois formes : obj.f( ); pas de paramtre => choix : void f ( ) obj.f(2); paramtre int => choix : void f ( int x ) obj.f(50,'a'); deux paramtres, un int un char => choix : int f ( int x, char y )
Comparaison Delphi - C# sur la surcharge :

- Rm di Scala
page
174
Delphi
Un = class a : integer; public constructor methode( b : integer ); procedure f;overload; procedure f(x:integer);overload; function f(x:integer;y:char):integer;overload; end; implementation constructor Un.methode( b : integer ); begin a:=b end; procedure Un.f; begin a:=a*10; end; procedure Un.f(x:integer); begin a:=a+10*x end; function Un.f(x:integer;y:char):integer; begin a:=x+ord(y); result:= a end; procedure Main; var obj:Un; begin obj:=Un.methode(15); obj.f; Memo1.Lines.Add('obj.f='+inttostr(obj.a)); obj.f(2); Memo1.Lines.Add('obj.f(2)='+inttostr(obj.a)); obj.f(50,'a'); Memo1.Lines.Add('obj.f(50,''a'')='+inttostr(obj.a)); end; class Un { public int a; public Un (int b ) { a = b; }
C#
public void f ( ) { a *=10; } public void f ( int x ) { a +=10*x; } public int f ( int x, char y ) { a = x+(int)y; return a; } }
class AppliSurcharge { public static void Main(String [ ] arg) { Un obj = new Un(15); System.Console.WriteLine("<cration> a ="+obj.a); obj.f( ); System.Console.WriteLine("<obj.f()> a ="+obj.a); obj.f(2); System.Console.WriteLine("<obj.f()> a ="+obj.a); obj.f(50,'a'); System.Console.WriteLine("<obj.f()> a ="+obj.a); } }
Redfinition
La redfinition de mthode (ou polymorphisme dynamique) est spcifique aux langages orients objet. Elle est mise en oeuvre lors de l'hritage d'une classe mre vers une classe fille dans le cas d'une mthode ayant la mme signature dans les deux classes. Dans ce cas les actions des l'appel de la mthode, dpendent du code inhrent chaque version de la mthode (celle de la classe mre, ou bien celle de la classe fille). Dans l'exemple ci-dessous, nous supposons que dans la classe PortesEtFenetres la mthode ouvrir(fenetre) explique le mode opratoire gnral d'ouverture d'une fentre, il est clair que dans les deux classes descendantes l'on doit "redfinir" le mode opratoire selon que l'on est en prsence d'une fentre la franaise, ou d'une fentre l'anglaise :
- Rm di Scala
page
175
Redfinition et rpartition des mthodes en C#

La redfinition de mthode peut tre selon les langages :
prcoce
et/ou
tardive
Ces deux actions sont diffrentes selon que le compilateur du langage met en place la laison du code de la mthode immdiatement lors de la compilation (liaison statique ou prcoce) ou bien lorsque le code est li lors de l'excution (laison dynamique ou tardive). Ce phnomne se dnomme la rpartition des mthodes. Le terme de rpartition fait rfrence la faon dont un programme dtermine o il doit rechercher une mthode lorsqu'il rencontre un appel cette mthode. Le code qui appelle une mthode ressemble un appel classique de mthode. Mais les classes ont des faons diffrentes de rpartir les mthodes.
Le langage C# supporte d'une manire identique Delphi, ces deux modes de liaison du code, la liaison statique tant comme en Delphi le mode par dfaut. Le dveloppeur Java sera plus dcontenanc sur ce sujet, car la liaison statique en Java n'existe que pour les methodes de classe static ou bien qualifie de final, de plus la liaison du code par dfaut est dynamique en Java.
Donc en C# comme en Delphi, des mots clefs comme virtual et override sont ncessaires pour la redfinition de mthode, ils sont utiliss strictement de la mme manire qu'en Delphi.
- Rm di Scala
page
176
1.2 Liaison statique et masquage en C# Toute mthode C# qui n'est prcde d'aucun des deux qualificateurs virtual ou override est liaison statique. Le compilateur dtermine l'adresse exacte de la mthode et lie la mthode au moment de la compilation. L'avantage principal des mthodes statiques est que leur rpartition est trs rapide. Comme le compilateur peut dterminer l'adresse exacte de la mthode, il la lie directement (les mthodes virtuelles, au contraire, utilisent un moyen indirect pour rcuprer l'adresse des mthodes l'excution, moyen qui ncessite plus de temps). Une mthode statique ne change pas lorsqu'elle est transmise en hritage une autre classe. Si vous dclarez une classe qui inclut une mthode statique, puis en drivez une nouvelle classe, la classe drive partage exactement la mme mthode situe la mme adresse. Cela signifie qu'il est impossible de redfinir les mthodes statiques; une mthode statique fait toujours exactement la mme chose, quelque soit la classe dans laquelle elle est appele. Si vous dclarez dans une classe drive une mthode ayant le mme nom qu'une mthode statique de la classe anctre, la nouvelle mthode remplace simplement (on dit aussi masque) la mthode hrite dans la classe drive. Comparaison masquage en Delphi et C# : Delphi
type ClasseMere = class x : integer; procedure f (a:integer); end; ClasseFille = class ( ClasseMere ) y : integer; procedure f (a:integer);//masquage end; implementation procedure ClasseMere.f (a:integer); begin... end; procedure ClasseFille.f (a:integer); begin... end;
C#
public class ClasseMere { public int x = 10; public void f ( int a) { x +=a; } } public class ClasseFille : ClasseMere { int y = 20; public void f ( int a) //masquage { x +=a*10+y; } }
Remarque importante : L'exprience montre que les tudiants comprennent immdiatement le masquage lorsque le polymorphisme d'objet n'est pas prsent. Ci-dessous un exemple de classe UtiliseMereFille qui instancie et utilise dans le mme type un objet de classe ClasseMere et un objet de classe ClasseFille :
- Rm di Scala
page
177
Lors de la compilation de l'instruction M.meth(10), c'est le code de la mthode meth de la classe ClasseMere qui est li avec comme paramtre par valeur 10; ce qui donnera la valeur 11 au champ x de l'objet M. Lors de la compilation de l'instruction F.meth(10), c'est le code de la mthode meth de la classe ClasseFille qui masque celui de la classe parent et qui est donc li avec comme paramtre par valeur 10; ce qui donnera la valeur 101 au champ x de l'objet F.
Pour bien comprendre toute la porte du masquage statique et les risques de mauvaises interprtations, il faut tudier le mme exemple lgrement modifi en incluant le cas du polymorphisme d'objet, plus prcisment le polymorphisme d'objet implicite. Dans l'exemple prcdent nous instancions la variable ClasseMere M en un objet de classe ClasseFille (polymorphisme implicite d'objet) soient les instructions ClasseMere M ; M = new ClasseFille ( ) ; Une erreur courante est de croire que dans ces conditions, dans l'instruction M.meth(10) c'est la mthode meth(int a) de la classe ClasseFille (en particulier si l'on ne connat que Java qui ne pratique pas le masquage) :
- Rm di Scala
page
178
Que fait alors le compilateur C# dans ce cas ? : il ralise une liaison statique : Lors de la compilation de l'instruction M.meth(10), c'est le code de la mthode meth(int a) de la classe ClasseMere qui est li, car la rfrence M a t dclare de type ClasseMere et peu importe dans quelle classe elle a t instancie ( avec comme paramtre par valeur 10; ce qui donnera la valeur 11 au champ x de l'objet M). Lors de la compilation de l'instruction F.meth(10), c'est le code de la mthode meth de la classe ClasseFille comme dans l'exemple prcdent (avec comme paramtre par valeur 10; ce qui donnera la valeur 101 au champ x de l'objet F).
Voici la bonne configuration de laison effectue lors de la compilation :
- Rm di Scala
page
179
Afin que le programmeur soit bien conscient d'un effet de masquage d'une mthode hrite par une mthode locale, le compilateur C# envoie, comme le compilateur Delphi, un message d'avertissement indiquant une possibilit de manque de cohrence smantique ou un masquage. S'il s'agit d'un masquage voulu, le petit plus apport par le langage C# est la proposition que vous fait le compilateur de l'utilisation optionnelle du mot clef new qualifiant la nouvelle mthode masquant la mthode parent. Cette criture amliore la lisibilit du programme et permet de se rendre compte que l'on travaille avec une liaison statique. Ci-dessous deux critures quivalentes du masquage de la mthode meth de la classe ClasseMere : masquage C#
public class ClasseMere { public int x = 10; public void meth ( int a) //liaison statique { x +=a; } } public class ClasseFille : ClasseMere { public void meth ( int a) //masquage { x +=a*10+y; } }
masquage C# avec new

public class ClasseMere { public int x = 10; public void meth ( int a) //liaison statique { x +=a; } } public class ClasseFille : ClasseMere { public new void meth ( int a) //masquage { x +=a*10+y; } }
L'exemple ci-dessous rcapitule les notions de masquage et de surcharge en C# :

- Rm di Scala
page
180
public class ClasseMere { public int x = 1; public void meth1 ( int a) { x += a ; } public void meth1 ( int a , int b) { x += a*b ; } } public class ClasseFille : ClasseMere { public new void meth1 ( int a) { x += a*100 ; } public void meth1 ( int a , int b , int c) { x += a*b*c ; } } public class UtiliseMereFille { public static void Main (string [ ] args) { ClasseMere M ; ClasseFille F ; M = new ClasseFille ( ) ; F = new ClasseFille ( ) ; M.meth1 (10) ; <--- meth1(int a) de ClasseMere M.meth1 (10,5) ; <--- meth1(int a, int b) de ClasseMere M.meth1 (10,5,2) ; <--- erreur! n'existe pas dans ClasseMere . F.meth1 (10) ; <--- meth1(int a) de ClasseFille F.meth1 (10,5) ; <--- meth1(int a, int b) de ClasseFille F.meth1 (10,5,2) ; <--- meth1(int a, int b, int c) de ClasseFille } } 1.3 Liaison dynamique (ou redfinition) en C# Toute mthode C# qui est prcde par l'un des deux qualificateurs virtual ou override est liaison dynamique, on dit aussi que c'est une mthode virtuelle. Le compilateur ne dtermine pas l'adresse exacte de la mthode et lie la mthode au moment de l'excution. (le CLR utilise un moyen indirect comme une table pour rcuprer l'adresse des mthodes lors de l'excution). Une mthode "f" de classe fille qui redfinit la mthode virtuelle "f" de classe mre, doit avoir la mme signature que la mthode "f" de classe mre qu'elle redfinit.
Dans l'exemple ci-dessous la classe ClasseFille qui hrite de la classe ClasseMere, redfinit la mthode virtuelle f de sa classe mre : Comparaison redfinition Delphi et C# : Delphi
type ClasseMere = class x : integer; procedure f (a:integer);virtual;//dclaration procedure g(a,b:integer); end; ClasseFille = class ( ClasseMere ) y : integer; Programmer objet .Net avec C# - ( rv. 17.10..2007 ) class ClasseMere { public int x = 10; public virtual void f ( int a) //dclaration { x +=a; } void g ( int a, int b) { x +=a*b; } }
- Rm di Scala
C#
page
181
procedure f (a:integer);override;//redfinition procedure g1(a,b:integer); end; implementation procedure ClasseMere.f (a:integer); begin... end; procedure ClasseMere.g(a,b:integer); begin... end; procedure ClasseFille.f (a:integer); begin... end; procedure ClasseFille.g1(a,b:integer); begin... end;
class ClasseFille : ClasseMere { int y = 20; public override void f ( int a) //redfinition { x +=a; } void g1 (int a, int b) //nouvelle mthode { ...... } }
Comme delphi, C# peut combiner la surcharge et la redfinition sur une mme mthode, c'est pourquoi nous pouvons parler de surcharge hrite : C#
class ClasseMere { public int x = 10; public virtual void f ( int a) // dclaration de f et signature initiale { x +=a; } } class ClasseFille : ClasseMere { int y = 20; public override void f ( int a) //redfinition de f et mme signature { x +=a; } public virtual void f (char b) //nouvelle dclaration par surcharge de f , signature diffrente { x +=b*y; } }
1.4 Comment opre le compilateur C# en liaison dynamique C'est le compilateur C# qui fait tout le travail de recherche de la bonne mthode. Prenons un objet obj de classe Classe1, lorsque le compilateur C# trouve une instruction du genre "obj.method1(paramtres effectifs);", sa dmarche d'analyse est semblable celle du compilateur Delphi, il cherche dans l'ordre suivant : Y-a-t-il dans Classe1, une mthode qui se nomme method1 ayant une signature identique aux paramtres effectifs ? si oui c'est la mthode ayant cette signature qui est appele, si non le compilateur remonte dans la hierarchie des classes mres de Classe1 en posant la mme question rcursivement jusqu' ce qu'il termine sur la classe Object. Si aucune mthode ayant cette signature n'est trouve il signale une erreur.
- Rm di Scala
page
182
Soit partir de l'exemple prcdent les instructions suivantes : ClasseFille obj = new ClasseFille( ); obj.g(-3,8); obj.g('h'); Le compilateur C# applique la dmarche d'analyse dcrite, l'instruction "obj.g(-3,8);". Ne trouvant pas dans ClasseFille de mthode ayant la bonne signature (signature = deux entiers) , le compilateur remonte dans la classe mre ClasseMere et trouve une mthode " void g ( int a, int b) " de la classe ClasseMere ayant la bonne signature (signature = deux entiers), lors de l'excution, la machine virtuelle CLR procde alors l'appel de cette mthode sur les paramtres effectifs (-3,8). Dans le cas de l'instruction obj.g('h'); , le compilateur trouve immdiatement dans ClasseFille la mthode " void g (char b) " ayant la bonne signature, c'est donc elle qui est appele sur le paramtre effectif 'h'. Le compilateur et le CLR consultent les mta-donnes (informations de description) de l'assemblage en cours ( applicationXXX.exe ), plus particulirement les mtadonnes de type qui sont stockes au fur et mesure dans de nombreuses tables. Nous figurons ci-dessous deux tables de dfinition importantes relativement au polymorphisme de mthode MethodDef et TypeDef utilises par le compilateur.
- Rm di Scala
page
183
Rsum pratique sur le polymorphisme en C#

La surcharge (polymorphisme statique) consiste proposer diffrentes signatures de la mme mthode. La redfinition (polymorphisme dynamique) ne se produit que dans l'hritage d'une classe, par redfinition (liaison dynamique) de la mthode mre avec une mthode fille (ayant ou n'ayant pas la mme signature). Le masquage ne se produit que dans l'hritage d'une classe, par redfinition (liaison statique) de la mthode mre par une mthode fille (ayant la mme signature). Toute mthode est considre liaison statique sauf si vous la dclarez autrement.
2. Accs la super classe en C#

2.1 Le mot clef ' base ' Nous venons de voir que le compilateur s'arrte ds qu'il trouve une mthode ayant la bonne signature dans la hirarchie des classes, il est des cas o nous voudrions accder une mthode de la classe mre alors que celle-ci est redfinie dans la classe fille. C'est un problme analogue l'utilisation du this lors du masquage d'un attribut. classe mre
class
classe fille class ClasseB : ClasseA { public new void meth01 ( ) { attrA = 1000 ; } public void meth02 ( ) { meth01 ( ); } }
ClasseA
{ public int attrA ; private int attrXA ; public void meth01 ( ) { attrA = 57 ; } }
La mthode meth02 ( ) invoque la mthode meth01 ( ) de la classe ClasseB. Il est impossible de faire directement appel la mthode meth01 ( ) de la classe mre ClasseA car celle-ci est masque dans la classe fille.
- Rm di Scala
page
184
Il existe en C# un mcanisme dclench par un mot clef qui permet d'accder la classe mre (classe immdiatement au dessus): ce mot est base. Le mot clef base fonctionne comme une rfrence d'objet et il est utilis pour accder tous les membres visibles de la classe mre partir d'une classe fille drive directement de cette classe mre (la super-classe en Java).
Ce mot clef base est trs semblable au mot clef inherited de Delphi qui joue le mme rle sur les mthodes et les proprits (il est en fait plus proche du mot clef super de Java car il ne remonte qu' la classe mre), il permet l'appel d'une mthode de la classe de base qui a t substitue (masque ou redfinie) par une autre mthode dans la classe fille. Exemple :
Remarques : Le fait d'utiliser le mot clef base partir d'une mthode statique constitue une erreur. base est utile pour spcifier un constructeur de classe mre lors de la cration d'instances de la classe fille.
Nous dveloppons ci-dessous l'utilisation du mot clef base afin d'initialiser un constructeur.
- Rm di Scala
page
185
2.2 Initialiseur de constructeur this et base Semblablement Delphi et Java, tous les constructeurs d'instance C# autorisent l'appel d'un autre constructeur d'instance immdiatement avant le corps du constructeur, cet appel est dnomm l'initialiseur du constructeur, en Delphi cet appel doit tre explicite, en C# et en Java cet appel peut tre implicite. Rappelons que comme en Java o dans toute classe ne contenant aucun constructeur, en C# un constructeur sans paramtres par dfaut est implicitement dfini :
vous crivez votre code comme ceci : class ClasseA { public int attrA ; public string attrStrA ; }
il est complt implicitement ainsi : class ClasseA { public int attrA ; public string attrStrA ; public ClasseA ( ) { } }
Remarque : Lors de l'hritage d'une classe fille, diffremment Delphi et Java, si un constructeur d'instance C# de la classe fille ne fait pas figurer explicitement d'initialiseur de constructeur, c'est qu'en fait un initialiseur de constructeur ayant la forme base( ) lui a t fourni implicitement.
Soit par exemple une classe ClasseA possdant 2 constructeurs :

class ClasseA { public int attrA ; public string attrStrA ; public ClasseA ( ) { /* premier constructeur */ attrA = 57 ; } public ClasseA ( string s ) { /* second constructeur */ attrStrA = s +"...1..." ; } }
Soit par suite une classe fille ClasseB drivant de ClasseA possdant elle aussi 2 constructeurs, les deux dclarations ci-dessous sont quivalentes : Initialiseur implicite Initialiseur explicite quivalent
- Rm di Scala
page
186
class ClasseB : ClasseA { /* premier constructeur */ public ClasseB ( ) { attrStrA = "..." ; } /* second constructeur */ public ClasseB ( string s ) { attrStrA = s ; } }
class ClasseB : ClasseA { /* premier constructeur */ public ClasseB ( ) : base( ) { attrStrA = "..." ; } /* second constructeur */ public ClasseB ( string s ) : base( ) { attrStrA = s ; } }
Dans les deux cas le corps du constructeur de la classe fille est initialis par un premier appel au constructeur de la classe mre ( ), en l'occurrence << public ClasseA ( ) ... /* premier constructeur */ >>
Initialiseur base( ) avant le corps

L'appel explicite au constructeur sans paramtre de classe mre doit obligatoirement tre mis la suite de l'en-tte du constructeur de classe fille (on doit d'abord construire l'objet comme tant de classe mre et ensuite on continue sa construction comme un objet de classe fille). Remarque : Dans une classe fille, en C# comme en Java, tout constructeur de la classe fille appelle implicitement et automatiquement le constructeur par dfaut (celui qui est sans paramtres) de la classe mre. Exemple : vous crivez votre code comme ceci : class ClasseA { public int attrA ; public string attrStrA ; } class ClasseB : ClasseA { } } Le constructeur de ClasseA sans paramtres est implicitement dclar par le compilateur. class ClasseB : ClasseA { public ClasseB ( ): base( ) { } } il est complt implicitement ainsi : class ClasseA { public int attrA ; public string attrStrA ; public ClasseA ( ) { }
Si la classe mre ne possde pas de constructeur par dfaut, le compilateur engendre un message d'erreur : vous crivez votre code comme ceci :
il est complt implicitement ainsi :

- Rm di Scala
page
187
class ClasseA { public int attrA ; public string attrStrA ; public ClasseA ( int a ) { } } class ClasseB : ClasseA { public ClasseB ( ) { //..... } }
La classe de base ClasseA ne comporte qu'un seul constructeur explicite un paramtre. Le constructeur sans paramtres n'existe que si vous le dclarez explicitement, ou bien si la classe ne possde pas de constructeur explicitement dclar.
class ClasseA { public int attrA ; public string attrStrA ; public ClasseA ( int a ) { } } class ClasseB : ClasseA { public ClasseB ( ): base( ) { // .... } }
L'initialiseur implicite base( ) renvoie le compilateur chercher dans la classe de base un constructeur sans paramtres. Or il n'existe pas dans la classe de base (ClasseA) de constructeur par dfaut sans paramtres. Donc la tentative choue !
Le message d'erreur sur la ligne " public ClasseB ( ) { ", est le suivant : [C# Erreur] Class.cs(54): Aucune surcharge pour la mthode 'ClasseA' ne prend d'arguments '0' Remarque : Donc sans initialiseur explicite, tout objet de classe fille ClasseB est minima et par dfaut, instanci comme un objet de classe de base ClasseA.
Initialiseur this( ) avant le corps

Lorsque l'on veut invoquer dans un constructeur d'une classe donne un autre constructeur de cette mme classe tant donn que tous les constructeurs ont le mme nom, il faut utiliser le mot clef this comme nom d'appel. La syntaxe d'utilisation du this() est semblable celle du base() : la suite de l'en-tte du constructeur de classe fille .
Exemple : Reprenons la mme classe ClasseA possdant 2 constructeurs et la classe ClasseB drivant de ClasseA, nous marquons les actions des constructeurs par une chane indiquant le numro du constructeur invoqu ainsi que sa classe : class ClasseA { public int attrA ; public string attrStrA ; public ClasseA ( ) { /* premier constructeur */ attrA = 57 ; }
- Rm di Scala
page
188
public ClasseA ( string s ) { /* second constructeur */ attrStrA = s +"...classeA1..." ; } } Ci-dessous la ClasseB crite de deux faons quivalentes : avec initialiseurs implicites-explicites
class ClasseB : ClasseA { /* premier constructeur */ public ClasseB ( ) { attrA = 100+attrA ; } /* second constructeur */ public ClasseB ( string s ) { attrStrA = attrStrA +s+"...classeB2..." ; } /* troisime constructeur */ public ClasseB ( int x , string ch ) : this( ch ) { attrStrA = attrStrA+"...classeB3..." ; } /* quatrime constructeur */ public ClasseB ( char x , string ch ) : base( ch ) { attrStrA = attrStrA+"...classeB4..." ; } }
avec initialiseurs explicites quivalents

class ClasseB : ClasseA { /* premier constructeur */ public ClasseB ( ) : base( ) { attrA = 100+attrA ; } /* second constructeur */ public ClasseB ( string s ): base( ) { attrStrA = attrStrA +s+"...classeB2..." ; } /* troisime constructeur */ public ClasseB ( int x , string ch ) : this( ch ) { attrStrA = attrStrA+"...classeB3..." ; } /* quatrime constructeur */ public ClasseB ( char x , string ch ) : base( ch ) { attrStrA = attrStrA+"...classeB4..." ; } }
Crons quatre objets de ClasseB, chacun avec l'un des 4 constructeurs de la ClasseB : class MaClass { static void Main(string[] args) { int x=68; ClasseB ObjetB= new ClasseB( ); System.Console.WriteLine(ObjetB.attrA); ObjetB= new ClasseB(x,"aaa"); System.Console.WriteLine(ObjetB.attrStrA); ObjetB= new ClasseB((char)x,"bbb"); System.Console.WriteLine(ObjetB.attrStrA); ObjetB= new ClasseB("ccc"); System.Console.WriteLine(ObjetB.attrStrA); System.Console.ReadLine(); } } Voici le rsultat console de l'excution de ce programme :
- Rm di Scala
page
189
Explications du code des classes prcdentes :

C# slectionne la signature du premier constructeur de la ClasseB (le constructeur sans paramtres). ClasseB ObjetB= new ClasseB( ); System.Console.WriteLine(ObjetB.attrA); constructeur mis en uvre : public ClasseB ( ) { attrA = 100+attrA ; } C# appelle d'abord implicitement le constructeur sans paramtre de la classe mre ( : base( ) ) public ClasseA ( ) { attrA = 57 ; } Le champ attrA vaut 57, puis C# excute le corps du constructeur : attrA = 100+attrA ; attrA vaut 100+57 = 157 C# slectionne la signature du troisime constructeur de la ClasseB (le constructeur avec paramtres : int x , string ch). ObjetB= new ClasseB(x,"aaa"); System.Console.WriteLine(ObjetB.attrStrA); C# appelle d'abord explicitement le constructeur local de la classeB avec un paramtre de type string ( le second constructeur de la ClasseB ) s = "aaa" ; public ClasseB ( string s ) { attrStrA = attrStrA +s+"...classeB2..." ; } Le champ attrStrA vaut "aaa...classeB2...", puis C# excute le corps du constructeur : attrStrA = attrStrA+"...classeB3..." ; attrStrA vaut "aaa...classeB2......classeB3..."
constructeurs mis en uvre : public ClasseB ( string s ) { attrStrA = attrStrA +s+"...classeB2..." ; } public ClasseB ( int x , string ch ) : this( ch ) { attrStrA = attrStrA+"...classeB3..." ; }
- Rm di Scala
page
190
ObjetB= new ClasseB((char)x,"bbb"); System.Console.WriteLine(ObjetB.attrStrA);
C# slectionne la signature du quatrime constructeur de la ClasseB (le constructeur avec paramtres : char x , string ch). C# appelle d'abord explicitement le constructeur de la classe mre (de base) classeA avec un paramtre de type string ( ici le second constructeur de la ClasseA )
constructeur mis en uvre : public ClasseB ( char x , string ch ) : base( ch ) { attrStrA = attrStrA+"...classeB4..." ; }
s = "bbb" ; public ClasseA ( string s ) { attrStrA = s +"...classeA1..." ; } Le champ attrStrA vaut "bbb...classeA1..." puis C# excute le corps du constructeur : attrStrA = attrStrA+"...classeB4..." ; attrStrA vaut "bbb...classeA1......classeB4..."
La dernire instanciation : ObjetB= new ClasseB("ccc"); est strictement identique la premire mais avec appel au second constructeur.
2.3 Comparaison de construction C#, Delphi et Java Exemple classe mre : C#

class ClasseA { public int attrA ; public string attrStrA ; public ClasseA ( ) { attrA = 57 ; } public ClasseA ( string s ) { attrStrA = s +"...classeA1..." ; } } }
Java
class ClasseA { public int attrA ; public String attrStrA = "" ; public ClasseA ( ) { attrA = 57 ; } public ClasseA ( String s ) { attrStrA = s +"...classeA1..." ; }
C#
Delphi
- Rm di Scala
page
191
class ClasseA { public int attrA ; public string attrStrA ; public ClasseA ( ) { attrA = 57 ; } public ClasseA ( string s ) { attrStrA = s +"...classeA1..." ; } }
ClasseA = class public attrA : integer ; attrStrA: string ; constructor Creer;overload; constructor Creer(s:string); overload; end; constructor ClasseA.Creer begin attrA := 57 ; end; constructor ClasseA.Creer(s:string); begin attrStrA := s +'...classeA1...' ; end;
Exemple classe fille : C# class ClasseB : ClasseA { /* premier constructeur */ public ClasseB ( ) { attrA = 100+attrA ; } /* second constructeur */ public ClasseB ( string s ) { attrStrA = attrStrA +s+"...classeB2..." ; } Java class ClasseB extends ClasseA { /* premier constructeur */ public ClasseB ( ) { super( ) ; attrA = 100+attrA ; } /* second constructeur */ public ClasseB ( String s ) { super( ) ; attrStrA = attrStrA +s+"...classeB2..." ; } /* troisime constructeur */ public ClasseB ( int x , String ch ) { this( ch ) ; attrStrA = attrStrA+"...classeB3..." ; } /* quatrime constructeur */ public ClasseB ( char x , String ch ) { super( ch ) ; attrStrA = attrStrA+"...classeB4..." ; } }
/* troisime constructeur */ public ClasseB ( int x , string ch ) : this( ch ) { attrStrA = attrStrA+"...classeB3..." ; }
/* quatrime constructeur */ public ClasseB ( char x , string ch ) : base( ch ) { attrStrA = attrStrA+"...classeB4..." ; } }
C#
Delphi
page
- Rm di Scala
192
class ClasseB : ClasseA {
/* premier constructeur */ public ClasseB ( ) { attrA = 100+attrA ; }
ClasseB = class( ClasseA ) public constructor Creer;overload; constructor Creer(s:string); overload; constructor Creer(x:integer;ch:string); overload; constructor Creer(x:char;ch:string); overload; end; /* premier constructeur */ constructor ClasseB.Creer; begin inherited ; attrA := 100+attrA ; end; /* second constructeur */ constructor ClasseB.Creer(s:string); begin inherited Creer ; attrStrA := attrStrA +s+'...classeB2...' ; end; /* troisime constructeur */ constructor ClasseB.Creer(x:integer;ch:string); begin Creer( ch ) ; attrStrA := attrStrA+'...classeB3...' ; end; /* quatrime constructeur */ constructor ClasseB.Creer(x:integer;ch:string); begin inherited Creer( ch ) ; attrStrA := attrStrA+'...classeB4...' ; end;
/* second constructeur */ public ClasseB ( string s ) { attrStrA = attrStrA +s+"...classeB2..." ; }
/* troisime constructeur */ public ClasseB ( int x , string ch ) : this( ch ) { attrStrA = attrStrA+"...classeB3..." ; }
/* quatrime constructeur */ public ClasseB ( char x , string ch ) : base( ch ) { attrStrA = attrStrA+"...classeB4..." ; } }
2.4 Traitement d'un exercice complet soit une hirarchie de classe de vhicules :
Syntaxe de base :
- Rm di Scala
page
193
class Vehicule { } class Terrestre :Vehicule { } class Marin :Vehicule { }
class Voiture : Terrestre { } class Voilier : Marin { } class Croiseur : Marin { }
Supposons que la classe Vhicule contienne 3 mthodes, qu'elle n'implmente pas la mthode Demarrer qui est alors abstraite, qu'elle fournit et implante vide la mthode "RpartirPassagers" de rpartition des passagers bord du vhicule, qu'elle fournit aussi et implante vide une mthode "PriodicitMaintenance" renvoyant la priodicit de la maintenance obligatoire du vhicule.
La classe Vhicule est abstraite : car la mthode Demarrer est abstraite et sert de "modle" aux futures classes drivant de Vhicule. Supposons que l'on implmente le comportement prcis du genre de dmarrage dans les classes Voiture, Voilier et Croiseur.
Dans cette hirarchie, les classes Terrestre et Marin hritent de la classe Vehicule, mais n'implmentent pas la mthode abstraite Dmarrer, ce sont donc par construction des classes abstraites elles aussi. Elles implantent chacune la mthode "RpartirPassagers" (fonction de la forme, du nombre de places, du personnel charg de s'occuper de faire fonctionner le vhicule...) et la mthode "PriodicitMaintenance" (fonction du nombre de km ou miles parcourus, du nombre d'heures d'activits,...) Les classes Voiture, Voilier et Croiseur savent par hritage direct comment rpartir leurs ventuels passagers et quand effectuer une maintenance, chacune d'elle implmente son propre comportement de dmarrage.
- Rm di Scala
page
194
Quelques implantations en C#
Une implmentation de la classe Voiture avec des mthodes non virtuelles (Version-1) :
abstract class Vehicule { public abstract void Demarrer( ); public void RpartirPassagers( ){} public void PriodicitMaintenance( ){} } La mthode Demarrer de la classe Vehicule est abstraite et donc automatiquement virtuelle ( liaison dynamique). Les mthodes RpartirPassagers et PriodicitMaintenance sont concrtes mais avec un corps vide. Ces deux mthodes sont non virtuelles ( liaison statique) abstract class Terrestre : Vehicule { public new void RpartirPassagers( ){ //...} public new void PriodicitMaintenance( ){ //...} } La classe Terrestre est abstraite car elle n'implmente pas la mthode abstraite Demarrer. Les deux mthodes dclares dans la classe Terrestre masquent chacune la mthode du mme nom de la classe Vehicule (d'o l'utilisation du mot clef new)
class Voiture : Terrestre { public override void Demarrer( ){ //...} }
La classe Voiture est la seule tre instanciable car toutes ses mthodes sont concrtes : Elle hrite des 2 mthodes implmentes de la classe Terrestre et elle implante (redfinition avec override) la mthode abstraite de l'anctre.
La mme implmentation de la classe Voiture avec des mthodes virtuelles (Version-2):

abstract class Vehicule { public abstract void Demarrer( ); public virtual void RpartirPassagers( ){} public virtual void PriodicitMaintenance( ){} } La mthode Demarrer de la classe Vehicule est abstraite et donc automatiquement virtuelle ( liaison dynamique). Les mthodesRpartirPassagers et PriodicitMaintenance sont concrtes mais avec un corps vide. Ces deux mthodes sont maintenant virtuelles ( liaison dynamique) abstract class Terrestre : Vehicule { public override void RpartirPassagers( ){ //...} public override void PriodicitMaintenance( ){ //...} } La classe Terrestre est abstraite car elle n'implmente pas la mthode abstraite Demarrer. Les deux mthodes dclares dans la classe Terrestre redfinissent chacune la mthode du mme nom de la classe Vehicule (d'o l'utilisation du mot clef override)
class Voiture : Terrestre { public override void Demarrer( ){ //...} }
La classe Voiture est la seule tre instanciable car toutes ses mthodes sont concrtes : Elle hrite des 2 mthodes implmentes de la classe Terrestre et elle implante (redfinition avec override) la mthode abstraite de l'anctre.
Supposons que les mthodes non virtuelles RpartirPassagers et PriodicitMaintenance sont implantes compltement dans la classe Vehicule, puis reprenons la classe Terrestre en masquant ces deux mthodes : abstract class Vehicule {
- Rm di Scala
page
195
public abstract void Demarrer( ); public void RpartirPassagers( ){ //....} public void PriodicitMaintenance( ){ //....} } abstract class Terrestre : Vehicule { public new void RpartirPassagers( ){ //...} public new void PriodicitMaintenance( ){ //...} } Question Nous voulons qu'un vhicule Terrestre rpartisse ses passagers ainsi : 1) d'abord comme tous les objets de classe Vehicule, 2) ensuite qu'il rajoute un comportement qui lui est propre Rponse La mthode RpartirPassagers est non virtuelle, elle masque la mthode mre du mme nom, si nous voulons accder au comportement de base d'un vhicule, il nous faut utiliser le mot clef base permettant d'accder aux membres de la classe mre : abstract class Terrestre : Vehicule { public new void RpartirPassagers( ){ base.RpartirPassagers( ); //... 1; comportement du parent //... 2 comportement propre } public new void PriodicitMaintenance( ){ //...} }
Il est conseill au lecteur de reprendre le mme schma et d'implanter l'identique les autres classes de la hirarchie pour la branche des vhicules Marin.
2.5 Destructeur Finaliseur Les classes de C# peuvent possder un finaliseur (syntaxe semblable au destructeur de C++) mais comme la gestion de la mmoire est automatiquement assure par le CLR, l'usage d'un finaliseur n'est pas le mme que celui qui en est fait avec Delphi ou C++ dans lesquels la rcupration de la mmoire est la charge du dveloppeur. Les structs ne peuvent pas possder de finaliseur (ou destructeur) Proprits et usage des finaliseurs avec C# : Une classe C# ne peut possder qu'un seul finaliseur. Un finaliseur ne peut pas tre redfini ni surcharg. Un finaliseur n'a pas de paramtre. Un destructeur est appel automatiquement par le CLR lors de la destruction effective de
- Rm di Scala
page
196
l'objet par le CLR, il ne peut pas tre appel directement.
De ces proprits il dcoule qu'un destructeur peut tre utilise par le dveloppeur pour librer certaines ressources non gres par le CLR (fermeture de fichier, fermeture de connexion,...) lorsque le programme ne les utilise plus.
Exemple : class classeB : classeA { // constructeur : public classeB( ) { .. } // destructeur : ~classeB( ) { Console.WriteLine("finalizeur de la classeB "); } } A chaque fois qu'un objet de classeA est dtruit par le CLR, le message "finalizeur de la classeB" apparatra sur la console. Il est entendu qu'il ne faut pas se servir de la programmation des destructeurs (finaliseurs) pour grer un programme d'une manire synchrone puisque le programme n'a aucun contrle sur la faon dont les objets sont librs par le CLR qui utilise son propre algorithme de garbage collection et de restitution de mmoire. Enfin, un destructeur appelle automatiquement le destructeur de la classe mre et ainsi de suite rcursivement jusqu' la classe object. Dans l'exemple prcdent, le destructeur de la classeB, aprs criture du message "finalizeur de la classeB" , appelle le destructeur de la classeA.
- Rm di Scala
page
197
Polymorphisme et interfaces en
Plan gnral:
Rappels sur la notion d'interface 1.Concepts et vocabulaire d'interface en C# les interfaces peuvent constituer des hirarchies et hriter entre elles la construction d'un objet necessite une classe implmentant l'interface les implmentations d'un membre d'interface sont en gnral public les implmentations explicites d'un membre d'interface sont spciales 1.1 Spcification d'un exemple complet 1.1.A Une classe abstraite 1.1.B Une interface 1.1.C Une simulation d'hritage multiple 1.1.D Encore une classe abstraite, mais plus concrte 1.1.E Une classe concrte 1.2 Implantation en C# de l'exemple 1.2.A La classe abstraite 1.2.B L'interface 1.2.C La simulation d'hritage multiple 1.2.D La nouvelle classe abstraite 1.2.E La classe concrte 2. Analyse du code de liaison de la solution prcdente 2.1 Le code de la classe Vehicule 2.2 Le code de l'interface IVehicule 2.3 Le code de la classe UnVehicule 2.4 Le code de la classe Terrestre 2.5 Le code de la classe Voiture 3. Cohrence de C# entre les notions de classe et d'interface une classe peut implmenter plusieures interfaces les interfaces et les classes respectent les mmes rgles de polymorphisme les conflits de noms dans les interfaces
- Rm di Scala
page
198
Rappels essentiels sur la notion d'interface

Les interfaces ressemblent aux classes abstraites : elles contiennent des membres spcifiant certains comportements sans les implmenter. Les classes abstraites et les interfaces se diffrencient principalement par le fait qu'une classe peut implmenter un nombre quelconque d'interfaces, alors qu'une classe abstraite ne peut hriter que d'une seule classe abstraite ou non. Une interface peut servir reprsenter des comportements d'hritage multiple.
Quelques conseils gnraux prodigus par des dveloppeurs professionnels (microsoft, Borland, Sun) :
Les interfaces bien conues sont plutt petites et indpendantes les unes des autres. Un trop grand nombre de fonctions rend l'interface peu maniable. Si une modification s'avre ncessaire, une nouvelle interface doit tre cre. Si la fonctionnalit que vous crez peut tre utile de nombreux objets diffrents, faites appel une interface. Si vous crez des fonctionnalits sous la forme de petits morceaux concis, faites appel aux interfaces. L'utilisation d'interfaces permet d'envisager une conception qui spare la manire d'utiliser une classe de la manire dont elle est implmente. Deux classes peuvent partager la mme interface sans descendre ncessairement de la mme classe de base.
1. Vocabulaire et concepts en C#
Une interface C# est un contrat, elle peut contenir des proprits, des mthodes , des vnements ou des indexeurs, mais ne doit contenir aucun champ ou attribut. Une interface ne peut pas contenir des mthodes dj implmentes. Une interface ne contient que des signatures (proprits, mthodes). Tous les membres d'une interface sont automatiquement public. Une interface est hritable. On peut construire une hirarchie d'interfaces. Pour pouvoir construire un objet partir d'une interface, il faut dfinir une classe non abstraite implmentant tous les membres de l'interface.
Les interfaces peuvent constituer des hirarchies et hriter entre elles soient l'interface IinterfA et l'interface IinterfB hritant de IinterfA. On pourra employer aussi le vocable d'tendre au sens o l'interface drive IinterfB "tend" le contrat (augmente le nombre de membres contractuels) de l'interface IinterfA.
Syntaxe de dclaration d'une interface

interface < nom de l'interface > {
< corps des dclarations : mthodes, >
}
- Rm di Scala
page
199
Dans tous les cas il faut une classe pour implmenter ces contrats : code C# :
interface IinterfA { event TypEvent1 OnTruc ; // vnement char Prop1 // proprit { get ; set ; } void meth1 ( ); // mthode int meth2 ( ); // mthode char meth3 ( int x ); // mthode } interface IinterfB : IinterfA //hritage { event TypEvent2 OnChose ; // vnement string Prop2 // proprit { get ; } void meth4 ( ); // mthode }
La construction d'un objet ncessite une classe implmentant l'interface La classe ClasseY doit implmenter tous les 8 membres provenant de l'hritage des interfaces : les 2 vnements OnTruc et Onchose, les 2 proprits Prop1 et Prop2, et enfin les 4 mthodes meth1, ... , meth4 . La classe ClasseY est une classe concrte (instanciable), un objet de cette classe possde en particulier tous les membres de l'interface IinterfB (et donc IinterfA car IinterfB hrite de IinterfA)
class ClasseY : ClasseX , IinterfB { // ... implmente tous les membres de InterfB } // construction et utilisation d'un objet : ClasseY Obj = new ClasseY( ) ; Obj.Prop1 = 'a' ; // proprit hrite de InterfA string s = Obj.Prop2 ; // proprit hrite de InterfB Obj.meth1( ) ; // mthode hrite de InterfA etc ...
Tous les membres doivent tre implments

Si ClasseY n'implmente par exemple que 7 membres sur les 8 alors C# considre que c'est une erreur et le compilateur le signale, tous les membres d'une interface doivent tre implments dans une classe qui en hrite (contrairement java qui accepte cette implmentation partielle en clase abstraite).
- Rm di Scala
page
200
Les implmentations des membres d'une interface sont en gnral public Par dfaut sans dclaration explicite, les membres (indexeurs, proprits, vnements, mthodes) d'une interface ne ncessitent pas de qualificateurs de visibilit car ils sont automatiquement dclars par C# comme tant de visibilit public, contrairement une classe ou par dfaut les membres sont du niveau assembly. Ce qui signifie que toute classe qui implmente un membre de l'interface doit obligatoirement le qualifier de public sous peine d'avoir un message d'erreur du compilateur, dans cette ventualit le membre devient un membre d'instance. Comme la signature de la mthode n'est qu'un contrat, le mode de liaison du membre n'est pas fix; la classe qui implmente le membre peut alors choisir de l'implmenter soit en liaison statique, soit en liaison dynamique. Soient une interface IinterfA et une classe ClasseX hritant directement de la classe Object et implmentant cette interface, ci-dessous les deux seules implmentations possibles d'une mthode avec un rappel sur les redfinitions possibles dans des classes descendantes :
interface IinterfA { void meth1 ( ); // mthode de l'interface }
Implmentation en liaison prcoce

class ClasseX : IinterfA { public void meth1 ( ){ ... } }
Implmentation en liaison tardive

class ClasseX : IinterfA { public virtual void meth1 ( ){ ... } }
meth1 devient une mthode d'instance
Redfinitions possibles
class ClasseY : ClasseX { public new void meth1 ( ){ ... } masque statiquement celle de ClasseX } class ClasseZ : ClasseX { public new virtual void meth1 ( ){ ... } masque dynamiquement celle de ClasseX }
Redfinitions possibles
class ClasseY : ClasseX { public new void meth1 ( ){ ... } masque statiquement celle de ClasseX } class ClasseZ : ClasseX { public new virtual void meth1 ( ){ ... } masque dynamiquement celle de ClasseX } class ClasseT : ClasseX { public override void meth1 ( ){ ... } redfinit dynamiquement celle de ClasseX }
Les implmentations explicites des membres d'une interface sont spciales Une classe qui implmente une interface peut aussi implmenter de faon explicite un membre de cette interface. Lorsqu'un membre est implment de faon explicite (le nom du membre est prfix par le nom de l'interface : InterfaceXxx.NomDuMembre ), il n'est pas accessible via une rfrence de classe, il est alors invisible tout objet instanci partir de la classe o il est dfini. Un membre implment de faon explicite n'est donc pas un membre d'instance.
- Rm di Scala
page
201
Pour utiliser un membre d'interface implment de manire explicite, il faut utiliser une rfrence sur cette interface et non une rfrence de classe; il devient visible uniquement travers une rfrence sur l'interface. Nous reprenons le mme tableau de diffrentes implmentations de la mthode void meth1 ( ) en ajoutant une nouvelle mthode void meth2 ( int x ) que nous implmentons explicitement dans les classes drives : interface IinterfA { void meth2 ( int x ); // mthode de l'interface void meth1 ( ); // mthode de l'interface } Nous implmentons l'interface IinterfA dans la classe ClasseX : 1) nous implmentons explicitement void meth2 ( int x ), 2) nous implmentons void meth1 ( ) en mthode virtuelle.
interface IinterfA { void meth2 ( int x ); // mthode de l'interface void meth1 ( ); // mthode de l'interface } class ClasseX : IinterfA { void IinterfA.meth2 ( int x ){ ... } public virtual void meth1 ( ){ ... } } Comprenons bien que la classe ClasseX ne possde pas cet instant une mthode d'instance qui se nommerait meth2, par exemple si dans la mthode virtuelle meth1 nous utilisons le paramtre implicite this qui est une rfrence la future instance, l'audit de code de C#Builder nous renvoie 7 mthodes comme visibles (6 provenant de la classe mre Object et une seule provenant de ClasseX), la mthode IinterfA.meth2 n'est pas visible :
Lorsque l'on instancie effectivement un objet de classe ClasseX, cet objet ne voit comme mthode provenant de ClasseX que la mthode meth1 :
- Rm di Scala
page
202
La mthode meth2 implmente explicitement en IinterfA.meth2 devient visible uniquement si l'on utilise une rfrence sur l'interface IinterfA, l'exemple ci-dessous montre qu'alors les deux mthodes meth1 et meth2 sont visibles :
L'audit de code de Visual C# fournit plus de prcision directement :
- Rm di Scala
page
203
Nous voyons bien que la mthode est qualifie avec sa signature dans IinterfA, voyons dans l'exemple ci-dessous que nous pouvons dclarer une mthode d'instance ayant la mme signature que la mthode explicite, voir mme de surcharger cette mthode d'instance sans que le compilateur C# n'y voit de conflit car la mthode explicite n'est pas rang dans la table des mthodes d'instances de la classe : class ClasseX : IinterfA { void IinterfA.meth2 ( int x ){ ... } //mthode de IinterfA implmente explicitement public virtual void meth2 ( int x ){ ... } //mthode de la ClasseX surcharge public virtual void meth2 ( char c ){ ... } //mthode de la ClasseX surcharge public virtual void meth1 ( ){ ... } //mthode de IinterfA implmente virtuellement }
La rfrence Obj1 peut appeller les deux surcharges de la mthode d'instance meth2 de la classe ClasseX :
- Rm di Scala
page
204
La rfrence Obj2 sur IinterfA fonctionne comme nous l'avons montr plus haut, elle ne peut voir de la mthode meth2 que son implmentation explicite :
Cette fonctionnalit d'implmentation explicite spcifique C# peut tre utilise dans au moins deux cas utiles au dveloppeur : Lorsque vous voulez qu'un membre (une mthode par exemple) implment d'une interface soit priv dans une classe pour toutes les instances de classes qui en driveront, l'implmentation explicite vous permet de rendre ce membre (cette mthode) inaccessible tout objet. Lors d'un conflit de noms si deux interfaces possdent un membre ayant la mme signature et que votre classe implmente les deux interfaces.
1.1 Spcification d'un exemple complet Utilisons la notion d'interface pour fournir un polymorphisme une hirarchie de classe de vhicules fonde sur une interface. : Soit au dpart une classe abstraite Vehicule et une interface IVehicule.
1.1.A) Une classe abstraite La classe abstraite Vehicule contient trois mthodes :
- Rm di Scala
page
205
La mthode Dmarrer qui est abstraite. La mthode RpartirPassagers de rpartition des passagers bord du vhicule, implante avec un corps vide. La mthode PriodicitMaintenance renvoyant la priodicit de la maintenance obligatoire du vhicule, implante avec un corps vide.
1.1.B) Une interface Afin d'utiliser les possibilits de C#, l'interface IVehicule propose un contrat d'implmentation pour un vnement, un indexeur, une proprit et une mthode :
L'vnement OnStart est de type dlgu (on construit un type dlgu Starting( ) spcifique pour lui) et se dclenchera au dmarrage du futur vhicule, L'indexeur this [int ] est de type string et permettra d'accder une liste indice d'informations sur le futur vhicule, La proprit TypeEngin est en lecture et criture et concerne le type du futur vhicule dans la marque, La mthode Stopper( ) indique comment le futur vhicule s'immobilisera.
1.1.C) Une simulation d'hritage multiple Nous souhaitons construire une classe abstraite UnVehicule qui "hrite" la fois des fonctionnalits de la classe Vehicule et de celles de l'interface IVehicule. Il nous suffit en C# de faire hriter la classe UnVehicule de la classe Vehicule, puis que la classe UnVehicule implmente les propositions de contrat de l'interface IVehicule :
- Rm di Scala
page
206
1.1.D) Encore une classe abstraite, mais plus "concrte" Nous voulons maintenant proposer une spcialisation du vhicule en crant une classe abstraite Terrestre, base des futurs vhicules terrestres. Cette classe implantera de faon explicite la mthode RpartirPassagers de rpartition des passagers et la mthode PriodicitMaintenance renvoyant la priodicit de la maintenance. Cette classe Terrestre reste abstraite car elle ne fournit pas l'implmentation de la mthode Demarrer :
1.1.E) Une classe concrte Nous finissons notre hirarchie par une classe Voiture qui descend de la classe Terrestre, qui implante la mthode Demarrer( ) et qui redfinie la mthode Stopper( ) :
- Rm di Scala
page
207
Ce qui nous donne le schma d'hritage total suivant :
1.2 Implantation en C# de l'exemple Nous proposons ci-dessous pour chaque classe ou interface une implmenation en C#. 1.2.A) La classe abstraite Vehicule
- Rm di Scala
page
208
abstract class Vehicule // classe abstraite mre { public abstract void Demarrer ( ); // mthode abstraite public void RpartirPassagers ( ) { } // implantation de mthode avec corps vide public void PriodicitMaintenance ( ) { } // implantation de mthode avec corps vide }
1.2.B) L'interface IVehicule
public delegate void Starting ( ); // declaration de type dlgu interface IVehicule { event Starting OnStart ; // dclaration d'vnement du type dlgu : Starting string this [ int index] // dclaration d'indexeur { get ; set ; } string TypeEngin // dclaration de proprit { get ; set ; } void Stopper ( ); // dclaration de mthode }
1.2.C) La classe UnVehicule Nous souhaitons dfinir une classe explique effectivement pour un vhicule comment fonctionne le dmarrage OnStart, comment on index les lments, comment on rcupre le type de l'engin, mais qui ne dise pas comment stopper le vhicule. Nous dfinissons alors une classe abstraite nomme UnVehicule qui hrite de la classe abstraite Vehicule qui implmente effectivement les 3 premiers membres de l'interface IVehicule (Event OnStart, Property Item, Property TypeEngin) et qui implmente fictivement la mthode " Sub Stopper( ) " (en laissant son corps vide sans aucune instruction). La classe UnVehicule reste abstraite car la mthode Demarrer( ) de la classe mre Vehicule n'est pas encore implmente.
- Rm di Scala
page
209
abstract class UnVehicule : Vehicule , IVehicule // hrite de la classe mre et implmente l'interface { private string nom = ""; private string [ ] ArrayInfos = new string [10] ; public event Starting OnStart ; protected void LancerEvent () { if( OnStart != null) OnStart (); } public string this [ int index] // implantation Indexeur { get { return ArrayInfos[index] ; } set { ArrayInfos[index] = value ; } } public string TypeEngin // implantation proprit { get { return nom ; } set { nom = value ; } } public virtual void Stopper ( ) { } // implantation de mthode avec corps vide }
1.2.D) La classe Terrestre
- Rm di Scala
page
210
abstract class Terrestre : UnVehicule { public new void RpartirPassagers ( ) { //...implantation de mthode masquant la mthode mre } public new void PriodicitMaintenance ( ) { //...implantation de mthode masquant la mthode mre } }
1.2.E) La classe Voiture
class Voiture : Terrestre { public override void Demarrer ( ) { LancerEvent ( ); } public override void Stopper ( ) { //... } }
- Rm di Scala
page
211
2. Analyse du code de liaison de la solution prcdente
Nous nous interessons au mode de liaison des membres du genre : mthodes, proprits, indexeurs et vnements. Rappelons au lecteur que la liaison statique indique que le compilateur lie le code lors de la compilation, alors que dans le cas d'une liaison dynamique le code n'est choisi et li que lors de l'excution. 2.1 Le code de la classe Vehicule
abstract class Vehicule { public abstract void Demarrer ( ); // mthode abstraite public void RpartirPassagers ( ) { } // implantation de mthode avec corps vide public void PriodicitMaintenance ( ) { } // implantation de mthode avec corps vide }
Analyse : Sans qualification particulire une mthode est liaison statique : La mthode public void RpartirPassagers ( ) est donc laison statique. La mthode public void PriodicitMaintenance ( ) est donc laison statique. Une mthode qualifie abstract est implicitement virtuelle : La mthode public abstract void Demarrer ( ) est donc laison dynamique.
2.2 Le code de l'interface IVehicule
interface IVehicule { event Starting OnStart ; // dclaration d'vnement du type dlgu : Starting string this [ int index] // dclaration d'indexeur { get ; set ; } string TypeEngin // dclaration de proprit { get ; set ; } void Stopper ( ); // dclaration de mthode }
- Rm di Scala
page
212
Analyse : Une interface n'est qu'un contrat, les membres dclars comme signatures dans l'interface n'tant pas implmentes, la question de leur liaison ne se pose pas au niveau de l'interface, mais lors de l'implmentation dans une classe ultrieure : La mthode void Stopper ( ); pourra donc tre plus tard soit statique, soit dynamique. L'vnement event Starting OnStart ; pourra donc tre plus tard soit statique, soit dynamique. La proprit string TypeEngin , pourra donc tre plus tard soit statique, soit dynamique. L'indexeur string this [ int index] , pourra donc tre plus tard soit statique, soit dynamique.
2.3 Le code de la classe UnVehicule
abstract class UnVehicule : Vehicule , IVehicule { private string nom = ""; private string [ ] ArrayInfos = new string [10] ; public event Starting OnStart ; protected void LancerEvent ( ) { if( OnStart != null) OnStart (); } public string this [ int index] // implantation Indexeur { get { return ArrayInfos[index] ; } set { ArrayInfos[index] = value ; } } public string TypeEngin // implantation proprit { get { return nom ; } set { nom = value ; } } public virtual void Stopper ( ) { } // implantation de mthode avec corps vide }
Analyse : Le qualificateur virtual indique que l'lment qualifi est virtuel, donc liaison dynamique; sans autre qualification un lment est par dfaut liaison statique : La mthode public virtual void Stopper ( ) est liaison dynamique. L'vnement public event Starting OnStart est liaison statique. La proprit public string TypeEngin est liaison statique.
- Rm di Scala
page
213
L'indexeur public string this [ int index] est liaison statique. La mthode protected void LancerEvent ( ) est liaison statique.
2.4 Le code de la classe Terrestre
abstract class Terrestre : UnVehicule { public new void RpartirPassagers ( ) { //...implantation de mthode } public new void PriodicitMaintenance ( ) { //...implantation de mthode } }
Analyse : Dans la classe mre Vehicule les deux mthodes RpartirPassagers et PriodicitMaintenance sont liaison statique, dans la classe Terrestre : La mthode public new void RpartirPassagers ( ) est laison statique et masque la mthode mre. La mthode public new void PriodicitMaintenance ( ) est laison statique et masque la mthode mre.
2.5 Le code de la classe Voiture
class Voiture : Terrestre { public override void Demarrer ( ) { LancerEvent ( ); } public override void Stopper ( ) { //... } }
- Rm di Scala
page
214
Analyse :
La mthode Demarrer( ) est hrite de la classe mre Vehicule, la mthode Stopper( ) est hrite de la classe UnVehicule : La mthode public override void Demarrer ( ) est laison dynamique et redfinit la mthode abstraite mre. La mthode public override void Stopper ( ) est laison dynamique et redfinit la mthode virtuelle corps vide de la classe UnVehicule.
3. Cohrence entre les notions de classe et d'interface dans C#
Une classe peut implmenter plusieurs interfaces. Dans ce cas nous avons une excellente alternative l'hritage multiple. Lorsque l'on cre une interface, on fournit un ensemble de dfinitions et de comportements qui ne devraient plus tre modifis. Cette attitude de constance dans les dfinitions, protge les applications crites pour utiliser cette interface. Les variables de types interface respectent les mmes rgles de transtypage que les variables de types classe. Les objets de type classe clA peuvent tre transtyps et refrencs par des variables d'interface IntfA dans la mesure o la classe clA implmente linterface IntfA. (cf. polymorphisme d'objet)
Une classe peut implmenter plusieures interfaces Soit la dfinition suivante o la classe UnVehiculeMoteur hrite de la classe abstraite Vehicule et implmente l'interface IVehicule de l'exemple prcdent, et supposons qu'en plus cette classe implmente l'interface IMoteur. L'interface IMoteur explique que lorsqu'un vhicule est moteur, il faut se proccuper de son type de carburant et de sa consommation :
- Rm di Scala
page
215
Ci-dessous le code C# correspondant cette dfinition, plus une classe concrte Voiture instanciable drivant de la classe abstraite UnVehiculeMoteur :
abstract class Vehicule { public abstract void Demarrer ( ); // mthode abstraite public void RpartirPassagers ( ) { } // implantation de mthode avec corps vide public void PriodicitMaintenance ( ) { } // implantation de mthode avec corps vide } interface IVehicule { event Starting OnStart ; // dclaration d'vnement du type dlgu : Starting string this [ int index] // dclaration d'indexeur { get ; set ; } string TypeEngin // dclaration de proprit { get ; set ; } void Stopper ( ); // dclaration de mthode } enum Energie { gaz , fuel , ess } // type numr pour le carburant interface IMoteur { Energie carburant // dclaration de proprit { get ; } int consommation ( ); // dclaration de mthode } abstract class UnVehiculeMoteur : Vehicule , IVehicule , IMoteur { private string nom = ""; private Energie typeEnerg = Energie.fuel ; private string [ ] ArrayInfos = new string [10] ; public event Starting OnStart ; Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
216
protected void LancerEvent ( ) { if( OnStart != null) OnStart ( ); } public string this [ int index] // implantation Indexeur de IVehicule { get { return ArrayInfos[index] ; } set { ArrayInfos[index] = value ; } } public string TypeEngin // implantation proprit de IVehicule { get { return nom ; } set { nom = value ; } } public Energie carburant // implantation proprit de IMoteur { get { return typeEnerg ; } } public virtual void Stopper ( ) { } // implantation vide de mthode de IVehicule public virtual int consommation ( ) { return .... } // implantation de mthode de IMoteur } class Voiture : UnVehiculeMoteur { public override void Demarrer ( ) { LancerEvent ( ); } public override void Stopper ( ) { //...implantation de mthode } public new void RpartirPassagers ( ) { //...implantation de mthode } public new void PriodicitMaintenance ( ) { //...implantation de mthode } }
Les interfaces et les classes respectent les mmes rgles de polymorphisme Il est tout fait possible d'utiliser des variables de rfrence sur des interfaces et de les transtyper d'une manire identique des variables de rfrence de classe. En particulier le polymorphisme de rfrence s'applique aux rfrences d'interfaces.
Le polymorphisme de rfrence sur les classes de l'exemple prcdent
- Rm di Scala
page
217
abstract class Vehicule { ... } interface IVehicule { ... } enum Energie { gaz , fuel , ess } interface IMoteur { ... } abstract class UnVehiculeMoteur : Vehicule , IVehicule , IMoteur { ... } class Voiture : UnVehiculeMoteur { ... } class UseVoiture1 { public string use ( IVehicule x ){ return x.TypeEngin ; } } class UseVoiture2 { public string use ( UnVehiculeMoteur x ){ return x.TypeEngin ; } } class UseVoiture3 { public string use ( Voiture x ){ return x.TypeEngin ; } }
class MaClass { static void Main(string [ ] args) { string s = "le client utilise une "; string ch ; IVehicule a1; UnVehiculeMoteur b1; Voiture c1; a1 = new Voiture( ); a1.TypeEngin = "Renault"; b1= new Voiture( ); b1.TypeEngin = "Citron"; c1 = new Voiture( ); c1.TypeEngin = "Peugeot"; UseVoiture1 client = new UseVoiture1( ); ch = s+client.use(a1); System.Console.WriteLine(ch); ch = s+client.use(b1); System.Console.WriteLine(ch); ch = s+client.use(c1); System.Console.WriteLine(ch); } }
code d'excution avec 3 objets diffrents static void Main(string [ ] args) { .... idem UseVoiture1 client = new UseVoiture1( ); ch = s+client.use(a1); System.Console.WriteLine(ch); ch = s+client.use(b1); System.Console.WriteLine(ch); ch = s+client.use(c1); System.Console.WriteLine(ch); } IVehicule |__UnVehiculeMoteur |__Voiture Aprs excution :
a1 est une rfrence sur IVehicule, b1 est une rfrence sur une interface fille de IVehicule, c1 est de classe Voiture implmentant IVehicule. Donc chacun de ces trois genres de paramtre peut tre pass par polymorphisme de rfrence d'objet la mthode public string use ( IVehicule x )
static void Main(string [ ] args) { .... idem UseVoiture2 client = new UseVoiture2( ); ch = s+client.use((UnVehiculeMoteur)a1); System.Console.WriteLine(ch); ch = s+client.use(b1); System.Console.WriteLine(ch); ch = s+client.use(c1); System.Console.WriteLine(ch); } IVehicule |__UnVehiculeMoteur |__Voiture
Aprs excution :
Le polymorphisme de rfrence d'objet appliqu la mthode public string use ( UnVehiculeMoteur x ) indique que les paramtres passs doivent tre de type UnVehiculeMoteur ou de type descendant. La variable a1 est une rfrence sur IVehicule qui ne descend pas de UnVehiculeMoteur, il faut donc transtyper la rfrence a1 soit : (UnVehiculeMoteur)a1.
- Rm di Scala
page
218
static void Main(string [ ] args) { .... idem UseVoiture3 client = new UseVoiture3( ); ch = s+client.use( (Voiture)a1 ); System.Console.WriteLine(ch); ch = s+client.use( (Voiture)b1 ); System.Console.WriteLine(ch); ch = s+client.use(c1); System.Console.WriteLine(ch); } IVehicule |__UnVehiculeMoteur |__Voiture
Aprs excution :
Le polymorphisme de rfrence d'objet appliqu la mthode public string use ( Voiture x ) indique que les paramtres pass doivent tre de type Voiture ou de type descendant. La variable a1 est une rfrence sur IVehicule qui ne descend pas de Voiture, il faut donc transtyper la rfrence a1 soit : (Voiture)a1 La variable b1 est une rfrence sur UnVehiculeMoteur qui ne descend pas de Voiture, il faut donc transtyper la rfrence b1 soit : (Voiture)b1
Les oprateurs is et as sont utilisables avec des rfrences d'interfaces en C#. Reprenons l'exemple prcdent :
abstract class Vehicule { ... } interface IVehicule { ... } enum Energie { gaz , fuel , ess } interface IMoteur { ... } abstract class UnVehiculeMoteur : Vehicule , IVehicule , IMoteur { ... } class Voiture : UnVehiculeMoteur { ... } class UseVoiture1 { public string use ( IVehicule x ){ if (x is UnVehiculeMoteur) { int consom = (x as UnVehiculeMoteur).consommation( ); return " consommation="+consom.ToString( ) ; } else return x.TypeEngin ; } }
Les conflits de noms dans les interfaces Il est possible que deux interfaces diffrentes possdent des membres ayant la mme signature. Une classe qui implmente ces deux interfaces se trouvera confronte un conflit de nom (ambigut). Le compilateur C# exige ds lors que l'ambigut soit leve avec le prfixage du nom du membre par celui de l'interface correspondante (implmentation explicite). L'exemple ci-dessous est figur avec deux interfaces IntA et IntB contenant chacune deux mthodes portant les mmes noms et plus particulirement la mthode meth1 possde la mme signature dans chaque interface. Soit ClasseUn une classe implmentant ces deux interfaces. Voici comment fait C# pour choisir les appels de mthodes implantes. Le code source de ClasseUn implmentant les deux interfaces IntA et IntB :
- Rm di Scala
page
219
interface IntA{ void meth1( int x ); void meth2( ); } interface IntB{ void meth1( int x ); void meth2( int y ); }
class ClasseUn : IntA , IntB { public virtual void meth1( int x ){ } void IntA.meth1( int x ){ } void IntB.meth1( int x ){ } public virtual void meth2( ){ } public void meth2( int y ){ } }
Schma expliquant ce que C# analyse dans le code source prcdent :
Lorsque l'on instancie effectivement 3 objets de classe ClasseUn prcdente, et que l'on dclare chaque objet avec un type de rfrence diffrent : classe ou interface, le schma cidessous indique quels sont les diffrents appels de mthodes corrects possibles :
- Rm di Scala
page
220
Il est aussi possible de transtyper une rfrence d'objet de classe ClasseUn en une rfrence d'interface dont elle hrite (les appels sont identiques ceux du schma prcdent) : class Tests { void methTest( ) { ClasseUn Obj1 = new ClasseUn( ); IntA Obj2 = ( IntA )Obj1; IntB Obj3 = ( IntB )Obj1; Obj1.meth2( ); Obj1.meth2(74); Obj2.meth2( ); Obj3.meth2(100); Obj1.meth1(50); Obj2.meth1(40); Obj3.meth1(40); } } Nous remarquons qu'aucun conflit et aucune ambigut de mthode ne sont possibles et que grce l'implmentation explicite, toutes les mthodes de mme nom sont accessibles. Enfin, nous avons prfr utiliser le transtypage dtaill dans : IntA Obj2 = ( IntA )Obj1 ; Obj2.meth1(40) ;
Plutt que l'criture quivalente : (( IntA )Obj1).meth1(40) ; //...appel de IntA.meth1(int x)

Programmer objet .Net avec C# - ( rv. 17.10..2007 ) page
- Rm di Scala
221
Car l'oubli du parenthsage externe dans l'instruction " (( IntA )Obj1).meth1(40) " peut provoquer des incomprhensions dans la mesure o aucune erreur n'est signal par le compilateur car ce n'est plus la mme mthode qui est appele. ( IntA )Obj1.meth1(40) ; //...appel de public virtual ClasseUn.meth1(int x)
- Rm di Scala
page
222
Classe de dlgation
Plan gnral:
Les classes de dlgations

1.1 Dfinition classe de dlgation - dlgu 1.2 Dlgu et mthodes de classe - dfinition 1.3 Dlgu et mthodes de classe - informations pendant l'excution 1.4 Dlgu et mthodes d'instance - dfinition 1.5 Plusieurs mthodes pour le mme dlgu 1.6 Excution des mthodes d'un dlgu multicast - Exemple de code
- Rm di Scala
page
223
Il existe en Delphi la notion de pointeur de mthode utilise pour implanter la notion de gestionnaire dvnements. C# a repris cette ide en l'encapsulant dans un concept objet plus abstrait : la notion de classes de dlgations. Dans la machine virtuelle CLR, la gestion des vnements est fonde sur les classes de dlgations, il est donc essentiel de comprendre le modle du dlgu pour comprendre le fonctionnement des vnements en C#.
1. Les classes de dlgations

Note de microsoft l'attention des dveloppeurs :
La classe Delegate est la classe de base pour les types dlgus. Toutefois, seuls le systme et les compilateurs peuvent driver de manire explicite de la classe Delegate ou MulticastDelegate. En outre, il n'est pas possible de driver un nouveau type d'un type dlgu. La classe Delegate n'est pas considre comme un type dlgu. Il s'agit d'une classe utilise pour driver des types dlgus.
1.1 Dfinition classe de dlgation - dlgu Le langage C# contient un mot cl delegate , permettant au compilateur de construire une classe drive de la classe MulticastDelegate drive elle-mme de la classe abstraite Delegate. Nous ne pouvons pas instancier une objet de classe Delegate, car le constructeur est spcifi protected et n'est donc pas accessible :
Les classes Delegate et MulticastDelegate sont des classes de base pour construire des dlgus, il n'est toutefois pas possible par programme de driver explicitement (hriter) une classe fille de ces classes, seuls le systme et les compilateurs le peuvent. On peut les considrer dans un programme comme des classes sealed. C'est en fait via le mot cl delegate que nous allons construire des classes qui ont pour nom : classes de dlgations. Ces classes sont des classes du genre rfrence, elles sont instanciables et un objet de classe dlgation est appel un dlgu. Les classes ainsi construites sont automatiquement sealed donc non hritables.
Un objet de classe dlgation permet de rfrencer (pointer vers) une ou plusieurs mthodes.
Il s'agit donc de l'extension de la notion de pointeur de mthode de Delphi. Selon les auteurs
- Rm di Scala
page
224
une classe de dlgation peut aussi tre nomme classe dlgue, type dlgu voir mme tout simplement dlgu. Il est essentiel dans le texte lu de bien distinguer la classe et l'objet instanci. Lorsque nous utiliserons le vocable classe dlgu ou type dlgu nous parlerons de la classe de dlgation dun objet dlgu.
Il est donc possible de crer un nouveau type de dlgu (une nouvelle classe) dans un programme, ceci d'une seule manire : en utilisant le qualificateur delegate. Ci-dessous nous dclarons un type dlgu (une nouvelle classe particulire) nomm NomTypeDelegue : delegate string NomTypeDelegue ( int parametre) ; Un objet dlgu peut donc tre instanc partir de cette "classe" comme n'importe quel autre objet : NomTypeDelegue Obj = new NomTypeDelegue ( <paramtre> ) Il ne doit y avoir qu'un seul paramtre <paramtre> et c'est obligatoirement un nom de mthode. Soit MethodeXYZ le nom de la mthode pass en paramtre, nous dirons alors que le dlgu (l'objet dlgu) rfrence la mthode MethodeXYZ .
Les mthodes rfrences par un dlgu peuvent tre : des mthodes de classe ( static ) ou des mthodes d'instance Toutes les mthodes rfrences par un mme dlgu ont la mme signature partielle : mme type de retour du rsultat, mme nombre de paramtres, mme ordre et type des paramtres, seul leur nom diffre.
- Rm di Scala
page
225
1.2 Dlgu et mthodes de classe - dfinition
Un type commenant par le mot clef delegate est une classe dlgation. ci-dessous la syntaxe de 2 exemples de dclaration de classe dlgation : delegate string Deleguer1( int x ) ; delegate void Deleguer2( string s ) ; Un objet instanci partir de la classe Deleguer1 est appel un dlgu de classe Deleguer1 : Deleguer1 FoncDeleg1 = new Deleguer1 ( Fonc1 ) ; o Fonc1 est une mthode : static string Fonc1 ( int x ) { ... } Un objet instanci partir de la classe Deleguer2 est appel un dlgu de classe Deleguer2 : Deleguer2 FoncDeleg2 = new Deleguer2 ( Fonc2 ) ; o Fonc2 est une autre mthode : static void Fonc2 ( string x ) { ... }
Nous avons cr deux types dlgations nomms Deleguer1 et Deleguer2 : Le type Deleguer1 permet de rfrencer des mthodes ayant un paramtre de type int et renvoyant un string. Le type Deleguer2 permet de rfrencer des mthodes ayant un paramtre de type string et ne renvoyant rien. Les mthodes de classe Fonc1 et Fonc11 rpondent la signature partielle du type Deleguer1 static string Fonc1 ( int x ) { ... } static string Fonc11 ( int x ) { ... } On peut crer un objet (un dlgu) qui va rfrencer l'une ou l'autre de ces deux fonctions : Deleguer1 FoncDeleg1 = new Deleguer1 ( Fonc1 ) ; ou bien Deleguer1 FoncDeleg1 = new Deleguer1 ( Fonc11 ) ; On peut maintenant appeler le dlgu FoncDeleg1 dans une instruction avec un paramtre d'entre de type int, selon que le dlgu rfrence Fonc1 ou bien Fonc11 c'est l'une ou l'autre des ces fonctions qui est en fait appele.
Source d'un exemple C# et excution :

delegate string Deleguer1 ( int x ); class ClasseA { static string Fonc1 ( int x ) { return ( x * 10 ) .ToString ( ); } static string Fonc11 ( int x ) { return ( x * 100 ) .ToString ( ); } static void Main ( string [] args ) { string s = Fonc1 ( 32 ); System .Console.WriteLine ("Fonc1(32) = " + s ); s = Fonc11 ( 32 ); // appel de fonction classique System .Console.WriteLine ("Fonc11(32) = " + s ); System .Console.WriteLine ("\nLe dlgu rfrence Fonc1 :"); Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
226
Deleguer1 FoncDeleg1 = new Deleguer1 ( Fonc1 ) ; s = FoncDeleg1 ( 32 ); // appel au dlgu qui appelle la fonction System .Console.WriteLine ("FoncDeleg1(32) = " + s ); System .Console.WriteLine ("\nLe dlgu rfrence maintenant Fonc11 :"); FoncDeleg1 = new Deleguer1 ( Fonc11 ) ; // on change d'objet rfrenc (de fonction) s = FoncDeleg1 ( 32 ); // appel au dlgu qui appelle la fonction System .Console.WriteLine ("FoncDeleg1(32) = " + s ); System .Console.ReadLine ( ); } }
Rsultats d'excution sur la console :
1.3 Dlgu et mthodes de classe - informations pendant l'excution Comme une rfrence de dlgu peut pointer (rfrencer) vers des mthodes de classes diffrentes au cours de l'excution, il est intressant d'obtenir des informations sur la mthode de classe actuellement rfrence par le dlgu. Nous donnons ci-dessous les deux proprits publiques qui sont utiles lors de cette recherche d'informations, elles proviennent de la classe mre Delegate non hritable par programme :
- Rm di Scala
page
227
La proprit Target sert plus particulirement lorsque le dlgu rfrence une mthode d'instance, la proprit Method est la seule utilisable lorsque la mthode rfrence par le dlgu est une mthode de classe (mthode marque static). Lorsque la mthode rfrence par le dlgu est une mthode de classe le champ Target a la valeur null. Ci-dessous nous avons extrait quelques informations concernant la proprit Method qui est elle-mme de classe MethodInfo :
Ces proprits sont des membres de la proprit Method qui est applicable uniquement lorsque le dlgu en cours rfrence une mthode de classe (qualifie static).
Nous illustrons dans la figure ci-aprs, dans le cas d'une mthode de classe, l'utilisation des proprits Name, DeclaringType et ReturnType membres de la proprit Method :
- Rm di Scala
page
228
Nous obtenons ainsi des informations sur le nom, le type du rsultat et la classe de la mthode static pointe par le dlgu.
Source complet excutable d'un exemple d'information sur la mthode de classe rfrence :
namespace PrDelegate { delegate string Deleguer1 ( int x ); class ClasseA { static string Fonc1 ( int x ) { return ( x * 10 ) .ToString ( ); } static void Main ( string [ ] args ) { System .Console.WriteLine ("\nLe dlgu rfrence Fonc1 :"); Deleguer1 FoncDeleg1 = new Deleguer1 ( Fonc1 ) ; System .Console.WriteLine ( "nom : "+FoncDeleg1.Method.Name ); System .Console.WriteLine ("classe : "+ FoncDeleg1.Method.DeclaringType.ToString( ) ); System .Console.WriteLine ( "retour : "+FoncDeleg1.Method.ReturnType.ToString( ) ); System .Console.ReadLine ( ); } } }
- Rm di Scala
page
229
1.4 Dlgu et mthodes d'instance - dfinition

Outre une mthode de classe, un dlgu peut pointer aussi vers une mthode d'instance(une mthode d'un objet). Le fonctionnement (dclaration, instanciation, utilisation) est identique celui du rfrencement d'une mthode de classe, avec syntaxiquement l'obligation, lors de l'instanciation du dlgu, d'indiquer le nom de l'objet ainsi que le nom de la mthode Obj.Methode (similitude avec le pointeur de mthode en Delphi). Ci-dessous la syntaxe d'un exemple de dclaration de classe dlgation pour une mthode d'instance, nous devons : 1) Dclarer une classe contenant une mthode public class clA { public int meth1(char x) { .... } } 2) Dclarer un type dlgation delegate int Deleguer( char x ) ; 3) Instancier un objet de la classe clA clA ObjA = new clA ( ) ; 4) Instancier partir de la classe Deleguer un dlgu Deleguer FoncDeleg = new Deleguer ( ObjA.meth1 ) ;
Nous illustrons dans la figure ci-aprs, dans le cas d'une mthode d'instance, l'utilisation de membres de la proprit Method et de la proprit Target :
- Rm di Scala
page
230
Source complet excutable d'un exemple d'information sur la mthode d'instance rfrence :
namespace PrDelegate { delegate int Deleguer ( char x ); class ClasseA { public int meth1 ( char x ) { return x ; } static void Main ( string [ ] args ) { ClasseA ObjX , ObjA = new ClasseA( ); System .Console.WriteLine ("Un dlgu rfrence ObjA.meth1 :"); Deleguer FoncDeleg = new Deleguer ( ObjA.meth1 ) ; ObjX = (ClasseA)FoncDeleg.Target; if (ObjX.Equals(ObjA)) System.Console.WriteLine ("Target rfrence bien ObjA"); else System.Console.WriteLine ("Target ne rfrence pas ObjA"); System.Console.WriteLine ( "\nnom : "+FoncDeleg.Method.Name ); System.Console.WriteLine ("classe : "+ FoncDeleg.Method.DeclaringType.ToString( ) ); System.Console.WriteLine ( "retour : "+FoncDeleg.Method.ReturnType.ToString( ) ); System.Console.ReadLine ( ); } } }

- Rm di Scala
page
231
Dans le programme prcdent, les lignes de code suivantes : ObjX = (ClasseA)FoncDeleg.Target ; if (ObjX.Equals(ObjA)) System.Console.WriteLine ("Target rfrence bien ObjA") ; else System.Console.WriteLine ("Target ne rfrence pas ObjA") ; servent faire "pointer" la rfrence ObjX vers l'objet vers lequel pointe FoncDeleg.Target. La rfrence de cet objet est transtype car ObjX est de type ClasseA, FoncDeleg.Target est de type Object et le compilateur n'accepterait pas l'affectation ObjX = FoncDeleg.Target. Le test if (ObjX.Equals(ObjA))... permet de nous assurer que les deux rfrences ObjX et ObjA pointent bien vers le mme objet.
1.5 Plusieurs mthodes pour le mme dlgu C# autorise le rfrencement de plusieurs mthodes par le mme dlgu, nous utiliserons le vocabulaire de dlgu multicast pour bien prciser qu'il rfrence plusieurs mthodes. Le dlgu multicast conserve les rfrencements dans une liste d'objet. Les mthodes ainsi rfrences peuvent chacune tre du genre mthode de classe ou mthode d'instance, elles doivent avoir la mme signature. Rappelons qu'un type dlgu multicast est une classe qui hrite intrinsquement de la classe MulticasteDelegate :
La documentation de .Net Framework indique que la classe MulticasteDelegate contient en particulier trois champs privs : Object _target ; Int32 _methodPtr ; MulticasteDelegate _prev ;
- Rm di Scala
page
232
Le champ _prev est utilis pour maintenir une liste de MulticasteDelegate Lorsque nous dclarons un programme comme celui-ci :
delegate int Deleguer ( char x ); class ClasseA { public int meth100 ( char x ) { System.Console.WriteLine ("Excution de meth100('"+x+"')"); return x+100 ; } static void Main ( string [ ] args ) { ClasseA ObjA = new ClasseA( ); Deleguer FoncDeleg = new Deleguer ( ObjA.meth100 ) ; } }
Lors de l'excution, nous avons vu qu'il y a cration d'un ObjA de ClasseA et cration d'un objet dlgu FoncDeleg, les proprits Method et Target sont automatiquement initialises par le compilateur :
En fait, ce sont les champs privs qui sont initialiss et les proprits Method et Target qui sont en lecture seulement, lisent les contenus respectifs de _methodPtr et de _target; le champ _prev est pour l'instant mis null , enfin la mthode meth100(...) est actuellement en tte de liste. Figure virtuelle de l'objet dlgu ce stade :
- Rm di Scala
page
233
Il est possible d'ajouter une nouvelle mthode meth101(...) au dlgu qui va la mettre en tte de liste la place de la mthode meth100(...) qui devient le deuxime lment de la liste. C# utilise l'oprateur d'addition pour implmenter l'ajout d'une nouvelle mthode au dlgu. Nous tendons le programme prcdent :
delegate int Deleguer ( char x ); class ClasseA { public int meth100 ( char x ) { System.Console.WriteLine ("Excution de meth100('"+x+"')"); return x+100 ; } public int meth101 ( char x ) { System.Console.WriteLine ("Excution de meth101('"+x+"')"); return x+101 ; } static void Main ( string [] args ) { ClasseA ObjA = new ClasseA( ); //-- meth100 est en tte de liste : Deleguer FoncDeleg = new Deleguer ( ObjA.meth100 ) ; // meth101 est ajoute en tte de liste devant meth100 : FoncDeleg = FoncDeleg + new Deleguer ( ObjA.meth101 ) ; } }
Figure virtuelle de l'objet dlgu cet autre stade :
- Rm di Scala
page
234
C# permet de consulter et d'utiliser si nous le souhaitons toutes les rfrencement de mthodes en nous renvoyant la liste dans un tableau de rfrence de type Delegate grce la mthode GetInvocationList. La ligne de code source ci-dessous retourne dans le tableau Liste, la liste d'appel dans l'ordre d'appel, du dlgu FoncDeleg : Delegate[ ] Liste = FoncDeleg.GetInvocationList( ) ;
1.6 Excution des mthodes d'un dlgu multicast - Exemple de code Lorsque l'on invoque le dlgu sur un paramtre effectif, C# appelle et excute squentiellement les mthodes contenues dans la liste jusqu' puisement. L'ordre d'appel est celui du stockage : la premire stocke est excute en premier, la suivante aprs, la dernire mthode ajoute est excute en dernier, s'il y a un rsultat de retour, c'est celui de la dernire mthode ajoute qui est renvoy , les autres rsultats de retour sont ignors. L'exemple ci-dessous reprend les notions que nous venons d'exposer. Source complet excutable d'un exemple de dlgu multicast :
namespace PrDelegate { delegate int Deleguer ( char x ); class ClasseA { public int champ; public int meth100 ( char x ) { System.Console.WriteLine ("Excution de meth100('"+x+"')"); return x+100 ; } public int meth101 ( char x ) { System.Console.WriteLine ("Excution de meth101('"+x+"')"); return x+101 ; } Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
235
public int meth102 ( char x ) { System.Console.WriteLine ("Excution de meth102('"+x+"')"); return x+102 ; } public static int meth103 ( char x ) { System.Console.WriteLine ("Excution de meth103('"+x+"')"); return x+103 ; } static void Main ( string [] args ) { System.Console.WriteLine ("Un dlgu rfrence ObjA.meth1 :" ) ; ClasseA ObjX , ObjA = new ClasseA( ); //-- instanciation du dlgu avec ajout de 4 mthodes : Deleguer FoncDeleg = new Deleguer ( ObjA.meth100 ) ; FoncDeleg += new Deleguer ( ObjA.meth101 ) ; FoncDeleg += new Deleguer ( ObjA.meth102 ) ; FoncDeleg += new Deleguer ( meth103 ) ; //--la mthode meth103 est en tte de liste : ObjX = (ClasseA)FoncDeleg.Target ; if (ObjX == null) System.Console.WriteLine ("Mthode static, Target = null") ; else if (ObjX.Equals(ObjA))System .Console.WriteLine ("Target rfrence bien ObjA") ; else System.Console.WriteLine ("Target ne rfrence pas ObjA") ; System.Console.WriteLine ( "\nnom : "+FoncDeleg.Method.Name ); System.Console.WriteLine ( "classe : "+FoncDeleg.Method.DeclaringType.ToString( ) ) ; System.Console.WriteLine ( "retour : "+FoncDeleg.Method.ReturnType.ToString( ) ); //--Appel du dlgu sur le paramtre effectif 'a' : ObjA.champ = FoncDeleg('a') ; //code ascii 'a' = 97 System.Console.WriteLine ( "\nvaleur du champ : "+ObjA.champ) ; System.Console.WriteLine ( "----------------------------------") ; //-- Parcours manuel de la liste des mthodes rfrences : Delegate[ ] Liste = FoncDeleg.GetInvocationList( ) ; foreach ( Delegate Elt in Liste ) { ObjX = (ClasseA)Elt.Target ; if (ObjX == null) System.Console.WriteLine ("Mthode static, Target = null") ; else if (ObjX.Equals(ObjA))System .Console.WriteLine ("Target rfrence bien ObjA") ; else System.Console.WriteLine ("Target ne rfrence pas ObjA") ; System.Console.WriteLine ( "\nnom : "+Elt.Method.Name ) ; System.Console.WriteLine ( "classe : "+Elt.Method.DeclaringType.ToString( ) ) ; System.Console.WriteLine ( "retour : "+Elt.Method.ReturnType.ToString( ) ) ; System.Console.WriteLine ( "----------------------------------") ; } System.Console.ReadLine ( ) ; } } }
- Rm di Scala
page
236
Nous voyons bien que le dlgu FoncDeleg contient la liste des rfrencements des mthodes meth100, meth101,meth102 et meth103 ordonn comme figur ci-dessous :
Remarquons que le premier objet de la liste est une rfrence sur une mthode de classe, la
- Rm di Scala
page
237
proprit Target renvoie la valeur null (le champ _target est null). La mthode de classe meth103 ajoute en dernier est bien en tte de liste :
L'invocation du dlgu lance l'excution squentielle des 4 mthodes :
et le retour du rsutat est celui de meth103('a') :
Le parcours manuel de la liste montre bien que ce sont des objets de type Delegate qui sont stocks et que l'on peut accder entre autre possibilits, leurs proprits :
- Rm di Scala
page
238
Les exceptions en
Plan gnral:
1. Les exceptions : syntaxe, rle, classes

1.1 Comment grer une exception dans un programme 1.2 Principe de fonctionnement de l'interception
2. Interception d'exceptions hirarchises

2.1 Interceptions de plusieurs exceptions 2.2 Ordre d'interception d'exceptions hirarchises
3. Redclenchement d'une exception mot-clef : throw

3.1 Dclenchement manuel d'une exception de classe dj existante 3.2 Dclenchement manuel d'une exception personnalise
4. Clause finally 5. Un exemple de traitement d'exceptions sur des fichiers 6. Une solution de lexemple prcdent en C#
- Rm di Scala
page
239
1. Les exceptions : syntaxe, rle, classes

Rappelons au lecteur que la scurit de fonctionnement d'une application peut tre rendue instable par toute une srie de facteurs : Des problmes lis au matriel : par exemple la perte subite d'une connexion un port, un disque dfectueux... Des actions imprvues de l'utilisateur, entranant par exemple une division par zro... Des dbordements de stockage dans les structures de donnes... Toutefois les faiblesses dans un logiciel pendant son excution, peuvent survenir : lors des entres-sorties, lors de calculs mathmatiques interdits (comme la division par zro), lors de fausses manoeuvres de la part de lutilisateur, ou encore lorsque la connexion un priphrique est inopinment interrompue, lors d'actions sur les donnes. Le logiciel doit donc se " dfendre " contre de tels incidents potentiels, nous nommerons cette dmarche la programmation dfensive ! Programmation dfensive La programmation dfensive est une attitude de pense consistant prvoir que le logiciel sera soumis des dfaillances dues certains paramtres externes ou internes et donc prvoir une rponse adapte chaque type de situation. En programmation dfensive il est possible de protger directement le code laide de la notion dexception. Lobjectif principal est damliorer la qualit de " robustesse " (dfinie par B.Meyer) dun logiciel. Lutilisation des exceptions avec leur mcanisme intgr, autorise la construction rapide et efficace de logiciels robustes. Rle dune exception Une exception est charge de signaler un comportement exceptionnel (mais prvu) dune partie spcifique dun logiciel. Dans les langages de programmation actuels, les exceptions font partie du langage lui-mme. Cest le cas de C# qui intgre les exceptions comme une classe particulire: la classe Exception. Cette classe contient un nombre important de classes drives. Comment agit une exception Ds quune erreur se produit comme un manque de mmoire, un calcul impossible, un fichier inexistant, un transtypage non valide,..., un objet de la classe adquate drive de la classe Exception est instanci. Nous dirons que le logiciel " dclenche une exception ".
1.1 Comment grer une exception dans un programme Programme sans gestion de l'exception Soit un programme C# contenant un incident d'excution (une division par zro dans l'instruction x = 1/0; ) dans la mthode meth() de la classe Action1, cette mthode est appele dans la classe UseAction1 travers un objet de classe Action1 :
- Rm di Scala
page
240
class Action1 { public void meth() { int x, y =0; Console.WriteLine(" ...Avant incident"); x = 1 / y; Console.WriteLine(" ...Aprs incident"); } } class Program { static void Main(string[] args) { Action1 Obj = new Action1( ); Console.WriteLine("Dbut du programme."); Obj.meth( ); Console.WriteLine("Fin du programme."); } }
Lors de l'excution, aprs avoir affich les chanes "Dbut du programme" et " ...Avant incident", le programme s'arrte et le CLR signale une erreur. Voici ci-dessous l'affichage obtenu dans Visual C# :
Sur la console l'affichage est le suivant :
Le programme s'est arrt cet endroit et ne peut plus pouruivre son excution. Que s'est-il pass ? La mthode Main : - a instanci un objet Obj de classe Action1, - a affich sur la console la phrase " Dbut du programme ", - a invoqu la mthode meth() de l'objet Obj, - a affich sur la console la phrase " ...Avant incident", - a excut l'instruction "x = 1/0;"
- Rm di Scala
page
241
Ds que l'instruction "x = 1/0;" a t excute celle-ci a provoqu un incident. En fait une exception de la classe DivideByZeroException a t "leve" (un objet de cette classe a t instanci) par le CLR, cette classe hrite de la classe ArithmeticException selon la hirarchie d'hritage suivante de .Net Framework : System.Object |__System.Exception |__System.SystemException |__System.ArithmeticException |__System.DivideByZeroException La classe mre de toutes les exceptions de .Net Framework est la classe Exception. Le CLR a arrt le programme immdiatement cet endroit parce qu'elle n'a pas trouv de code d'interception de cette exception qu'il a leve automatiquement :
Nous allons voir comment intercepter (on dit aussi "attraper" - to catch) cette exception afin de faire ragir notre programme pour qu'il ne s'arrte pas brutalement.
Programme avec gestion de l'exception C# possde une instruction qui permet d'intercepter des exceptions drivant de la classe Exception : try ... catch On dnomme cette instruction : un gestionnaire d'exceptions. Syntaxe minimale d'un tel gestionnaire try catch : try
- Rm di Scala
page
242
{ <lignes de code protger> } catch ( UneException ) { <lignes de code ragissant lexception UneException > } Le type UneException est obligatoirement une classe qui hrite de la classe Exception.
Schma du fonctionnement d'un tel gestionnaire : Le gestionnaire d'exception "droute" l'excution du programme vers le bloc d'interception catch qui traite l'exception (excute le code contenu dans le bloc catch), puis renvoie et continue l'excution du programme vers le code situ aprs le gestionnaire lui-mme.
1.2 Principe de fonctionnement de l'interception Ds qu'une exception est leve (instancie), le CLR stoppe immdiatement l'excution normale du programme la recherche d'un gestionnaire d'exception susceptible d'intercepter (saisir) et de traiter cette exception. Cette recherche s'effectue partir du bloc englobant et se poursuit sur les blocs plus englobants si aucun gestionnaire de cette exception n'a t trouv. Soit le mme programme C# que prcdemment, contenant un incident d'excution (une division par zro dans l'instruction x = 1/0; ). Cette fois nous allons grer l'incident grce un gestionnaire d'exception try..catch dans le bloc englobant immdiatement suprieur. Programme avec traitement de l'incident par try...catch :
class Action1 { public void meth() { int x, y =0; Console.WriteLine(" ...Avant incident"); x = 1 / y; Console.WriteLine(" ...Aprs incident"); } } class Program {
- Rm di Scala
page
243
static void Main(string[] args) { Action1 Obj = new Action1(); Console.WriteLine("Dbut du programme."); try { Obj.meth(); } catch (DivideByZeroException) { Console.WriteLine("Interception exception"); } Console.WriteLine("Fin du programme."); } }
Figuration du droulement de l'excution de ce programme :
Ci-dessous l'affichage obtenu sur la console lors de l'excution de ce programme :
Nous remarquons que le CLR a donc bien excut le code d'interception situ dans le corps du "catch (DivideByZeroException ){...}", il a poursuivi l'excution normale
- Rm di Scala
page
244
aprs le gestionnaire. Le gestionnaire d'exception se situe dans la mthode Main (code englobant) qui appelle la mthode meth( ) qui lve l'exception.
Il est aussi possible d'atteindre l'objet d'exception qui a t instanci (ou lev) en dclarant un identificateur local au bloc catch du gestionnaire d'exception try catch, cet objet est disponible dans tout le corps de la clause catch. Dans l'exemple qui suit, on dclare un objet Except de classe DivideByZeroException et l'on lit le contenu de deux de ses proprits Message et Source : try{ Obj.meth(); } catch ( DivideByZeroException Except ) { // accs aux membres publiques de l'objet Except : Console.WriteLine("Interception exception message : " + Except.Message); Console.WriteLine("Interception exception source : " + Except.Source); . }
2. Interception d'exceptions hirarchises

2.1 Interceptions de plusieurs exceptions Dans un gestionnaire try...catch, il est en fait possible d'intercepter plusieurs types d'exceptions diffrentes et de les traiter. Ci-aprs nous montrons la syntaxe d'un tel gestionnaire qui fonctionne comme un slecteur ordonn, ce qui signifie qu'une seule clause d'interception est excute. Ds qu'une exception intervient dans le < bloc de code protger>, le CLR scrute squentiellement toutes les clauses catch de la premire jusqu' la nime. Si l'exception actuellement leve est d'un des types prsents dans la liste des clauses le traitement associ est effectu, la scrutation est abandonne et le programme poursuit son excution aprs le gestionnaire. try { < bloc de code protger> } catch ( TypeException1 E ) { <Traitement TypeException1 > } catch ( TypeException2 E ) { <Traitement TypeException2 > } ..... catch ( TypeExceptionk E ) { <Traitement TypeExceptionk > } O TypeException1, TypeException12, ... , TypeExceptionk sont des classes d'exceptions obligatoirement toutes distinctes. Seule une seule clause catch ( TypeException E ) {...}est excute (celle qui correspond au bon type de l'objet d'exception instanci).
- Rm di Scala
page
245
Exemple thorique : Soit SystemException la classe des exceptions prdfinies dans le nom despace System de .Net Framework, InvalidCastException, IndexOutOfRangeException, NullReferenceException et ArithmeticException sont des classes drivant directement de la classe SystemException. Supposons que la mthode meth() de la classe Action2 puisse lever quatre types diffrents d'exceptions: InvalidCastException, IndexOutOfRangeException, NullReferenceException et ArithmeticException. Notre gestionnaire d'exceptions est programm pour intercepter l'une de ces 4 catgories. Nous figurons ci-dessous les trois schmas d'excution correspondant chacun la leve (l'instanciation d'un objet) d'une exception de l'un des trois types et son interception :
class Action2 { public void meth( ) { // une exception est leve ..... } } class Program { static void Main(string[] args) { Action2 Obj = new Action2(); Console.WriteLine("Dbut du programme."); try { Obj.meth(); } catch ( InvalidCastException E ) { Console.WriteLine("Interception InvalidCastException"); } catch ( IndexOutOfRangeException E ) { Console.WriteLine("Interception IndexOutOfRangeException "); } catch ( NullReferenceException E ) { Console.WriteLine("Interception NullReferenceException"); } catch ( ArithmeticException E ) { Console.WriteLine("Interception ArithmeticException"); } Console.WriteLine("Fin du programme."); }
} Nous figurons ci-aprs deux schmas d'interception sur l'ensemble des quatre possibles d'une ventuelle exception qui serait leve dans la mthode meth( ) de l'objet Obj. Schma d'interception d'une IndexOutOfRangeException :
- Rm di Scala
page
246
Schma d'interception d'une ArithmeticException :
2.2 Ordre d'interception d'exceptions hirarchises Dans un gestionnaire try...catch comprenant plusieurs clauses, la recherche de la clause catch contenant le traitement de la classe d'exception approprie, seffectue squentiellement dans lordre dcriture des lignes de code. Soit le pseudo-code C# suivant :
- Rm di Scala
page
247
try { < bloc de code protger gnrant un objet exception> } catch ( TypeException1 E ) { <Traitement TypeException1 > } catch ( TypeException2 E ) { <Traitement TypeException2 > } ..... catch ( TypeExceptionk E ) { <Traitement TypeExceptionk > } La recherche va s'effectuer comme si le programme contenait des if...else if... imbriqus : if (<Objet exception> is TypeException1) { <Traitement TypeException1 > } else if (<Objet exception> is TypeException2) { <Traitement TypeException2 > } ... else if (<Objet exception> is TypeExceptionk) { <Traitement TypeExceptionk > } Les tests sont effectus sur l'appartenance de l'objet d'exception une classe l'aide de l'oprateur is. Signalons que l'oprateur is agit sur une classe et ses classes filles (sur une hirarchie de classes), c'est dire que tout objet de classe TypeExceptionX est aussi considr comme un objet de classe parent au sens du test d'appartenance en particulier cet objet de classe TypeExceptionX est aussi considr objet de classe Exception qui est la classe mre de toutes les exceptions C#.
Le test d'appartenance de classe dans la recherche d'une clause catch fonctionne d'une faon identique l'oprateur is dans les if...else On choisira donc, lorsquil y a une hirarchie entre les exceptions intercepter, de placer le code de leurs gestionnaires dans lordre inverse de la hirarchie. Exemple : Soit une hirarchie d'exceptions de C# System.Exception |__System.SystemException |__System.InvalidCastException |__System.IndexOutOfRangeException |__System.NullReferenceException |__System.ArithmeticException Soit le modle de gestionnaire d'interception dj fourni plus haut : try { < bloc de code protger gnrant un objet exception> } catch (InvalidCastException E ) { <Traitement InvalidCastException > } catch ( IndexOutOfRangeException E ) { <Traitement IndexOutOfRangeException > } catch (NullReferenceException E ) { <Traitement NullReferenceException > } catch (ArithmeticException E ) { <Traitement ArithmeticException > } Supposons que nous souhaitions intercepter une cinquime classe d'exception, par exemple
- Rm di Scala
page
248
une DivideByZeroException, nous devons rajouter une clause : catch (DivideByZeroException E ) { <Traitement DivideByZeroException > } Insrons cette clause en dernier dans la liste des clauses d'interception :
try { Obj.meth(); } catch ( InvalidCastException E ) { Console.WriteLine("Interception InvalidCastException"); } catch ( IndexOutOfRangeException E ) { Console.WriteLine("Interception IndexOutOfRangeException "); } catch ( NullReferenceException E ) { Console.WriteLine("Interception NullReferenceException"); } catch ( ArithmeticException E ) { Console.WriteLine("Interception ArithmeticException"); } catch (DivideByZeroException E ) { Console.WriteLine("Interception DivideByZeroException "); } Console.WriteLine("Fin du programme."); }
Nous lanons ensuite la compilation de cette classe et nous obtenons un message d'erreur : Error 1 : Une clause catch prcdente intercepte dj toutes les expressions de this ou d'un super type ('System.ArithmeticException') Le compilateur proteste partir de la clause catch (DivideByZeroException E ) en nous indiquant que l'exception est dj intercepte.
Que s'est-il pass ?

Le fait de placer en premier la clause catch (ArithmeticException E ) charge d'intercepter les exceptions de classe ArithmeticException implique que n'importe quelle exception hritant de ArithmeticException comme par exemple DivideByZeroException, est considre comme une ArithmeticException. Dans un tel cas cette DivideByZeroException est intercepte par la clause catch (ArithmeticException E ) mais elle n'est jamais intercepte par la clause catch (DivideByZeroException E ) . Le seul endroit o le compilateur C# acceptera l'criture de la clause catch (DivideByZeroException E ) se situe dans cet exemple avant la clause catch (ArithmeticException E ). Ci-dessous l'criture d'un programme correct :
try { Obj.meth(); } catch ( InvalidCastException E )
- Rm di Scala
page
249
{ Console.WriteLine("Interception InvalidCastException"); } catch ( IndexOutOfRangeException E ) { Console.WriteLine("Interception IndexOutOfRangeException "); } catch ( NullReferenceException E ) { Console.WriteLine("Interception NullReferenceException"); } catch (DivideByZeroException E ) { Console.WriteLine("Interception DivideByZeroException "); } catch ( ArithmeticException E ) { Console.WriteLine("Interception ArithmeticException"); } Console.WriteLine("Fin du programme."); }
Dans ce cas la recherche squentielle dans les clauses permettra le filtrage correct des classes filles puis ensuite le filtrage des classes mres.
On choisira donc, lorsquil y a une hirarchie entre les exceptions intercepter, de placer le code de leurs clauses dans lordre inverse de la hirarchie.
3. Redclenchement d'une exception mot-clef : throw

Il est possible de dclencher soi-mme des exceptions en utilisant l'instruction throw, voir mme de dclencher des exceptions personnalises ou non. Une exception personnalise est une classe hritant de la classe System.Exception dfinie par le dveloppeur lui-mme.
3.1 Dclenchement manuel d'une exception de classe dj existante Le CLR peut dclencher une exception automatiquement comme dans l'exemple de la leve d'une DivideByZeroException lors de l'excution de l'instruction "x = 1/y ;". Le CLR peut aussi lever (dclencher) une exception votre demande suite la rencontre d'une instruction throw. Le programme qui suit lance une ArithmeticException (ie: instancie un objet de type ArithmeticException) avec le message "Mauvais calcul !" dans la mthode meth( ) et intercepte cette exception dans le bloc englobant Main. Le traitement de cette exception consiste afficher le contenu du champ message de l'exception grce la proprit Message de l'exception :
class Action3 { public void meth() { int x = 0;
- Rm di Scala
page
250
Console.WriteLine(" ...Avant incident"); if (x == 0) throw new ArithmeticException("Mauvais calcul !"); Console.WriteLine(" ...Aprs incident"); } } class Program { static void Main(string[] args) { Action3 Obj = new Action3(); Console.WriteLine("Dbut du programme."); try { Obj.meth(); } catch (ArithmeticException E) { Console.WriteLine("Interception ArithmeticException : "+E.Message); } Console.WriteLine("Fin du programme."); } }
Rsultats de l'excution du programme prcdent :
3.2 Dclenchement manuel d'une exception personnalise Pour une exception personnalise, le mode d'action est strictement identique, il vous faut seulement auparavant crer une nouvelle classe hritant obligatoirement de la classe Exception ou de n'importe laquelle de ses sous-classes. Reprenons le programme prcdent et crons une classe d'exception que nous nommerons ArithmeticExceptionPerso hritant de la classe des ArithmeticException puis excutons ce programme :
class ArithmeticExceptionPerso : ArithmeticException { public ArithmeticExceptionPerso(String s) : base(s) { } } class Action3 { public void meth() { int x = 0; Console.WriteLine(" ...Avant incident"); if (x == 0) throw new ArithmeticExceptionPerso ("Mauvais calcul !"); Console.WriteLine(" ...Aprs incident"); } } class Program {
- Rm di Scala
page
251
static void Main(string[] args) { Action3 Obj = new Action3(); Console.WriteLine("Dbut du programme."); try { Obj.meth(); } catch (ArithmeticExceptionPerso E) { Console.WriteLine("Interception ArithmeticExceptionPerso: "+E.Message); } Console.WriteLine("Fin du programme."); } }
Rsultats de l'excution du programme prcdent : Dbut du programme. ...Avant incident Interception ArithmeticExceptionPerso : Mauvais calcul ! Fin du programme. L'excution de ce programme est identique celle du programme prcdent, notre exception personnalise fonctionne bien comme les exceptions prdfinies de C#.
4. Clause finally
Supposons que nous soyons en prsence d'un code contenant une ventuelle leve d'exception, mais supposons que quoiqu'il se passe nous dsirions qu'un certain type d'action ait toujours lieu (comme par exemple fermer un fichier qui a t ouvert auparavant). Il existe en C# une clause spcifique optionnelle dans la syntaxe des gestionnaires d'exception permettant ce type de raction du programme, c'est la clause finally. Voici en pseudo C# une syntaxe de cette clause :
<Ouverture du fichier> try { < action sur fichier> } catch( ) { < traitement si exception >} finally { <fermeture du fichier> } .... suite
- Rm di Scala
page
252
Fonctionnement sans incident Si aucun incident ne se produit durant l'excution du bloc try < action sur fichier> :
1) l'excution se poursuit l'intrieur du bloc finally par l'action <fermeture du fichier> 3) et la suite du code continue s'excuter.
Fonctionnement si un incident se produit Si un incident se produit durant l'excution du bloc try < action sur fichier> et qu'une exception est lance: 1) La clause catch intercepte l'exception et la traite puis, 2) l'excution se poursuit l'intrieur du bloc finally par l'action <fermeture du fichier> 3) et enfin la suite du code continue s'excuter.
La syntaxe C# autorise l'criture d'une clause finally associe plusieurs clauses catch : try { <code protger> } catch (exception1 e ) { <traitement de l'exception1> } catch (exception2 e ) { <traitement de l'exception2> } ... finally { <action toujours effectue> } Remarque : Si le code du bloc protger dans try...finally contient une instruction de rupture de squence comme break, return ou continue, le code de la clause finally{...} est malgr tout excut avant la rupture de squence.
- Rm di Scala
page
253
Nous avons vu lors des dfinitions des itrations while, for et de l'instruction continue, que l'quivalence suivante entre un for et un while valide dans le cas gnral, tait mise en dfaut si le corps d'instruction contenait un continue (instruction forant l'arrt d'un tours de boucle et relanant l'itration suivante) : Equivalence incorrecte si Instr contient un continue : Expr1 ; while ( Expr2 ) for (Expr1 ; Expr2 ; Expr3 ) Instr { Instr ; Expr3 } Equivalence correcte mme si Instr contient un continue : Expr1 ; while ( Expr2 ) { try { for (Expr1 ; Expr2 ; Expr3 ) Instr Instr ; } finally { Expr3 } }
5. Un exemple de traitement d'exceptions sur des fichiers

Crons une hirarchie d'exceptions permettant de signaler des incidents sur des manipulations de fichiers. Pour cela on distingue essentiellement trois catgories d'incidents qui sont reprsents par trois classes :
- Rm di Scala
page
254
Enonc : Nous nous proposons de

mettre en oeuvre les concepts prcdents sur un exemple simulant un traitement de fichier. L'application est compose d'un bloc principal <programme> qui appelle une suite de blocs imbriqus. Les classes en jeu et les blocs de programmes (mthodes) acteurs dans le traitement des exceptions sont figures dans les diagrammes UML de droite :
<programme: prTransmettre> <ActionsSurFichier> ..<AfficheFichier> ...<ChercheElement> ..............<OuvrirFichier> --> exception ..............<LireElement> --> exception ..........<FermerFichier> --> exception
Les trois blocs du dernier niveau les plus internes <OuvrirFichier>, <LireElement> et <FermerFichier> peuvent lancer chacun une exception selon le schma ci-aprs :
La dmarche
Les ventuelles exceptions lances par les blocs <OuvrirFichier>,<LireElement> et <FermerFichier> doivent pouvoir se propager aux blocs de niveaux englobant afin d'tre
- Rm di Scala
page
255
interceptables n'importe quel niveau.
Les classes d'exception
On propose de crer une classe gnrale d'exception EFichierError hritant de la classe des Exception, puis 3 classes d'exception hritant de cette classe EFichierError :
- Rm di Scala
page
256
Les blocs lanant ventuellement une exception
Chaque bloc le plus interne peut lancer (lever) une exception de classe diffrente et la propage au niveau suprieur :
Les blocs interceptant les exceptions
Nous proposons par exemple d'intercepter les exceptions dans les deux blocs <ActionsSurFichier> et <AfficheFichier> :
- Rm di Scala
page
257
Le bloc <AfficherFichier>
Ce bloc interceptera une exception de type EFichierError, puis la redclenchera aprs traitement :
Le bloc <ActionsSurFichier>
Ce bloc interceptera une exception de l'un des trois types EOuvertureError, ELectureError ou EFermetureError :
6. Une solution de lexemple prcdent en C#
using System ; namespace PrTests { /* pseudo-Traitement d'un fichier plusieurs niveaux, * avec exception et relance d'exception */ class EFichierError : Exception { public int typeErr ; public EFichierError ( String s, int x ): base ( s ) { typeErr = x ; } } Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
258
class EOuvertureError : EFichierError { public EOuvertureError ( int x ): base ("Impossible d'ouvrir le fichier !" ,x ) { } } class ELectureError : EFichierError{ public ELectureError ( int x ): base ("Impossible de lire le fichier !" ,x ) { } } class EFermetureError : EFichierError{ public EFermetureError ( int x ): base ("Impossible de fermer le fichier !" ,x ) { } }
//------------------------------------------------------------------------------------------------------------------------------public class PrTransmettre { void TraitementGen ( String s ) { System .Console.WriteLine ("traitement general de lerreur: " + s ); } void TraitementSpecif ( String s ) { System .Console.WriteLine ("traitement specifique de lerreur: " + s ); } void OuvrirFichier ( ) { System .Console.WriteLine (" GenererIncident ( 1 ); System .Console.WriteLine (" } void LireElement ( ) { System .Console.WriteLine (" GenererIncident ( 2 ); System .Console.WriteLine (" }
>> Action ouverture..."); >> Fin ouverture.");
>> Action lecture..."); >> Fin lecture.");
void FermerFichier ( ) { System .Console.WriteLine (" >> Action fermeture..."); GenererIncident ( 3 ); System .Console.WriteLine (" >> Fin fermeture."); }
- Rm di Scala
page
259
void ChercheElement ( ) { OuvrirFichier ( ); LireElement ( ); FermerFichier ( ); }
//-----------------------------------------------------------------------------------------void GenererIncident ( int TypeIncident ) { int n ; Random nbr = new Random ( ); switch ( TypeIncident ) { case 1 : n = nbr.Next ( ) % 4 ; if ( n == 0 ) throw new EOuvertureError ( TypeIncident ); break; case 2 : n = nbr.Next ( ) % 3 ; if ( n == 0 ) throw new ELectureError ( TypeIncident ); break; case 3 : n = nbr.Next ( ) % 2 ; if ( n == 0 ) throw new EFermetureError ( TypeIncident ); break; } }
//-----------------------------------------------------------
- Rm di Scala
page
260
void ActionsSurFichier ( ) { System .Console.WriteLine ("Debut du travail sur le fichier."); try { System .Console.WriteLine ("........."); AfficherFichier ( ); }
catch( EOuvertureError E ) { TraitementSpecif ( E.Message ); } catch( ELectureError E ) { TraitementSpecif ( E.Message ); } catch( EFermetureError E ) { TraitementSpecif ( E.Message ); } System.Console.WriteLine ("Fin du travail sur le fichier."); } //----------------------------------------------------------------void AfficherFichier ( ) { try { ChercheElement ( ); } catch( EFichierError E ) { TraitementGen ( E.Message ); throw E ; } } public static void Main ( string [ ] arg ) { PrTransmettre Obj = new PrTransmettre ( ); try { Obj.ActionsSurFichier ( ); } catch( EFichierError E ) { System .Console.WriteLine ( " Autre type d'Erreur gnrale Fichier !"); } System .Console.ReadLine ( ); } } }
- Rm di Scala
page
261
Exemples d'excutions avec un incident de chaque type :

La mthode GenererIncident afin de simuler un incident, lance alatoirement lors de l'excution soit une exception de l'un des trois type EOuvertureError (incident lors de l'ouverture), ELectureError (incident lors de la lecture), EFermetureError (incident lors de la fermeture), soit ne lance pas d'exception pour indiquer le bon droulement de toutes les oprations. Le mcanisme des trycatch mis en place dans le programme intercepte une ventuelle exception et la propage. Nous donnons ci-dessous les rsultats console dans chcun des quatre cas.
1) Aucune exception n' a t lance (pas d'incident) :
2) Une exception de type EOuvertureError a t lance (incident lors de l'ouverture) :
3) Une exception de type ELectureError a t lance (incident lors de la lecture) :
4) Une exception de type EFermetureError a t lance (incident lors de la fermeture) :
- Rm di Scala
page
262
Processus et multi-threading
Plan gnral:
1. Rappels
1.1 La multiprogrammation 1.2 Multitche et processus 1.3 Multi-threading et processus
2. C# autorise l'utilisation des processus et des threads

2.1 Les processus avec C# 2.2 Comment excuter une application partir d'une autre application 2.3 Comment atteindre un processus dj lanc 2.4 Comment arrter un processus
3. C# et les threads
3.1 Comment crer un Thread 3.2 Comment endormir, arrter ou interrompre un Thread 3.3 Exclusion mutuelle, concurrence, section critique, et synchronisation 3.4 Section critique en C# : lock 3.5 Section critique en C# : Monitor 3.6 Synchronisation commune aux processus et aux threads
- Rm di Scala
page
263
1. Rappels
1.1 La multiprogrammation Nous savons que les ordinateurs fonds sur les principes d'une machine de Von Neumann, sont des machines squentielles donc n'excutant qu'une seule tche la fois. Toutefois, le gaspillage de temps engendr par cette manire d'utiliser un ordinateur (le processeur central passe l'crasante majorit de son temps attendre) a trs vite t endigu par l'invention de systmes d'exploitations de multiprogrammation ou multitches, permettant l'excution "simultane" de plusieurs tches. Dans un tel systme, les diffrentes tches sont excutes sur une machine disposant d'un seul processeur, en apparence en mme temps ou encore en parallle, en ralit elles sont excutes squentiellement chacune leur tour, ceci ayant lieu tellement vite pour notre conscience que nous avons l'impression que les programmes s'excutent simultanment. Rappelons ici qu'une tche est une application comme un traitement de texte, un navigateur Internet, un jeu,... ou d'autres programmes spcifiques au systme d'exploitation que celui-ci excute.
1.2 Multitche et processus Le noyau du systme d'exploitation SE, conserve en permanence le contrle du temps d'excution en distribuant cycliquement des tranches de temps (time-slicing) chacune des applications A, B, C et D figures ci-dessous. Dans cette ventualit, une application reprsente dans le systme un processus :
Rappelons la dfinition des processus donne par A.Tanenbaum: un programme qui s'excute et qui possde son propre espace mmoire : ses registres, ses piles, ses variables et son propre processeur virtuel (simul en multiprogrammation par la commutation entre processus effectue par le processeur unique).
- Rm di Scala
page
264
Thread En fait, chaque processus peut lui-mme fonctionner comme le systme d'exploitation en lanant des sous-tches internes au processus et par l mme reproduire le fonctionnement de la multiprogrammation. Ces sous-tches sont nommes "flux d'excution" ou Threads. Ci-dessous nous supposons que l'application D excute en mme temps les 3 Threads D1, D2 et D3 :
Reprenons l'exemple d'excution prcdent, dans lequel 4 processus s'excutent "en mme temps" et incluons notre processus D possdant 3 flux d'excutions (threads) :
La commutation entre les threads d'un processus fonctionne de la mme faon que la commutation entre les processus, chaque thread se voit allou cycliquement, lorsque le processus D est excut une petite tranche de temps.
Le partage et la rpartition du temps sont effectus uniquement par le systme d'exploitation :
- Rm di Scala
page
265
1.3 Multithreading et processus Dfinition : La majorit des systmes d'exploitation (Windows, Linux, Solaris, MacOs,...) supportent l'utilisation d'application contenant des threads, l'on dsigne cette fonctionnalit sous le nom de Multi-threading.
Diffrences entre threads et processus : Communication entre threads plus rapide que la communication entre processus, Les threads partagent un mme espace de mmoire (de travail) entre eux, Les processus ont chacun un espace mmoire personnel.
Dans l'exemple prcdent, figurons les processus A, B, C et le processus D avec ses threads dans un graphique reprsentant une tranche de temps d'excution alloue par le systme et suppose tre la mme pour chaque processus.
Le systme ayant allou le mme temps d"excution chaque processus, lorsque par exemple le tour vient au processus D de s'excuter dans sa tranche de temps, il excutera une petite sous-tranche pour D1, pour D2, pour D3 et attendra le prochain cycle. Ci-dessous un cycle d'excution :
- Rm di Scala
page
266
Voici sous les mmes hypothses de temps gal d'excution allou chaque processus, le comportement de l'excution sur 3 cycles conscutifs :
Le langages C# dispose de classes permettant d'crire et d'utiliser des threads dans vos applications.
2. C# autorise l'utilisation des processus et des threads

Lorsqu'un programme C# s'excute en dehors d'une programmation de multi-threading, le processus associ comporte automatiquement un thread appel thread principal. Un autre thread utilis dans une application s'appelle un thread secondaire. Supposons que les quatre applications (ou tches) prcdentes A, B, C et D soient toutes des applications C#, et que D soit celle qui comporte trois threads secondaires D1, D2 et D3 "paralllement" excuts :
- Rm di Scala
page
267
2.1 Les processus avec C# Il existe dans .Net Framework une classe nomme Process dans l'espace de nom System.Diagnostics, permettant d'accder des processus locaux la machine ou distants et de les manipuler ( dmarrer, surveiller, stopper, ). Cette classe est bien documente par la bibliothque MSDN de Microsoft, nous allons dans ce paragraphe montrer comment l'utiliser partir d'un cas pratique souvent rencontr par le dbutant : comment lancer une autre application partir d'une application dj en cours d'excution.
2.2 Comment excuter une application partir d'une autre 1 ) Instancier un objet de classe Process : Process AppliAexecuter = new Process( ); 2) Paramtrer les informations de lancement de l'application excuter : Parmi les nombreuses proprits de la classe Process la proprit StartInfo (public ProcessStartInfo StartInfo {get; set;}) est incontournable, car elle permet ce paramtrage. Supposons que notre application se nomme "Autreappli.exe" qu'elle soit situe sur le disque C: dans le dossier "Travail", qu'elle ncessite au dmarrage comme paramtre le nom d'un fichier contenant des donnes, par exemple le fichier "donnees.txt" situ dans le dossier "C:\infos". La proprit StartInfo s'utilise alors comme suit afin de prparer le lancement de l'application : AppliAexecuter.StartInfo.FileName ="c:\\Travail\\Autreappli.exe"; AppliAexecuter.StartInfo.UseShellExecute = false; AppliAexecuter.StartInfo.RedirectStandardOutput = false; Appliexec.StartInfo.Arguments ="c:\\infos\\donnees.txt"; Remarques : UseShellExecute = false: permet de lancer directement l'application sans avoir utiliser l'interface shell du systme d'exploitation.
- Rm di Scala
page
268
RedirectStandardOutput = false: la sortie standard du processus reste dirige vers l'cran par dfaut.
3) Dmarrer le processus par exemple par la surcharge d'instance de la mthode Start( ) de la classe Process : AppliAexecuter.Start( );
Code rcapitulatif de la mthode Main pour lancer un nouveau processus dans une application en cours d'excution : public static void Main( ) { Process AppliAexecuter = new Process( ); AppliAexecuter.StartInfo.FileName ="c:\\Travail\\Autreappli.exe"; AppliAexecuter.StartInfo.UseShellExecute = false; AppliAexecuter.StartInfo.RedirectStandardOutput = false; Appliexec.StartInfo.Arguments ="c:\\infos\\donnees.txt"; AppliAexecuter.Start( ); } Image produit par ce code dans la mmoire centrale :
2.3 Comment atteindre un processus dj lanc Atteindre le processus courant de l'application appelante : Process Courant = Process.GetCurrentProcess(); Atteindre toutes les instances de processus d'une application nomme "Autreappli.exe" lance plusieurs fois grce son nom sur l'ordinateur local : Process [] localProcess = Process.GetProcessesByName("Autreappli"); Atteindre toutes les instances de processus d'une application nomme "Autreappli.exe" lance plusieurs fois grce son nom sur un ordinateur distant de nom "ComputerDistant" : Process [] localProcess = Process.GetProcessesByName("Autreappli","ComputerDistant");
- Rm di Scala
page
269
Atteindre toutes les instances de processus d'une application nomme "Autreappli.exe" lance plusieurs fois grce son nom sur un ordinateur distant d'adresse IP connue par exemple "101.22.34.18": Process [] localProcess = Process.GetProcessesByName("Autreappli","101.22.34.18"); Atteindre un processus grce l'identificateur unique sur un ordinateur local de ce processus par exemple 9875 : Process localProcess = Process.GetProcessById(9875); Atteindre un processus grce l'identificateur unique de ce processus par exemple 9875 sur un ordinateur distant de nom "ComputerDistant" : Process localProcess = Process.GetProcessById(9875, "ComputerDistant"); Atteindre un processus grce l'identificateur unique de ce processus par exemple 9875 sur un ordinateur distant d'adresse IP connue par exemple "101.22.34.18" : Process localProcess = Process.GetProcessById(9875, "101.22.34.18");
2.4 Comment arrter un processus Seuls les processus locaux peuvent tre stopps dans .Net Framework, les processus distants ne peuvent qu'tre surveills. Si le processus est une application fentre (application possdant une interface IHM) La mthode "public bool CloseMainWindow( )" est la mthode employer Process AppliAexecuter = new Process( ); . AppliAexecuter.CloseMainWindow( ); Cette mthode renvoie un boolen qui indique : True si la fermeture a t correctement envoye et le processus est stopp. False si le processus n'est pas stopp soit parcequ'il y a eu un incident, soit parce que le processus n'tait une application fentre (application console).
Si le processus n'est pas une application fentre (application console) La mthode "public void Kill( )" est la mthode employer Process AppliAexecuter = new Process( ); . AppliAexecuter.Kill( ); Ou bien : if( !AppliAexecuter.CloseMainWindow( ) ) AppliAexecuter.Kill( );
- Rm di Scala
page
270
3. C# et les threads
Comme l'avons dj signal tous les systmes d'exploitation modernes permettent la programmation en multi-threading, le .Net Framework contient une classe rserve cet usage dans l'espace de noms System.Threading : la classe non hritable Thread qui implmente l'interface _Thread. public sealed class Thread: _Thread Cette classe Thread sert crer, contrler, et modifier les priorits de threads.
3.1 Comment crer un Thread Le C# 2.0 propose quatre surcharges du constructeur de Thread, toutes utilisent la notion de delegate pour prciser le code excuter dans le thread, nous examinons celle qui est la plus utilise depuis la version 1.0. public Thread ( ThreadStart start ); Le paramtre start de type ThreadStart est un objet delegate sans paramtre qui pointe sur ( equiv : fait rfrence ) la mthode appeler chaque excution du thread ainsi cr : public delegate void ThreadStart ( );
Vous devez donc crire une mthode de classe ou d'instance ayant la mme signature que le delegate void ThreadStart ( ), puis crer l'objet delegate qui pointera vers cette mthode. Vous pouvez nommer cette mthode du nom que vous voulez, pour rester dans le style Java nous la dnommerons run( ). Ci-dessous un pseudo-code C# de cration d'un thread partir d'un dlgu pointant sur une mthode de classe : public class ChargerDonnees { public static void run( ){ . } } public class AppliPrincipale { public static void Main( ){ ThreadStart ChargerDelegate = new ThreadStart (ChargerDonnees.run); Thread thrdChargement = new Thread(ChargerDelegate); } } Notons qu'il est possible d'allger le code d'instanciation du thread en crant un objet dlgu anonyme qui est pass en paramtre au constructeur de Thread : Thread thrdChargement = new Thread( new ThreadStart (ChargerDonnees.run) );
Dans l'exemple qui suit nous lanons trois threads en plus du thread principal automatiquement construit par le CLR pour chaque processus, l'un partir d'une mthode static run0 de la classe Program et les deux autres partir d'une mthode static run1 et d'une mthode d'instance run2 de
- Rm di Scala
page
271
la classe AfficherDonnees :
public class AfficherDonnees { public static void run1() { for (int i1 = 1; i1 < 100; i1++) System.Console.WriteLine(">>> thread1 = " + i1); } public void run2() { for (int i2 = 1; i2 < 100; i2++) System.Console.WriteLine("*** thread2 = " + i2); } } public class Program { public static void run0() { for (int i0 = 1; i0 < 100; i0++) System.Console.WriteLine(".... thread0 = " + i0); } static void Main(string[] args) { Console.WriteLine("Lancement des threads :"); AfficherDonnees obj = new AfficherDonnees(); Thread thread0 = new Thread(new ThreadStart( run0 )); Thread thread1 = new Thread(new ThreadStart(AfficherDonnees.run1)); Thread thread2 = new Thread(new ThreadStart(obj.run2)); thread0.Start(); thread1.Start(); thread2.Start(); for (int i = 1; i < 100; i++) System.Console.WriteLine(" i = " + i); System.Console.WriteLine("fin de tous les threads."); } } Rsultats de l'excution du programme prcdent (dpendants de votre configuration machine+OS) : Lancement des threads : .... thread0 = 1 >>> thread1 = 1 i=1 *** thread2 = 1 .... thread0 = 2 >>> thread1 = 2 i=2 *** thread2 = 2 .... thread0 = 3 . i = 98 *** thread2 = 98 .... thread0 = 99 >>> thread1 = 99 i = 99 *** thread2 = 99 fin de tous les threads.
L'excution prcdente montre bien que chacun des thread0, thread1 et thread2 se voient allouer une tranche de temps pendant laquelle chacun d'eux excute une partie de sa boucle for et
- Rm di Scala
page
272
imprime ses informations sur la console. Chaque thread se termine lorsque le code de la mthode run vers laquelle il pointe a fini de s'excuter. Nous figurons ci-aprs l'image de la mmoire centrale pour le processus Program avec chacun des 3 threads instancis pointant vers la mthode qu'il excute :
3.2 Comment endormir, arrter ou interrompre un Thread La socit Microsoft a dprci depuis la version 2.0 du .Net Framework les mthodes Suspend() et Resume() qui permettaient d'effectuer la synchronisation entre les threads, toutefois elles n'ont pas t supprimes. En ce sens Microsoft adopte la mme attitude que Sun pour Java, afin de ne pas encourager les dveloppeurs utiliser des outils qui se sont montrs sensibles aux blocages du type verrou mortel. Nous ne proposerons donc pas ces mthodes dangereuses au lecteur, mais plutt des mthodes sres.
Endormir : Mthode Sleep ( )

On parle d'endormir un thread pendant un certain temps t, lorsque l'excution de ce thread est arrte pendant ce temps t, c'est dire que le thread est retir de la file d'attente de l'algorithme d'ordonnancement du systme. A la fin du temps t, le thread est automatiquement "rveill" par le systme, c'est dire qu'il est replac dans la file d'attente de l'ordonnanceur et donc son excution repart. La mthode "public static void Sleep( int millisecondsTimeout )" sert endormir un thread pendant un temps exprim en millisecondes. Dans la mthode run0( ) de l'exemple prcdent si nous rajoutons l'instruction "Thread.Sleep(2);", nous "ralentissons" l'excution de la boucle, puisque tous les tours de boucles nous bloquons le thread qui l'excute pendant 2 ms.
public static void run0( ) { for (int i0 = 1; i0 < 100; i0++) { System.Console.WriteLine(".... thread0 = " + i0); Thread.Sleep(2); } Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
273
} Rsultats de l'excution du programme prcdent avec Thread.Sleep(2) dans la mthode run0( ) : .... thread0 = 85 Lancement des threads : .... thread0 = 86 .... thread0 = 1 .... thread0 = 87 >>> thread1 = 1 .... thread0 = 88 i=1 .... thread0 = 89 *** thread2 = 1 .... thread0 = 90 . .... thread0 = 91 i = 98 .... thread0 = 92 *** thread2 = 98 .... thread0 = 93 .... thread0 = 79 .... thread0 = 94 >>> thread1 = 99 .... thread0 = 95 i = 99 .... thread0 = 96 *** thread2 = 99 .... thread0 = 97 .... thread0 = 80 .... thread0 = 98 fin de tous les threads. .... thread0 = 99 .... thread0 = 81 .... thread0 = 82 (rsultats dpendants de votre configuration .... thread0 = 83 machine+OS) .... thread0 = 84
Notons que cette excution est semblable la prcdente, du moins au dpart, car nous constatons vers la fin que le thread0 a pris un lger retard sur ses collgues puisque le thread1 et le thread2 se termine avec la valeur 99, le thread principal affiche la phrase "fin de tous les threads" alors que le thread0 n'a pas encore dpass la valeur 80. Les trois threads thread1, thread2 et le thread principal sont en fait termins seul le thread0 continue sont excution jusqu' la valeur 99 qui clt son activit.
Arrter : Mthode Abort ( )

Dans l'exemple prcdent le message "fin de tous les threads" n'est pas conforme la ralit puisque le programme est bien arriv la fin du thread principal, mais thread0 continue son excution. Il est possible de demander au systme d'arrter dfinitivement l'excution d'un thread, cette demande est introduite par la mthode d'instance Abort de la classe Thread qui lance le processus d'arrt du thread qui l'appelle. Nous reprenons le programme prcdent dans lequel nous lanons une demande d'arrt du thread0 par l'instruction : thread0.Abort();
public class AfficherDonnees { public static void run1() { for (int i1 = 1; i1 < 100; i1++) System.Console.WriteLine(">>> thread1 = " + i1); } public void run2() { for (int i2 = 1; i2 < 100; i2++) System.Console.WriteLine("*** thread2 = " + i2); } } public class Program Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
274
{ public static void run0() { for (int i0 = 1; i0 < 100; i0++) System.Console.WriteLine(".... thread0 = " + i0); Thread.Sleep(2); } static void Main(string[] args) { Console.WriteLine("Lancement des threads :"); AfficherDonnees obj = new AfficherDonnees( ); Thread thread0 = new Thread(new ThreadStart( run0 )); Thread thread1 = new Thread(new ThreadStart(AfficherDonnees.run1)); Thread thread2 = new Thread(new ThreadStart(obj.run2)); thread0.Start( ); thread1.Start( ); thread2.Start( ); for (int i = 1; i < 100; i++) System.Console.WriteLine(" i = " + i);
thread0.Abort();
System.Console.WriteLine("fin de tous les threads."); } } Rsultats de l'excution du programme prcdent avec Thread.Sleep(2) et thread0.Abort() : Lancement des threads : .... thread0 = 1 >>> thread1 = 1 i=1 *** thread2 = 1 . i = 98 *** thread2 = 98 .... thread0 = 79 >>> thread1 = 99 i = 99 *** thread2 = 99 .... thread0 = 80 fin de tous les threads. (Rsultats dpendants de votre configuration machine+OS)
Le thread0 a bien t arrt avant sa fin normale, avec comme dernire valeur 80 pour l'indice de la boucle for.
Attendre : Mthode Join ( )

Un thread peut se trouver dans des tats d'excution diffrents selon qu'il est actuellement en cours d'excution, qu'il attend, qu'il est arrt etc Il existe en C# un type numr ThreadState qui liste toutes les valeurs possibles des tats d'un thread : public enum ThreadState { Running = 0, StopRequested = 1, SuspendRequested = 2, Background = 4, Unstarted = 8, Stopped = 16, WaitSleepJoin = 32, Suspended = 64, AbortRequested = 128, Aborted = 256 } Dans la classe Thread, nous trouvons une proprit "public ThreadState ThreadState {get;}" en lecture seule qui fournit pour un thread donn son tat d'excution. En consultant cette proprit le dveloppeur peut connatre l'tat "en direct" du thread, notons que cet tat peut varier au cours du
- Rm di Scala
page
275
temps. On peut faire attendre la fin d'excution complte d'un thread pour qu'un autre puisse continuer son excution, cette attente est lance par l'une des trois surcharges de la mthode d'instance Join de la classe Thread : public void Join();
Dans le programme prcdent rappelons-nous que le thread0 prend du "retard" sur les autres car nous l'avons ralenti avec un Sleep(2). Au lieu de l'arrter dfinitivement avant la dernire instruction de la mthode Main remplaons l'instruction "thread0.Abort();"par l'instruction "thread0.Join();". Que se passe-t-il : Le thread principal qui excute la mthode main, invoque la mthode Join du thread0 avant de terminer son excution, ce qui signifie que le thread principal bloque tant que le thread0 n'a pas fini compltement son excution. Nous ajoutons au programme prcdent une mthode public static void etatsThreads qui affiche l'tat d'excution du thread principal et des 3 threads instancis :
public static void etatsThreads(Thread principal, Thread thrd1, Thread thrd2, Thread thrd3 ) { System.Console.WriteLine(principal.Name + " : " + principal.ThreadState); System.Console.WriteLine(thrd1.Name + " : " + thrd1.ThreadState); System.Console.WriteLine(thrd2.Name + " : " + thrd2.ThreadState); System.Console.WriteLine(thrd3.Name + " : " + thrd3.ThreadState); } static void Main(string[] args) { Console.WriteLine("Lancement des threads :"); AfficherDonnees obj = new AfficherDonnees(); Thread principal = Thread.CurrentThread; principal.Name = "principal"; Thread thread0 = new Thread(new ThreadStart(run0)); thread0.Name = "thread0"; Thread thread1 = new Thread(new ThreadStart(AfficherDonnees.run1)); thread1.Name = "thread1"; Thread thread2 = new Thread(new ThreadStart(obj.run2)); thread2.Name = "thread2"; etatsThreads(principal, thread0, thread1, thread2); thread0.Start(); thread1.Start(); thread2.Start(); etatsThreads(principal, thread0, thread1, thread2); for (int i = 1; i < 100; i++) { System.Console.WriteLine(" i = " + i); } etatsThreads(principal, thread0, thread1, thread2); thread0.Join(); etatsThreads(principal, thread0, thread1, thread2); System.Console.WriteLine("fin de tous les threads."); }
Nous obtenons une rfrence sur le thread principal par la proprit CurrentThread dans l'instruction : Thread principal = Thread.CurrentThread.
- Rm di Scala
page
276
Rsultats de l'excution du programme prcdent avec Thread.Sleep(2) et thread0.Join() : Lancement des threads principal : Running thread0 : Unstarted thread1 : Unstarted thread2 : Unstarted .... thread0 = 1 >>> thread1 = 1 principal : Running *** thread2 = 1 >>> thread1 = 2 .... thread0 = 2 thread0 : WaitSleepJoin *** thread2 = 2 >>> thread1 = 3 .... thread0 = 3 thread1 : WaitSleepJoin *** thread2 = 3 >>> thread1 = 4 thread2 : WaitSleepJoin .... thread0 = 4 *** thread2 = 4 >>> thread1 = 5 i=1 . i = 99 principal : Running .... thread0 = 85 thread0 : WaitSleepJoin thread1 : Stopped .... thread0 = 86 thread2 : Stopped .... thread0 = 87 .... thread0 = 88 .... thread0 = 89 .... thread0 = 90 .... thread0 = 91 .... thread0 = 92 .... thread0 = 93 .... thread0 = 94 .... thread0 = 95 .... thread0 = 96 .... thread0 = 97 .... thread0 = 98 .... thread0 = 99 principal : Running thread0 : Stopped thread1 : Stopped thread2 : Stopped fin de tous les threads. (Rsultats dpendants de votre configuration machine+OS)
Au dbut de l'excution les tats sont :

principal : Running thread0 : Unstarted thread1 : Unstarted thread2 : Unstarted
Seul le thread principal est en tat d'excution, les 3 autres nonencore dmarrs. Aprs invocation de la mthode Start de chaque thread, la tour revient au thread principal pour excuter la boucle for (int i = 1; i < 100; i++), les 3 autres threads sont dans la file d'attente :
principal : Running thread0 : WaitSleepJoin thread1 : WaitSleepJoin thread2 : WaitSleepJoin
Aprs la fin de l'excution de la boucle for (int i = 1; i < 100; i++) du thread principal celui-ci est sur le point de s'arrter, les thread1 et thread2 ont fini leur excution, le thread0 continue son excution car ralenti par le Sleep(2) chaque tour de boucle :
principal : Running thread0 : WaitSleepJoin thread1 : Stopped thread2 : Stopped
Aprs la terminaison du dcompte de la boucle du thread0 jusqu' la valeur 99, le thread0 se termine et le thread principal est sur le point de se terminer (il ne lui reste plus la dernire instruction d'affichage " System.Console.WriteLine("fin de tous les threads.")" excuter) :
- Rm di Scala
page
277
principal : Running thread0 : Stopped thread1 : Stopped thread2 : Stopped fin de tous les threads.
Interrompre-rveiller : Mthode Interrupt ( )

Si le thread est dans l'tat WaitSleepJoin c'est dire soit endormi (Sleep), soit dans la file d'attente attendant son tour (Wait), soit en attente de la fin d'un autre thread (Join), il est alors possible d'interrompre son tat d'attente grce la mthode Interrupt. Cette mthode interrompt temporairement le thread qui l'invoque et lance une exception du type ThreadInterruptedException. Dans le programme prcdent nous ajoutons l'instruction "thread0.Interrupt()" dans la mthode Main, juste aprs la fin de la boucle for (int i = 1; i < 100; i++) {}. Lors de l'excution, ds que le thread0 se met en mode WaitSleepJoin par invocation de la mthode Sleep(2), il est interrompu :
Une exception ThreadInterruptedException a bien t lance et peut tre intercepte dans le thread principal. Nous listons ci-dessous le code source de la mthode Main produisant l'interruption du thread0 figure prcdemment :
- Rm di Scala
page
278
static void Main(string[] args) { Console.WriteLine("Lancement des threads :"); AfficherDonnees obj = new AfficherDonnees(); Thread principal = Thread.CurrentThread; principal.Name = "principal"; Thread thread0 = new Thread(new ThreadStart(run0)); thread0.Name = "thread0"; Thread thread1 = new Thread(new ThreadStart(AfficherDonnees.run1)); thread1.Name = "thread1"; Thread thread2 = new Thread(new ThreadStart(obj.run2)); thread2.Name = "thread2"; etatsThreads(principal, thread0, thread1, thread2); thread0.Start(); thread1.Start(); thread2.Start(); etatsThreads(principal, thread0, thread1, thread2); for (int i = 1; i < 100; i++) { System.Console.WriteLine(" i = " + i); } thread0.Interrupt(); etatsThreads(principal, thread0, thread1, thread2); thread0.Join(); etatsThreads(principal, thread0, thread1, thread2); System.Console.WriteLine("fin de tous les threads."); }
Attention : La rapidit du processeur, linfluence du CLR et la charge instantane du systme changent considrablement les rsultats obtenus ! Il faut donc nutiliser ces outils que pour du paralllisme rel et non pour du squentiel (cf. la notion de synchronisation paragraphe suivant)
3.3 Exclusion mutuelle, concurrence, section critique, et synchronisation
ressource partage
D'un point de vue gnral, plusieurs processus peuvent accder en lecture et en criture un mme espace mmoire par exemple : accder un spooler d'imprimante, rserver une page en mmoire centrale, etcCet espace mmoire partag par plusieurs processus se dnomme une ressource partage.
concurrence
Lorsque le rsultat final aprs excution des processus l'intrieur sur une ressource partage n'est pas dterministe, mais dpend de l'ordre dans lequel le systme d'exploitation a procd l'excution de chacun des processus, on dit que l'on est en situation de concurrence.
synchronisation
Lorsqu'une structure de donnes est accde par des processus en situation de concurrence, il est impossible de prvoir le comportement des threads sur cette structure. Si l'on veut obtenir un comportement dterministe, il faut ordonner les excutions des processus d'une manire squentielle afin d'tre sr qu'un seul processus accde toute la structure jusqu' la fin de son excution , puis laisse la main au processus suivant etc. Cet rgulation des excutions des processus s'appelle la synchronisation.
Exclusion mutuelle
- Rm di Scala
page
279
Lorsque plusieurs processus travaillent sur une ressource partage, la synchronisation entre les divers processus sous-entend que cette ressource partage est exclusivement la disposition d'un processus pendant sa dure complte d'excution. Le mcanisme qui permet un seul processus de s'excuter sur une ressource partage l'exclusion de tout autre, se dnomme l'exclusion mutuelle.
section critique
Lorsqu'un bloc de lignes de code traite d'accs par threads synchroniss une ressource partage on dnomme ce bloc de code une section critique.
Tout ce que nous venons de voir sur les processus se reporte intgralement aux threads qui sont des processus lgers. Dans un systme d'exploitation de multiprogrammation, ces situations de concurrence sont trs courantes et depuis les annes 60, les informaticiens ont mis en uvre un arsenal de rponses d'exclusion mutuelle ; ces rponses sont fondes sur les notions de verrous, smaphores, mutex, moniteurs. Le dveloppeur peut avoir besoin dans ses programmes de grer des situations de concurrence comme par exemple dans un programme de rservation de place de train et d'dition de billet de transport voyageur. Le multi-threading et les outils de synchronisation que le langage de programmation fournira seront une aide trs prcieuse au dveloppeur dans ce style de programmation. Pour programmer de la synchronisation entre threads, le langage C# met la disposition du dveloppeur les notions de verrous, smaphores, mutex, moniteurs.
3.4 Section critique en C# : lock
L'instruction lock () { . }
Le mot clef lock dtermine un bloc d'instructions en tant que section critique. Le verrouillage de cette section critique est obtenu par exclusion mutuelle sur un objet spcifique nomm verrou qui peut tre dans deux tats : soit disponible ou libre, soit vrouill. Ci-dessous la syntaxe C# de l'instruction lock : object verrou = new object(); lock ( verrou ) { lignes de code de la section critique } Lorsqu'un thread Th1 veut entrer dans la section critique dlimite par lock, nous sommes en face de deux possibilits selon que l'objet verrou est libre ou non : Si l'objet verrou est libre (c'est dire qu'aucun autre thread n'excute le code de la section critique) alors on dit que le thread Th1 acquiert le verrou, d'autre part il le verrouille pour tout autre thread. Ds que le thread Th1 finit d'excuter la dernire instruction de la section critique, il libre le verrou qui devient disponible pour un autre thread.
- Rm di Scala
page
280
Si l'objet verrou n'est pas libre et qu'un thread Th2 demande acqurir ce verrou (veut entrer dans la section critique) pendant que Th1 est dans la section critique, le thread Th2 est alors mis dans la file d'attente associe l'objet verrou par le CLR (le thread est donc bloqu en attente). Chaque nouveau thread demandant acqurir ce verrou est rang dans la file d'attente du verrou tant que ce dernier n'est pas libr. Ds que le verrou devient libre le CLR autorise le thread en tte de file acqurir le verrou et ce thread est retir de la file d'attente des threads du verrou. Si une exception est leve dans la section critique, le verrou est automatiquement libr par l'instruction lock pour ce thread. Exemple C# de synchronisation avec lock : 1) Partons d'un exemple o le fait qu'il n'y ait pas de synchronisation provoque un comportement erratique. Soit un tableau d'entiers "int[ ] datas = new int[50]" tous la valeur 1, nous construisons trois threads modifiant ce tableau, le premier rajoute 1 chaque cellule du tableau, le second multiplie par 2 le contenu de chaque cellule du tableau, le troisime soustrait 1 chaque cellule du tableau. Nous crons une classe ThreadModifierDonnees dont la vocation est de permettre des dlgus, qui nous donnerons un nom lors de leur instanciation, de travailler sur le tableau d'entiers travers une mthode run(). Dans cette classe ThreadModifierDonnees la mthode run( ) effectue une action diffrente selon le nom du dlgu qui l'invoque (ajouter 1, multiplier par 2, soustraire 1). Afin de souligner la concurrence entre les 3 threads nous dsquilibrons les temps allous aux threads par un endormissement diffrent pour le thread1 (Thread.Sleep(1);) et pour le thread2 (Thread.Sleep(0) ;), le thread3 restant indemne de toute modification temporelle :
public class ThreadModifierDonnees { private int[ ] donnees; private string nom; public ThreadModifierDonnees(int[ ] donnees, string nom) { this.donnees = donnees; this.nom = nom; } public void run( ) { for (int i = 0; i < donnees.Length; i++) { if (nom == "modif1") { donnees[i] += 1; Thread.Sleep(1); } else if (nom == "modif2") { donnees[i] *= 2; Thread.Sleep(0); } else if (nom == "modif3") donnees[i] -= 1; Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
281
} } } public class Program { public static int[ ] datas = new int[50]; public static void afficherDatas() { for (int i = 0; i < datas.Length; i++) Console.Write(datas[i]); Console.WriteLine(); } public static void initDatas() { for (int i = 0; i < 50; i++) datas[i]=1; } static void Main(string[] args) { initDatas(); ThreadModifierDonnees modif_1 = new ThreadModifierDonnees(datas,"modif1"); ThreadModifierDonnees modif_2 = new ThreadModifierDonnees(datas,"modif2"); ThreadModifierDonnees modif_3 = new ThreadModifierDonnees(datas, "modif3"); afficherDatas(); Thread thread1 = new Thread(new ThreadStart(modif_1.run)); Thread thread2 = new Thread(new ThreadStart(modif_2.run)); Thread thread3 = new Thread(new ThreadStart(modif_3.run)); thread1.Start(); thread2.Start(); thread3.Start(); afficherDatas(); System.Console.ReadLine(); } }
La mthode initDatas() rempli de 1 le tableau datas, la mthode afficherDatas affiche le contenu des 50 cellules du tableau datas. Aprs avoir lanc les 3 threads nous affichons afficherDatas affiche de nouveau le contenu des 50 cellules du tableau datas. En relanant plusieurs fois le programme nous obtenons des rsultats diffrents (qui peuvent aussi diffrer dune machine lautre) ds au fait que les threads ne sont pas synchroniss sur la boucle for de la mthode run :
Excution : (Rsultats dpendants de votre configuration machine+OS) 11111111111111111111111111111111111111111111111111 33222222211111111111111111111111111111111111111111 Autre excution : (Rsultats dpendants de votre configuration machine+OS) 11111111111111111111111111111111111111111111111111 33222222222211111111111111111111111111111111111111 Autre excution : (Rsultats dpendants de votre configuration machine+OS) 11111111111111111111111111111111111111111111111111 33222221111111111111111111111111111111111111111111 etc
2) A l'vidence, les rsultats ne sont pas fiables puisqu'ils dpendent du temps et de la charge du
- Rm di Scala
page
282
systme, donc ce programme n'est pas valide. Afin de remdier cet inconvnient majeur nous utilisons un verouillage de la boucle for dans la mthode run et nous dclarons un verrou de type object dans la classe ThreadModifierDonnees. L'objet verrou est static afin que ce soit le mme objet pour toutes les instances de telle sorte que les threads consulteront le mme verrou :
public class ThreadModifierDonnees { private int[] donnees; private string nom; private static object verrou = new object(); public ThreadModifierDonnees(int[] donnees, string nom) { this.donnees = donnees; this.nom = nom; } public void run() { lock (verrou) { for (int i = 0; i < donnees.Length; i++) { if (nom == "modif1") { donnees[i] += 1; Thread.Sleep(1); } else if (nom == "modif2") { donnees[i] *= 2; Thread.Sleep(0); } else if (nom == "modif3") { donnees[i] -= 1; } } } } }
Le code de la classe Program reste identique, et les rsultats de l'excution sont dterministes et dirigs uniquement par l'ordre squentiel de lancement des 3 threads
1) Pour l'ordre de lancement des threads suivant : thread1.Start(); thread2.Start(); thread3.Start(); Rsultats d'excution pour l'ordre de lancement 1,2,3 : 11111111111111111111111111111111111111111111111111 33333333333333333333333333333333333333333333333333 2) Pour l'ordre de lancement des threads suivant: thread2.Start(); thread1.Start(); Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
283
thread3.Start(); Rsultats d'excution pour l'ordre de lancement 2,1,3 : 11111111111111111111111111111111111111111111111111 22222222222222222222222222222222222222222222222222
3) Pour l'ordre de lancement des threads suivant: thread3.Start(); thread2.Start(); thread1.Start(); Rsultats d'excution pour l'ordre de lancement 3,2,1 : 11111111111111111111111111111111111111111111111111 11111111111111111111111111111111111111111111111111 Si le thread prinicipal va trop vite on lui demande dattendre la fin de lexcution des 3 autres threads avant quil excute la mthode afficherDatas() thread1.Join(); // on attend que ce thread ait termin la totalit de son excution thread2.Join(); // on attend que ce thread ait termin la totalit de son excution thread3.Join(); // on attend que ce thread ait termin la totalit de son excution afficherDatas();
3.5 Section critique en C# : Monitor
La classe Monitor
Cette classe fournit un moyen gnral de synchroniser les accs un objet en C#. Elle est abstraite public sealed abstract class Monitor Elle contient des mthodes permettant un thread de travailler plus finement sur une section critique que l'instruction lock. Voici trois mthodes static de la classe Monitor permettant un thread : D'acqurir un verrou : public static void Enter(object obj); De librer un verrou : public static void Exit(object obj); D'essayer d'aqurir un verrou : public static bool TryEnter(object obj); Les mthodes Enter et Exit permettent de dlimiter une section critique : object verrou = new object(); Monitor.Enter ( verrou ) ; lignes de code de la section critique Monitor.Exit ( verrou ) ; La mthode TryEnter permet un thread de consulter l'tat d'un verrou et dans l'ventualit o ce verrou est verrouill, si le dveloppeur le souhaite, de ne pas mettre immdiatement le thread dans la file d'attente du verrou, mais d'effectuer d'autres actions. Ci-dessous un pseudo-code C# dans lequel le thread qui excute la mthode2() teste l'tat du verrou avant de rentrer dans la section critique contenue dans la mthode1() ou bien effectue d'autres actions si cette section critique est
- Rm di Scala
page
284
occupe par un autre thread : private object verrou = new object(); public void methode1() { Monitor.Enter ( verrou ) ; lignes de code de la section critique Monitor.Exit ( verrou ) ; } . public void methode2() { if (Monitor.TryEnter ( verrou ) methode1( ); else Autres actions } Dans le cas o une exception serait leve dans une section critique le verrou n'est pas automatiquement lev comme avec l'instruction lock(){}, Microsoft conseille au dveloppeur de protger son code par un tryfinally. Voici le code minimal permettant d'assurer cette protection semblablement un lock : object verrou = new object(); Monitor.Enter ( verrou ) ; try { lignes de code de la section critique } finally { Monitor.Exit ( verrou ) ; } Dans l'exemple prcdent de section critique mettant jour les 50 cellules d'un tableau d'entiers, nous remplaons l'instruction lock par un appel aux mthodes static Enter et Exit de la classe Monitor sans protection du code :
public class ThreadModifierDonnees { private int[] donnees; private string nom; private static object verrou = new object(); public ThreadModifierDonnees(int[] donnees, string nom) { this.donnees = donnees; this.nom = nom; } public void run() {
Monitor.Enter ( verrou ) ;
- Rm di Scala
page
285
for (int i = 0; i < donnees.Length; i++) { if (nom == "modif1") { donnees[i] += 1; Thread.Sleep(1); } else if (nom == "modif2") { donnees[i] *= 2; Thread.Sleep(0); } else if (nom == "modif3") { donnees[i] -= 1; } }
Monitor.Exit ( verrou ) ;
} }
Mme programme avec appel aux mthodes static Enter et Exit de la classe Monitor et protection du code par tryfinally dans la mthode run( ):
public void run() {
Monitor.Enter ( verrou ) ;
try { for (int i = 0; i < donnees.Length; i++) { if (nom == "modif1") { donnees[i] += 1; Thread.Sleep(1); } else if (nom == "modif2") { donnees[i] *= 2; Thread.Sleep(0); } else if (nom == "modif3") { donnees[i] -= 1; } } } finally { Monitor.Exit ( verrou ) ; } }
3.6 Synchronisation commune aux processsus et aux threads Il existe dans la version C# 2.0 deux classes permettant de travailler aussi bien avec des threads qu'avec des processus.
- Rm di Scala
page
286
La classe Semaphore
public sealed class Semaphore : WaitHandle Semaphore est une classe ddie l'accs une ressource partage non pas par un seul thread mais par un nombre dtermin de threads lors de la cration du smaphore travers son constructeur dont nous donnons une surcharge : public Semaphore ( int initialCount, int maximumCount ); initialCount = le nombre de thread autoriss possder le smaphore en plus du thread principal, la valeur 0 indique que seul le thread principal possde le spmaphore au dpart. MaximumCount = le nombre maximal de thread autoriss possder le smaphore.
Pour essayer de simuler une section critique accessible par un seul thread la fois par la notion de verrou, il faut instancier un smaphore avec un maximumCount = 1 et utiliser les mthodes WaitOne et Release de la classe Semaphore : Semaphore verrou = new Semaphore (0, 1); verrou.WaitOne ( ); lignes de code de la section critique verrou.Release ( ); Toutefois l'utilisation d'un smaphore mme avec maximumCount = 1 ne permet pas d'ordonnancer les accs la section critique, dans ce cas le smaphore sert seulement assurer qu'une section critique est accde entirement par un seul thread. Illustrons ce propos avec notre exemple de code partag mettant jour les 50 cellules d'un tableau d'entiers. Nous crons un smaphore public static dans la classe ThreadModifierDonnees que nous nommons verrou, nous supprimons les endormissements Sleep(), nous instancions le smaphore Semaphore verrou = new Semaphore (0, 1), enfin nous encadrons la section critique par les appels des mthodes WaitOne et Release :
public class ThreadModifierDonnees { private int[] donnees; private string nom; public static Semaphore verrou = new Semaphore ( 0, 1 ); public ThreadModifierDonnees(int[] donnees, string nom) { this.donnees = donnees; this.nom = nom; } public void run() { verrou.WaitOne( ); for (int i = 0; i < donnees.Length; i++) { if (nom == "modif1") Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
287
{ donnees[i] += 1; Thread.Sleep(1); } else if (nom == "modif2") { donnees[i] *= 2; Thread.Sleep(0); } else if (nom == "modif3") { donnees[i] -= 1; } } verrou.Release( ); } }
Dans la mthode Main de la classe Program, par construction du smaphore c'est le thread principal qui possde le smaphore verrou, on fait librer ce smaphore par le thread principal par l'instruction "ThreadModifierDonnees.verrou.Release(1)" qui a vocation autoriser un des 3 threads thread1, thread2 ou thread3 entrer dans la section critique :
static void Main(string[] args) { initDatas(); ThreadModifierDonnees modif_1 = new ThreadModifierDonnees(datas,"modif1"); ThreadModifierDonnees modif_2 = new ThreadModifierDonnees(datas,"modif2"); ThreadModifierDonnees modif_3 = new ThreadModifierDonnees(datas, "modif3"); afficherDatas(); Thread thread1 = new Thread(new ThreadStart(modif_1.run)); Thread thread2 = new Thread(new ThreadStart(modif_2.run)); Thread thread3 = new Thread(new ThreadStart(modif_3.run)); thread1.Start(); thread2.Start(); thread3.Start(); ThreadModifierDonnees.verrou.Release ( 1 ); afficherDatas(); System.Console.ReadLine(); } }
Le rsultat obtenu est identique celui que nous avions obtenu avec lock ou Monitor :
Pour l'ordre de lancement des threads suivant : thread1.Start(); thread2.Start(); thread3.Start(); Rsultats d'excution : 11111111111111111111111111111111111111111111111111 33333333333333333333333333333333333333333333333333
Il ne faut pas s'y mprendre, si l'on change l'ordre de lancement on a toujours l'accs garanti par le smaphore la section critique par un seul thread, mais l'ordre d'accs squentiel n'est pas garanti :
- Rm di Scala
page
288
1) Pour l'ordre de lancement des threads suivant: thread2.Start(); thread1.Start(); thread3.Start(); Rsultats d'excution : 11111111111111111111111111111111111111111111111111 33333333333333333333333333333333333333333333333333 2) Pour l'ordre de lancement des threads suivant: thread3.Start(); thread2.Start(); thread1.Start(); Rsultats d'excution : 11111111111111111111111111111111111111111111111111 22222222222222222222222222222222222222222222222222
La classe Mutex
public sealed class Mutex : WaitHandle Mutex est une classe ddie la synchronisation entre processus ou entre threads. Elle permet un accs exclusif une ressource partage en situation de concurrence : elle autorise un accs exclusif cette ressource par un seul thread ou processus. Si un thread ou processus acquiert un mutex, l'autre thread ou processus qui veut acqurir ce mutex est interrompu jusqu' ce que le premier thread ou processus libre le mutex. Elle fonctionne comme un smaphore un seul thread autoris. Les mthodes intressantes pour grer une section critique sont semblables celle de la classe Semaphore, on peut considrer la classe Mutex comme une simplification de la classe Semaphore dans le cas d'un seul thread ou d'un seul processus qui accde la section critique. Elle possde toutefois l'avantage sur la classe Semaphore de permettre de grer l'ordre d'accs squentiel la section critique. On utilise les mthodes WaitOne et ReleaseMutex de la classe Mutex: Semaphore verrou = new Mutex ( ); verrou.WaitOne ( ); lignes de code de la section critique verrou.ReleaseMutex ( ); Ci-dessous le code de la classe ThreadModifierDonnees avec un mutex public que nous nommons verrou, nous avons aussi supprim les endormissements Sleep(), et nous encadrons la section critique par les appels des mthodes WaitOne et ReleaseMutex :
public class ThreadModifierDonnees { private int[] donnees; private string nom; Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
289
public static Mutex verrou = new Mutex ( ); public ThreadModifierDonnees(int[] donnees, string nom) { this.donnees = donnees; this.nom = nom; } public void run() { verrou.WaitOne( ); for (int i = 0; i < donnees.Length; i++) { if (nom == "modif1") { donnees[i] += 1; Thread.Sleep(1); } else if (nom == "modif2") { donnees[i] *= 2; Thread.Sleep(0); } else if (nom == "modif3") { donnees[i] -= 1; } } verrou.ReleaseMutex( ); } }
Nous retrouvons dans la mthode Main de la classe Program, un code identique celui correspondant une utilisation d'un lock ou d'un Monitor :
static void Main(string[] args) { initDatas(); ThreadModifierDonnees modif_1 = new ThreadModifierDonnees(datas,"modif1"); ThreadModifierDonnees modif_2 = new ThreadModifierDonnees(datas,"modif2"); ThreadModifierDonnees modif_3 = new ThreadModifierDonnees(datas, "modif3"); afficherDatas(); Thread thread1 = new Thread(new ThreadStart(modif_1.run)); Thread thread2 = new Thread(new ThreadStart(modif_2.run)); Thread thread3 = new Thread(new ThreadStart(modif_3.run)); thread1.Start(); thread2.Start(); thread3.Start(); afficherDatas(); System.Console.ReadLine(); } }
Nous donnons les rsultats obtenus selon l'odre de lancement des thread :
1) Pour l'ordre de lancement des threads suivant : thread1.Start(); thread2.Start(); thread3.Start(); Programmer objet .Net avec C# - ( rv. 17.10..2007 )
- Rm di Scala
page
290
Rsultats d'excution : 11111111111111111111111111111111111111111111111111 33333333333333333333333333333333333333333333333333 2) Pour l'ordre de lancement des threads suivant: thread2.Start(); thread1.Start(); thread3.Start(); Rsultats d'excution : 11111111111111111111111111111111111111111111111111 22222222222222222222222222222222222222222222222222
3) Pour l'ordre de lancement des threads suivant: thread3.Start(); thread2.Start(); thread1.Start(); Rsultats d'excution : 11111111111111111111111111111111111111111111111111 11111111111111111111111111111111111111111111111111
Ces rsultats sont identiques ceux que l'on obtient en utilisant un lock. En conclusion, l'instruction lock s'avre tre la plus souple et la plus simple utiliser pour dfinir une section critique et pour assurer une synchronisation efficace des threads sur cette section critique.
- Rm di Scala
page
291

Csharp Part 2

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Csharp Part 2

Transféré par

Droits d'auteur :

Formats disponibles

Un langage trs orient objet

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Classes, objets et mthodes

1. Les classes C# : des nouveaux types

2. Les objets : des rfrences ou des valeurs

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

inclues dans le mme assembly.

1. Les classes : des nouveaux types

// les dclarations et implmentation des classes

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Tableau des possibilits fourni par microsoft :

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Par dfaut la classe ApplicationClasse6 est ici private.

Un programme utilisant la classe ApplicationClasses : C# Explication

namespace Exemple { class AppliTestClasses { ApplicationClasses.ApplicationClasse2 a2; } }

Seule la classe interne ApplicationClasse2 est visible et permet d'instancier un objet.

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

C# dans le mme namespace

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Doit obligatoirement tre redfinie dans une classe fille.

Comparaison de dclaration d'abstraction de mthode en Delphi et C# : Delphi

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Rappel classes abstraites-interfaces

C# mthode virtuelle corps vide

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Java mthode virtuelle corps vide

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

2. Les objets : des rfrences ou des valeurs

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Situation aprs l'affectation " x = y "

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Exemple de constructeur avec instructions : C# class Un { public Un ( ) { a = 100 } int a; } Explication

Soit le dernier constructeur : public Un (int x , float y ) : this(y)

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

{ a = 100; } public Un (float b ) { a = (int)b; } public Un (int x , float y ) : this(y) { a += 100; } }

Dtaillons les instructions

Que se passe-t-il l'excution ?

x.a =12; System.Console.WriteLine("x.a="+x.a); System.Console.WriteLine("y.a="+y.a);

Comparaison Delphi - C# sur cet exemple (similitude complte) Delphi

Cas o le this sert outrepasser le masquage de visibilit : C#

Comparaison Delphi - C# sur ce second exemple (similitude complte aussi)

C# class Un { int a; public void methode(float a) { a = this.a + 7 ; } }

int b =15; a =.... ..... } }

struct AppliIn stance { int x ; int y ; }

Voici une image du segment de mmoire associ ces 3 objets :

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

class UtiliseApplistaticVar { int a ; void f( ) { a = ApplistaticVar.x ; ..... } }

Rsum pratique sur les membres de classe en C#

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Rappel des notions de base Polymorphisme d'objet en C# : dfinitions

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

1.1 instanciation dans le type initial et utilisation dans le mme type

Programmer objet .Net avec C# - ( rv. 17.10..2007 )

1.2 Polymorphisme d'objet implicite

Programmer objet .Net avec C# - ( rv. 17.10..2007 )