Académique Documents
Professionnel Documents
Culture Documents
Cours Csharp PDF
Cours Csharp PDF
Avec la plate-forme .NET, trois nouveaux langages sont apparus : C#, VB.VET, JSCRIPT.NET. C# est largement une copie de
Java. VB.NET et JSCRIPT.NET sont des extensions de Visual basic et Jscript pour la plate-forme .NET. Celle-ci rend disponible
aux programmes qui sexcutent en son sein un ensemble trs important de classes, classes trs proches de celles que lon trouve au
sein des machines virtuelles Java. En premire approximation, on peut dire que la plate-forme .NET est un environnement
dexcution analogue une machine virtuelle Java. On peut noter cependant deux diffrences importantes :
la plate-forme .NET ne s'excute que sur les machines Windows alors que Java s'excute sur diffrents OS (windows,
unix, macintosh).
la plate-forme .NET permet l'excution de programmes crits en diffrents langages. Il suffit que le compilateur de ceux-ci
sache produire du code IL (Intermediate Language), code excut par la machine virtuelle .NET. Toutes les classes de
.NET sont disponibles aux langages compatibles .NET ce qui tend gommer les diffrences entre langages dans la mesure
o les programmes utilisent largement ces classes. Le choix d'un langage .NET devient affaire de got plus que de
performances.
De la mme faon que Java ne peut tre ignor, la plate-forme .NET ne peut l'tre, la fois cause du parc trs important de
machines windows installes et de l'effort fait par Microsoft pour la promouvoir et l'imposer. Il semble que C# soit un bon choix
pour dmarrer avec .NET, notamment pour les programmeurs Java, tellement ces deux langages sont proches. Ensuite on pourra
passer aisment de C# VB.NET ou un autre langage .NET. La syntaxe changera mais les classes .NET resteront les mmes.
Contrairement aux apparences, le passage de VB VB.NET est difficile. VB n'est pas un langage orient objets alors que VB.NET
l'est compltement. Le programmeur VB va donc tre confront des concepts qu'il ne matrise pas. Il parat plus simple
d'affronter ceux-ci avec un langage entirement nouveau tel que C# plutt qu'avec VB.NET o le programmeur VB aura toujours
tendance vouloir revenir ses habitudes VB.
Ce document n'est pas un cours exhaustif. Il est destin des gens connaissant dj la programmation et qui veulent dcouvrir C#.
Afin de faciliter la comparaison avec Java, il reprend la structure du document "Introduction au langage Java" du mme auteur.
1.1 INTRODUCTION 7
1.2 LES DONNEES DE C# 7
1.2.1 LES TYPES DE DONNEES PREDEFINIS 7
1.2.2 CONVERSION ENTRE TYPES SIMPLES ET TYPES OBJETS 8
1.2.3 NOTATION DES DONNEES LITTERALES 8
1.2.4 DECLARATION DES DONNEES 8
1.2.5 LES CONVERSIONS ENTRE NOMBRES ET CHAINES DE CARACTERES 9
1.2.6 LES TABLEAUX DE DONNEES 10
1.3 LES INSTRUCTIONS ELEMENTAIRES DE C# 12
1.3.1 ECRITURE SUR ECRAN 12
1.3.2 LECTURE DE DONNEES TAPEES AU CLAVIER 13
1.3.3 EXEMPLE D'ENTREES-SORTIES 13
1.3.4 REDIRECTION DES E/S 13
1.3.5 AFFECTATION DE LA VALEUR D'UNE EXPRESSION A UNE VARIABLE 14
1.4 LES INSTRUCTIONS DE CONTROLE DU DEROULEMENT DU PROGRAMME 20
1.4.1 ARRET 20
1.4.2 STRUCTURE DE CHOIX SIMPLE 20
1.4.3 STRUCTURE DE CAS 21
1.4.4 STRUCTURE DE REPETITION 21
1.5 LA STRUCTURE D'UN PROGRAMME C# 24
1.6 COMPILATION ET EXECUTION D'UN PROGRAMME C# 24
1.7 L'EXEMPLE IMPOTS 24
1.8 ARGUMENTS DU PROGRAMME PRINCIPAL 26
1.9 LES ENUMERATIONS 27
1.10 LA GESTION DES EXCEPTIONS 28
1.11 PASSAGE DE PARAMETRES A UNE FONCTION 31
1.11.1 PASSAGE PAR VALEUR 31
1.11.2 PASSAGE PAR REFERENCE 31
1.11.3 PASSAGE PAR REFERENCE AVEC LE MOT CLE OUT 32
- des donnes
- les instructions qui les manipulent
+--------------------+
DONNEES
+--------------------
INSTRUCTIONS
+--------------------+
int Int32
long Int64
decimal Decimal
bool Boolean
char Char
byte Byte
float Float
double Double
enum Enum
On notera les deux chanes littrales : "c:\\chap1\\paragraph3" et @"c:\chap1\paragraph3". Dans les chanes littrales, le caractre \
est interprt. Ainsi "\n" reprsente la marque de fin de ligne et non la succession des deux caractres \ et n. Si on voulait cette
succession, il faudrait crire "\\n" o la squence \\ est remplace par un seul \ non interprt. On pourrait crire aussi @"\n"
pour avoir le mme rsultat. La syntaxe @"texte" demande que texte soit pris exactement comme il est crit. On appelle parfois cela
une chane verbatim.
Les bases de C# 8
Pourquoi dclarer des constantes ?
1. La lecture du programme sera plus aise si l'on a donn la constante un nom significatif :
2. La modification du programme sera plus aise si la "constante" vient changer. Ainsi dans le cas prcdent, si le taux de tva
passe 33%, la seule modification faire sera de modifier l'instruction dfinissant sa valeur :
Si l'on avait utilis 0.186 explicitement dans le programme, ce serait alors de nombreuses instructions qu'il faudrait modifier.
Les variables peuvent tre initialises lors de leur dclaration. La syntaxe de dclaration d'une ou plusieurs variables est :
identificateur_de_type variable1,variable2,...,variablen;
La conversion d'une chane vers un nombre peut chouer si la chane ne reprsente pas un nombre valide. Il y a alors gnration
d'une erreur fatale appele exception en C#. Cette erreur peut tre gre par la clause try/catch suivante :
try{
appel de la fonction susceptible de gnrer l'exception
} catch (Exception e){
traiter l'exception e
}
instruction suivante
Si la fonction ne gnre pas d'exception, on passe alors instruction suivante, sinon on passe dans le corps de la clause catch puis
instruction suivante. Nous reviendrons ultrieurement sur la gestion des exceptions. Voici un programme prsentant les
principales techniques de conversion entre nombres et chanes de caractres. Dans cet exemple la fonction affiche crit l'cran la
valeur de son paramtre. Ainsi affiche(S) crit la valeur de S l'cran.
// la classe de test
public class conv1{
S=10
S=100000
S=45.78
S=-14.98
S=False
S=10
S=Erreur The input string was not in a correct format.
S=100
S=Erreur The input string was not in a correct format.
S=100.87
S=Erreur The input string was not in a correct format.
S=100.87
S=Erreur The input string was not in a correct format.
On remarquera que les nombres rels sous forme de chane de caractres doivent utiliser la virgule et non le point dcimal. Ainsi on
crira
Les bases de C# 10
Un tableau C# est un objet permettant de rassembler sous un mme identificateur des donnes de mme type. Sa dclaration est la
suivante :
n est le nombre de donnes que peut contenir le tableau. La syntaxe Tableau[i] dsigne la donne n i o i appartient l'intervalle
[0,n-1]. Toute rfrence la donne Tableau[i] o i n'appartient pas l'intervalle [0,n-1] provoquera une exception. Un tableau peut
tre initialis en mme temps que dclar :
Les tableaux ont une proprit Length qui est le nombre d'lments du tableau. Un tableau deux dimensions pourra tre dclar
comme suit :
o n est le nombre de lignes, m le nombre de colonnes. La syntaxe Tableau[i,j] dsigne l'lment j de la ligne i de Tableau. Le tableau
deux dimensions peut lui aussi tre initialis en mme temps qu'il est dclar :
Le nombre d'lments dans chacune des dimensions peut tre obtenue par la mthode GetLenth(i) o i=0 reprsente la dimension
correspondant au 1er indice, i=1 la dimension correspondant au 2ime indice, Un tableau de tableaux est dclar comme suit :
La dclaration ci-dessus cre un tableau de n lignes. Chaque lment Tableau[i] est une rfrence de tableau une dimension. Ces
tableaux ne sont pas crs lors de la dclaration ci-dessus. L'exemple ci-dessous illustre la cration d'un tableau de tableaux :
// un tableau de tableaux
string[][] noms=new string[3][];
for (int i=0;i<noms.Length;i++){
noms[i]=new string[i+1];
}//for
// initialisation
for (int i=0;i<noms.Length;i++){
for(int j=0;j<noms[i].Length;j++){
noms[i][j]="nom"+i+j;
}//for j
}//for i
Ici noms[i] est un tableau de i+1 lments. Comme noms[i] est un tableau, noms[i].Length est son nombre d'lments. Voici un
exemple regroupant les trois types de tableaux que nous venons de prsenter :
// tableaux
using System;
// classe de test
public class test{
public static void Main(){
// un tableau 1 dimension initialis
int[] entiers=new int[] {0,10,20,30};
for (int i=0;i<entiers.Length;i++){
Console.Out.WriteLine("entiers["+i+"]="+entiers[i]);
}//for
}//Main
}//class
entiers[0]=0
entiers[1]=10
entiers[2]=20
entiers[3]=30
rels[0,0]=0.5
rels[0,1]=1.7
rels[1,0]=8.4
rels[1,1]=-6
noms[0][0]=nom00
noms[1][0]=nom10
noms[1][1]=nom11
noms[2][0]=nom20
noms[2][1]=nom21
noms[2][2]=nom22
Les instructions lmentaires apparaissent clairement lorsqu'on considre la structure d'un micro-ordinateur et de ses priphriques.
U. C MEMOIRE ECRAN
+-------------------+ +-------+
2 <-+--> 3
+-----------+ 1 ----+------+->
CLAVIER +-----------+--------+-->
+-----------+ +-------------------+ +-------+
4^
\
\ 5 +-------+
\ ---->
DISQUE
+-------+
Console.Out.WriteLine(expression)
Console.WriteLine(expression)
Console.Error.WriteLine (expression)
o expression est tout type de donne qui puisse tre converti en chane de caractres pour tre affich l'cran. Dans les exemples
vus jusqu'ici, nous n'avons utilis que l'instruction Console.Out.WriteLine(expression).
La classe System.Console donne accs aux oprations d'criture cran (Write, WriteLine). La classe Console a deux proprits Out et
Error qui sont des flux d'criture de type StreamWriter :
Console.WriteLine() est quivalent Console.Out.WriteLine() et crit sur le flux Out associ habituellement l'cran.
Les bases de C# 12
Console.Error.WriteLine() crit sur le flux Error, habituellement associ lui aussi l'cran.
Les flux Out et Error sont associs par dfaut l'cran. Mais ils peuvent tre redirigs vers des fichiers texte au moment de l'excution
du programme comme nous le verrons prochainement.
La ligne tape au clavier est range dans la variable ligne et peut ensuite tre exploite par le programme.Le flux In peut tre redirig
vers un fichier comme les flux Out et Error.
using System;
public class io1{
System.Object
i=10
Tapez une ligne : je suis l
ligne=je suis l
Les instructions
ont pour but de montrer que n'importe quel objet peut faire l'objet d'un affichage. Nous ne chercherons pas ici expliquer la
signification de ce qui est affich.
En C#, le flux d'criture Console.Out crit sur le priphrique 1, le flux d'criture Console.Error crit sur le priphrique 2 et le flux de
lecture Console.In lit les donnes provenant du priphrique 0.
Lorsqu'on lance un programme sous Dos ou Unix, on peut fixer quels seront les priphriques 0, 1 et 2 pour le programme
excut. Considrons la ligne de commande suivante :
Les bases de C# 13
pg arg1 arg2 .. argn
Derrire les arguments argi du programme pg, on peut rediriger les priphriques d'E/S standard vers des fichiers:
0<in.txt le flux d'entre standard n 0 est redirig vers le fichier in.txt. Dans le programme le flux Console.In
prendra donc ses donnes dans le fichier in.txt.
1>out.txt redirige la sortie n 1 vers le fichier out.txt. Cela entrane que dans le programme le flux Console.Out crira
ses donnes dans le fichier out.txt
1>>out.txt idem, mais les donnes crites sont ajoutes au contenu actuel du fichier out.txt.
2>error.txt redirige la sortie n 2 vers le fichier error.txt. Cela entrane que dans le programme le flux Console.Error
crira ses donnes dans le fichier error.txt
2>>error.txt idem, mais les donnes crites sont ajoutes au contenu actuel du fichier error.txt.
1>out.txt 2>error.txt Les priphriques 1 et 2 sont tous les deux redirigs vers des fichiers
On notera que pour rediriger les flux d'E/S du programme pg vers des fichiers, le programme pg n'a pas besoin d'tre modifi.
C'est l'OS qui fixe la nature des priphriques 0,1 et 2. Considrons le programme suivant :
// imports
using System;
// redirections
public class console2{
public static void Main(String[] args){
// lecture flux In
string data=Console.In.ReadLine();
// criture flux Out
Console.Out.WriteLine("criture dans flux Out : " + data);
// criture flux Error
Console.Error.WriteLine("criture dans flux Error : " + data);
}//Main
}//classe
E:\data\serge\MSNET\c#\bases\1>console2
test
criture dans flux Out : test
criture dans flux Error : test
L'excution prcdente ne redirige aucun des flux d'E/S standard In, Out, Error. Nos allons maintenant rediriger les trois flux. Le
flux In sera redirig vers un fichier in.txt, le flux Out vers le fichier out.txt, le flux Error vers le fichier error.txt. Cette redirection a lieu
sur la ligne de commande sous la forme
E:\data\serge\MSNET\c#\bases\1>more in.txt
test
E:\data\serge\MSNET\c#\bases\1>more out.txt
criture dans flux Out : test
E:\data\serge\MSNET\c#\bases\1>more error.txt
criture dans flux Error : test
On voit clairement que les flux Out et In n'crivent pas sur les mmes priphriques.
Les bases de C# 14
L'opration variable=expression;
V1=V2=expression
est lgale. A cause de la priorit, c'est l'oprateur = le plus droite qui va tre valu. On a donc
V1=(V2=expression)
L'expression V2=expression est value et a pour valeur V. L'valuation de cette expression a provoqu l'affectation de V V2.
L'oprateur = suivant est alors valu sous la forme :
V1=V
La valeur de cette expression est encore V. Son valuation provoque l'affectation de V V1.
V1=V2=....=Vn=expression
+ addition
- soustraction
* multiplication
/ division : le rsultat est le quotient exact si l'un au moins des oprandes est rel. Si les deux oprandes sont entiers le
rsultat est le quotient entier. Ainsi 5/2 -> 2 et 5.0/2 ->2.5.
% division : le rsultat est le reste quelque soit la nature des oprandes, le quotient tant lui entier. C'est donc l'opration
modulo.
etc...
Toutes ces fonctions sont dfinies dans une classe C# appele Math. Lorsqu'on les utilise, il faut les prfixer avec le nom de la
classe o elles sont dfinies. Ainsi on crira :
Les bases de C# 15
double x, y=4;
x=Math.Sqrt(y);
Le rsultat d'une expression relationnelle est le boolen false si expression fausse true sinon.
boolean fin;
int x;
fin=x>4;
Soient deux caractres C1 et C2. Il est possible de les comparer avec les oprateurs
<, <=, ==, !=, >, >=
Ce sont alors leurs codes ASCII, qui sont des nombres, qui sont alors compars. On rappelle que selon l'ordre ASCII on a les
relations suivantes :
espace < .. < '0' < '1' < .. < '9' < .. < 'A' < 'B' < .. < 'Z' < .. < 'a' < 'b' < .. <'z'
Elles sont compares caractre par caractre. La premire ingalit rencontre entre deux caractres induit une ingalit de mme
sens sur les chanes.
Exemples :
"Chat" "Chien"
-----------------------
'C' = 'C'
'h' = 'h'
'a' < 'i'
Soit comparer les chanes "Chat" et "Chaton". Il y a galit tout le temps jusqu' puisement de la chane "Chat". Dans ce cas, la
chane puise est dclare la plus "petite". On a donc la relation
"Chat" < "Chaton".
On peut utiliser ici les oprateurs relationnels <, <=, ==, !=, >, >= ou des mthodes de la classe String :
Les bases de C# 17
-1 si chane n1 < chane n2
La variable egal aura la valeur true si les deux chanes sont gales.
int fin;
int x;
fin= x>2 && x<4;
Les oprateurs relationnels ont priorit sur les oprateurs && et ||.
i<<n dcale i de n bits sur la gauche. Les bits entrants sont des zros.
i>>n dcale i de n bits sur la droite. Si i est un entier sign (signed char, int, long) le bit de signe est prserv.
i&j fait le ET logique de i et j bit bit.
i|j fait le OU logique de i et j bit bit.
~i complmente i 1
i^j fait le OU EXCLUSIF de i et j
Soit
opration valeur
i<<4 0x23F0
i>>4 0x0123 le bit de signe est prserv.
k>>4 0xFF12 le bit de signe est prserv.
i&j 0x1023
i|j 0xF33F
~i 0xEDC0
Il en est de mme avec les oprateurs /, %,* ,<<, >>, &, |, ^. Ainsi a=a+2; peut s'crire a+=2;
Les bases de C# 18
1.3.5.9 L'oprateur ?
L'expression
expr_cond ? expr1:expr2
1 l'expression expr_cond est value. C'est une expression conditionnelle valeur vrai ou faux
2 Si elle est vraie, la valeur de l'expression est celle de expr1. expr2 n'est pas value.
3 Si elle est fausse, c'est l'inverse qui se produit : la valeur de l'expression est celle de expr2. expr1 n'est pas value.
L'opration i=(j>4 ? j+1:j-1); affectera la variable i : j+1 si j>4, j-1 sinon. C'est la mme chose que d'crire if(j>4) i=j+1; else i=j-1;
mais c'est plus concis.
gd indique qu'a priorit gale, c'est la priorit gauche-droite qui est observe. Cela signifie que lorsque dans une expression, l'on a
des oprateurs de mme priorit, c'est l'oprateur le plus gauche dans l'expression qui est valu en premier. dg indique une
priorit droite-gauche.
(type) valeur
La valeur prend alors le type indiqu. Cela entrane un changement de codage de la valeur.
int i, j;
float isurj;
isurj= (float)i/j; // priorit de () sur /
Ici il est ncessaire de changer le type de i ou j en rel sinon la division donnera le quotient entier et non rel.
i est une valeur code de faon exacte sur 2 octets
(float) i est la mme valeur code de faon approche en rel sur 4 octets
Il y a donc transcodage de la valeur de i. Ce transcodage n'a lieu que le temps d'un calcul, la variable i conservant toujours son type
int.
Les bases de C# 19
1.4 Les instructions de contrle du droulement du programme
1.4.1 Arrt
La mthode Exit dfinie dans la classe Environment permet d'arrter l'excution d'un programme.
exit provoque la fin du processus en cours et rend la main au processus appelant. La valeur de status peut tre utilise par celui-ci.
Sous DOS, cette variable status est rendue DOS dans la variable systme ERRORLEVEL dont la valeur peut tre teste dans un
fichier batch. Sous Unix, c'est la variable $? qui rcupre la valeur de status.
Environment.Exit(0);
notes:
si condition
alors actions_condition_vraie
sinon actions_condition_fausse
finsi
exemple
if(condition1)
if (condition2)
{......}
else //condition2
{......}
else //condition1
{.......}
Dans l'exemple prcdent, le else se rapporte quel if ? La rgle est qu'un else se rapporte toujours au if le plus proche : if(n>6) dans
l'exemple. Considrons un autre exemple :
Les bases de C# 20
public static void Main()
{ int n=0;
if(n>1)
if(n>6) Console.Out.WriteLine (">6");
else; // else du if(n>6) : rien faire
else Console.Out.WriteLine ("<=1"); // else du if(n>1)
}
Ici nous voulions mettre un else au if(n>1) et pas de else au if(n>6). A cause de la remarque prcdente, nous sommes obligs de
mettre un else au if(n>6), dans lequel il n'y a aucune instruction.
switch(expression) {
case v1:
actions1;
break;
case v2:
actions2;
break;
. .. .. .. .. ..
default:
actions_sinon;
break;
}
notes
exemple
En algorithmique
En C#
Les bases de C# 21
Structure for
for (i=id;i<=if
if;i=i+ip){
if
actions;
}
Notes
les 3 arguments du for sont l'intrieur d'une parenthse et spars par des points-virgules.
chaque action du for est termine par un point-virgule.
l'accolade n'est ncessaire que s'il y a plus d'une action.
l'accolade n'est pas suivie de point-virgule.
i ! id
tantque i<=if
actions
i! i+ip
fintantque
Structure foreach
foreach
for (type variable in expression)
instructions;
}
Notes
expression est une collection d'objets. La collection d'objets que nous connaissons dj est le tableau
type est le type des objets de la collection. Pour un tableau, ce serait le type des lments du tableau
variable est une variable locale la boucle qui va prendre successivement pour valeur, toutes les valeurs de la collection.
afficherait :
paul
hlne
jacques
sylvie
while(condition){
while
Les bases de C# 22
actions;
}
On boucle tant que la condition est vrifie. La boucle peut ne jamais tre excute.
notes:
tantque condition
actions
fintantque
do{
do
instructions;
}while
while(condition);
while
On boucle jusqu' ce que la condition devienne fausse ou tant que la condition est vraie. Ici la boucle est faite au moins une fois.
notes
rpter
actions
jusqu' condition
for(instructions_dpart;condition;instructions_fin_boucle){
for
instructions;
}
On boucle tant que la condition est vraie (value avant chaque tour de boucle). Instructions_dpart sont effectues avant d'entrer
dans la boucle pour la premire fois. Instructions_fin_boucle sont excutes aprs chaque tour de boucle.
notes
les diffrentes instructions dans instructions_depart et instructions_fin_boucle sont spares par des virgules.
instructions_dpart
tantque condition
actions
instructions_fin_boucle
fintantque
Les bases de C# 23
Exemples
Les programmes suivants calculent tous la somme des n premiers nombres entiers.
1 for(i=1,
for somme=0;i<=n;i=i+1)
somme=somme+a[i];
4 i=1; somme=0;
do somme+=i++;
while (i<=n);
Si on utilise des fonctions susceptibles de gnrer des exceptions qu'on ne souhaite pas grer finement, on pourra encadrer le code
du programme par une clause try/catch :
produit un fichier test1.exe interprtable par la plate-forme .NET. Le programme csc.exe est le compilateur C# et se trouve dans
l'arborescence du SDK, par exemple C:\WINNT\Microsoft.NET\Framework\v1.0.2914\csc.exe. Si l'installation de .NET s'est faite
correctement, l'excutable csc.exe doit tre dans le chemin des excutables du DOS.
DOS> test1
Les bases de C# 24
on calcule le nombre de parts du salari nbParts=nbEnfants/2 +1 s'il n'est pas mari, nbEnfants/2+2 s'il est mari, o
nbEnfants est son nombre d'enfants.
s'il a au moins trois enfants, il a une demi-part de plus
on calcule son revenu imposable R=0.72*S o S est son salaire annuel
on calcule son coefficient familial QF=R/nbParts
on calcule son impt I. Considrons le tableau suivant :
12620.0 0 0
13190 0.05 631
15640 0.1 1290.5
24740 0.15 2072.5
31810 0.2 3309.5
39970 0.25 4900
48360 0.3 6898.5
55790 0.35 9316.5
92970 0.4 12106
127860 0.45 16754.5
151250 0.50 23147.5
172040 0.55 30710
195000 0.60 39312
0 0.65 49062
Chaque ligne a 3 champs. Pour calculer l'impt I, on recherche la premire ligne o QF<=champ1. Par exemple, si QF=23000 on
trouvera la ligne
24740 0.15 2072.5
L'impt I est alors gal 0.15*R - 2072.5*nbParts. Si QF est tel que la relation QF<=champ1 n'est jamais vrifie, alors ce sont les
coefficients de la dernire ligne qui sont utiliss. Ici :
0 0.65 49062
ce qui donne l'impt I=0.65*R - 49062*nbParts.
using System;
public class impots{
// ------------ main
public static void Main(){
// nombre d'enfants
OK=false;
int NbEnfants=0;
while(! OK){
Console.Out.Write("Nombre d'enfants : ");
reponse=Console.In.ReadLine();
try{
NbEnfants=int.Parse(reponse);
if(NbEnfants>=0) OK=true;
else Console.Error.WriteLine("Rponse incorrecte. Recommencez");
} catch(Exception){
Console.Error.WriteLine("Rponse incorrecte. Recommencez");
}// try
}// while
// salaire
OK=false;
int Salaire=0;
while(! OK){
Console.Out.Write("Salaire annuel : ");
reponse=Console.In.ReadLine();
try{
Salaire=int.Parse(reponse);
if(Salaire>=0) OK=true;
else Console.Error.WriteLine("Rponse incorrecte. Recommencez");
Les bases de C# 25
} catch(Exception){
Console.Error.WriteLine("Rponse incorrecte. Recommencez");
}// try
}// while
// calcul du nombre de parts
decimal NbParts;
if(Marie) NbParts=(decimal)NbEnfants/2+2;
else NbParts=(decimal)NbEnfants/2+1;
if (NbEnfants>=3) NbParts+=0.5M;
// revenu imposable
decimal Revenu;
Revenu=0.72M*Salaire;
// quotient familial
decimal QF;
QF=Revenu/NbParts;
// recherche de la tranche d'impots correspondant QF
int i;
int NbTranches=Limites.Length;
Limites[NbTranches-1]=QF;
i=0;
while(QF>Limites[i]) i++;
// l'impt
int impots=(int)(i*0.05M*Revenu-CoeffN[i]*NbParts);
// on affiche le rsultat
Console.Out.WriteLine("Impt payer : " + impots);
}// main
}// classe
E:\data\serge\MSNET\c#\impots\4>C:\WINNT\Microsoft.NET\Framework\v1.0.2914\csc.exe impots.cs
Microsoft (R) Visual C# Compiler Version 7.00.9254 [CLR version v1.0.2914]
Copyright (C) Microsoft Corp 2000-2001. All rights reserved.
E:\data\serge\MSNET\c#\impots\4>dir
30/04/2002 16:16 2 274 impots.cs
30/04/2002 16:16 5 120 impots.exe
Il faut noter que impots.exe n'est pas directement excutable par le processeur mais uniquement. Il contient en ralit du code
intermdiaire qui n'est excutable que sur une plate-forme .NET. Les rsultats obtenus sont les suivants :
E:\data\serge\MSNET\c#\impots\4>impots
Etes-vous mari(e) (O/N) ? o
Nombre d'enfants : 3
Salaire annuel : 200000
Impt payer : 16400
E:\data\serge\MSNET\c#\impots\4>impots
Etes-vous mari(e) (O/N) ? n
Nombre d'enfants : 2
Salaire annuel : 200000
Impt payer : 33388
E:\data\serge\MSNET\c#\impots\4>impots
Etes-vous mari(e) (O/N) ? w
Rponse incorrecte. Recommencez
Etes-vous mari(e) (O/N) ? q
Rponse incorrecte. Recommencez
Etes-vous mari(e) (O/N) ? o
Nombre d'enfants : q
Rponse incorrecte. Recommencez
Nombre d'enfants : 2
Salaire annuel : q
Rponse incorrecte. Recommencez
Salaire annuel : 1
Impt payer : 0
Les bases de C# 26
La fonction principale Main peut admettre comme paramtre un tableau de chanes : String[] (ou string[]). Ce tableau contient les
arguments de la ligne de commande utilise pour lancer l'application. Ainsi si on lance le programme P avec la commande :
// imports
using System;
public class arg1{
public static void Main(String[] args){
// on liste les paramtres
Console.Out.WriteLine("Il y a " + args.Length + " arguments");
for (int i=0;i<args.Length;i++){
Console.Out.WriteLine("arguments["+i+"]="+args[i]);
}
}//Main
}//classe
E:\data\serge\MSNET\c#\bases\0>arg1
Il y a 0 arguments
E:\data\serge\MSNET\c#\bases\0>arg1 a b c
Il y a 3 arguments
arguments[0]=a
arguments[1]=b
arguments[2]=c
le paramtre args est un tableau de chanes de caractres qui reoit les arguments passs sur la ligne de commande lors de l'appel du
programme.
args.Length est le nombre d'lements du tableau args
args[i] est l'lment i du tableau
De faon interne, ces cinq constantes sont codes par des entiers conscutifs commenant par 0 pour la premire constante, 1 pour
la suivante, etc... Une variable peut tre dclare comme prenant ces valeurs dans l'numration :
if(maMention==mention.Passable){
Console.Out.WriteLine("Peut mieux faire");
}//if
De la mme faon que le type simple int est quivalent la classe Int32, le type simple enum est quivalent la classe Enum. Cette
classe a une mthode statique GetValues qui permet d'obtenir toutes les valeurs d'un type numr que l'on passe en paramtre.
Celui-ci doit tre un objet de type Type qui est une classe d'information sur le type d'une donne. Le type d'une variable v est
obtenu par v.GetType(). Donc ici maMention.GetType() donne l'objet Type de l'numration mentions et
Enum.GetValues(maMention.GetType()) la liste des valeurs de l'numration mentions.
Si on crit maintenant
foreach(int m in Enum.GetValues(maMention.GetType())){
Console.Out.WriteLine(m);
}//foreach
on obtiendra la liste des valeurs de l'numration sous forme d'entiers. C'est ce que montre le programme suivant :
// numration
using System;
public class intro{
// une numration
enum mention {Passable,AssezBien,Bien,TrsBien, Excellent};
public static void Main(){
// une variable qui prend ses valeurs dans l'numration mentions
mention maMention=mention.Passable;
// affichage valeur variable
Console.Out.WriteLine("mention="+maMention);
// test avec valeur de l'numration
if(maMention==mention.Passable){
Console.Out.WriteLine("Peut mieux faire");
}//if
// liste des mentions
foreach(mention m in Enum.GetValues(maMention.GetType())){
Console.Out.WriteLine(m);
}//foreach
foreach(int m in Enum.GetValues(maMention.GetType())){
Console.Out.WriteLine(m);
}//foreach
}//Main
}//classe
mention=Passable
Peut mieux faire
Passable
AssezBien
Bien
TrsBien
0
1
2
3
try{
appel de la fonction susceptible de gnrer l'exception
} catch (Exception e){
traiter l'exception e
}
instruction suivante
Les bases de C# 28
Si la fonction ne gnre pas d'exception, on passe alors instruction suivante, sinon on passe dans le corps de la clause catch puis
instruction suivante. Notons les points suivants :
e est un objet driv du type Exception. On peut tre plus prcis en utilisant des types tels que IOException, SystemException,
etc : il existe plusieurs types d'exceptions. En crivant catch (Exception e), on indique qu'on veut grer toutes les types
d'exceptions. Si le code de la clause try est susceptible de gnrer plusieurs types d'exceptions, on peut vouloir tre plus prcis
en grant l'exception avec plusieurs clauses catch :
try{
appel de la fonction susceptible de gnrer l'exception
} catch (IOException e){
traiter l'exception e
}
} catch (SystemException e){
traiter l'exception e
}
instruction suivante
try{
appel de la fonction susceptible de gnrer l'exception
} catch (Exception e){
traiter l'exception e
}
finally{
code excut aprs try ou catch
}
instruction suivante
Qu'il y ait exception ou pas, le code de la clause finally sera toujours excut.
Dans la clause catch, on peut ne pas vouloir utiliser l'objet Exception disponible. Au lieu d'crire catch (Exception e){..}, on crit
alors catch(Exception){...} ou catch {...}.
La classe Exception a une proprit Message qui est un message dtaillant l'erreur qui s'est produite. Ainsi si on veut afficher
celui-ci, on crira :
catch (Exception ex){
Console.Error.WriteLine("L'erreur suivante s'est produite : "+ex.Message);
...
}//catch
La classe Exception a une mthode ToString qui rend une chane de caractres indiquant le type de l'exception ainsi que la
valeur de la proprit Message. On pourra ainsi crire :
catch (Exception ex){
Console.Error.WriteLine("L'erreur suivante s'est produite : "+ex.ToString());
...
}//catch
On peut crire aussi :
catch (Exception ex){
Console.Error.WriteLine("L'erreur suivante s'est produite : "+ex);
...
}//catch
Nous avons ici une opration string + Exception qui va tre automatiquement transforme en string + Exception.ToString() par le
compilateur afin de faire la concatnation de deux chanes de caractres.
L'exemple suivant montre une exception gnre par l'utilisation d'un lment de tableau inexistant :
// tableaux
// imports
using System;
public class tab1{
public static void Main(String[] args){
// dclaration & initialisation d'un tableau
Les bases de C# 29
int[] tab=new int[] {0,1,2,3};
int i;
// affichage tableau avec un for
for (i=0; i<tab.Length; i++)
Console.Out.WriteLine("tab[" + i + "]=" + tab[i]);
// affichage tableau avec un for each
foreach (int lmt in tab)
Console.Out.WriteLine(lmt);
// gnration d'une exception
try{
tab[100]=6;
}catch (Exception e){
Console.Error.WriteLine("L'erreur suivante s'est produite : " + e);
}//try-catch
finally{
String attente=Console.ReadLine();
}
}//Main
}//classe
E:\data\serge\MSNET\c#\bases\2>tab1
tab[0]=0
tab[1]=1
tab[2]=2
tab[3]=3
0
1
2
3
L'erreur suivante s'est produite : System.IndexOutOfRangeException: Exception of
type System.IndexOutOfRangeException was thrown.
at tab1.Main(String[] args)
Voici un autre exemple o on gre l'exception provoque par l'affectation d'une chane de caractres un nombre lorsque la chane
ne reprsente pas un nombre :
// imports
using System;
public class console1{
public static void Main(String[] args){
// On demande le nom
System.Console.Write("Nom : ");
// lecture rponse
String nom=System.Console.ReadLine();
// on demande l'ge
int age=0;
Boolean ageOK=false;
while ( ! ageOK){
// question
Console.Out.Write("ge : ");
// lecture-vrification rponse
try{
age=int.Parse(System.Console.ReadLine());
ageOK=true;
}catch {
Console.Error.WriteLine("Age incorrect, recommencez...");
}//try-catch
}//while
// affichage final
Console.Out.WriteLine("Vous vous appelez " + nom + " et vous avez " + age + " ans");
Console.ReadLine();
}//Main
}//classe
E:\data\serge\MSNET\c#\bases\1>console1
Nom : dupont
ge : 23
Vous vous appelez dupont et vous avez 23 ans
E:\data\serge\MSNET\c#\bases\1>console1
Nom : dupont
ge : xx
Age incorrect, recommencez...
ge : 12
Vous vous appelez dupont et vous avez 12 ans
Les bases de C# 30
1.11 Passage de paramtres une fonction
Nous nous intressons ici au mode de passage des paramtres d'une fonction. Considrons la fonction :
private static void changeInt(int a){
a=30;
Console.Out.WriteLine("Paramtre formel a="+a);
}
Dans la dfinition de la fonction, a est appel un paramtre formel. Il n'est l que pour les besoins de la dfinition de la fonction
changeInt. Il aurait tout aussi bien pu s'appeler b. Considrons maintenant une utlisation de cette fonction :
public static void Main(){
int age=20;
changeInt(age);
Console.Out.WriteLine("Paramtre effectif age="+age);
}
Ici dans l'instruction changeInt(age), age est le paramtre effectif qui va transmettre sa valeur au paramtre formel a. Nous nous
intressons la faon dont un paramtre formel rcupre la valeur d'un paramtre effectif.
La valeur 20 du paramtre effectif a t recopie dans le paramtre formel a. Celui-ci a t ensuite modifi. Le paramtre effectif est
lui rest inchang. Ce mode de passage convient aux paramtres d'entre d'une fonction.
Voici un exemple :
using System;
public class param2{
public static void Main(){
int age=20;
changeInt(ref age);
Console.Out.WriteLine("Paramtre effectif age="+age);
}
private static void changeInt(ref int a){
a=30;
Console.Out.WriteLine("Paramtre formel a="+a);
}
}
Les bases de C# 31
et les rsultats d'excution :
Le paramtre effectif a suivi la modification du paramtre formel. Ce mode de passage convient aux paramtres de sortie d'une
fonction.
On peut contourner l'obstacle en affectant une valeur initiale age. On peut aussi remplacer le mot cl ref par le mot cl out. On
exprime alors que la paramtre est uniquement un paramtre de sortie et n'a donc pas besoin de valeur initiale :
Les bases de C# 32
2. Classes, stuctures, interfaces
2.1 L' objet par l'exemple
2.1.1 Gnralits
Nous abordons maintenant, par l'exemple, la programmation objet. Un objet est une entit qui contient des donnes qui dfinissent
son tat (on les appelle des proprits) et des fonctions (on les appelle des mthodes). Un objet est cr selon un modle qu'on
appelle une classe :
A partir de la classe C1 prcdente, on peut crer de nombreux objets O1, O2, Tous auront les proprits p1, p2, et les
mthodes m3, m4, Mais ils auront des valeurs diffrentes pour leurs proprits pi ayant ainsi chacun un tat qui leur est propre.
Par analogie la dclaration
int i,j;
cre deux objets (le terme est incorrect ici) de type (classe) int. Leur seule proprit est leur valeur.
Si O1 est un objet de type C1, O1.p1 dsigne la proprit p1 de O1 et O1.m1 la mthode m1 de O1.
// mthode
public void initialise(string P, string N, int age){
this.prenom=P;
this.nom=N;
this.age=age;
}
// mthode
public void identifie(){
Console.Out.WriteLine(prenom+","+nom+","+age);
}
}
Nous avons ici la dfinition d'une classe, donc d'un type de donnes. Lorsqu'on va crer des variables de ce type, on les appellera
des objets ou des instances de classes. Une classe est donc un moule partir duquel sont construits des objets.
Les membres ou champs d'une classe peuvent tre des donnes (attributs), des mthodes (fonctions), des proprits. Les proprits
sont des mthodes particulires servant connatre ou fixer la valeur d'attributs de l'objet. Ces champs peuvent tre accompagns
de l'un des trois mots cls suivants :
En gnral, les donnes d'une classe sont dclares prives alors que ses mthodes et proprits sont dclares publiques. Cela
signifie que l'utilisateur d'un objet (le programmeur)
// mthode
public void identifie(){
Console.Out.WriteLine(prenom+","+nom+","+age);
}
}
Quel est le rle de la mthode initialise ? Parce que nom, prenom et age sont des donnes prives de la classe personne, les instructions :
personne p1;
p1.prenom="Jean";
p1.nom="Dupont";
p1.age=30;
sont illgales. Il nous faut initialiser un objet de type personne via une mthode publique. C'est le rle de la mthode initialise. On
crira :
personne p1;
p1.initialise("Jean","Dupont",30);
personne p1;
p1.initialise("Jean","Dupont",30);
personne p1;
dclare p1 comme une rfrence un objet de type personne. Cet objet n'existe pas encore et donc p1 n'est pas initialis. C'est comme
si on crivait :
Classes, Structures, Interfaces 34
personne p1=null;
o on indique explicitement avec le mot cl null que la variable p1 ne rfrence encore aucun objet. Lorsqu'on crit ensuite
p1.initialise("Jean","Dupont",30);
on fait appel la mthode initialise de l'objet rfrenc par p1. Or cet objet n'existe pas encore et le compilateur signalera l'erreur.
Pour que p1 rfrence un objet, il faut crire :
Cela a pour effet de crer un objet de type personne non encore initialis : les attributs nom et prenom qui sont des rfrences d'objets
de type String auront la valeur null, et age la valeur 0. Il y a donc une initialisation par dfaut. Maintenant que p1 rfrence un objet,
l'instruction d'initialisation de cet objet
p1.initialise("Jean","Dupont",30);
est valide.
L'instruction this.prenom=P signifie que l'attribut prenom de l'objet courant (this) reoit la valeur P. Le mot cl this dsigne l'objet
courant : celui dans lequel se trouve la mthode excute. Comment le connat-on ? Regardons comment se fait l'initialisation de
l'objet rfrenc par p1 dans le programme appelant :
p1.initialise("Jean","Dupont",30);
C'est la mthode initialise de l'objet p1 qui est appele. Lorsque dans cette mthode, on rfrence l'objet this, on rfrence en fait
l'objet p1. La mthode initialise aurait aussi pu tre crite comme suit :
Lorsqu'une mthode d'un objet rfrence un attribut A de cet objet, l'criture this.A est implicite. On doit l'utiliser explicitement
lorsqu'il y a conflit d'identificateurs. C'est le cas de l'instruction :
this.age=age;
this
o age dsigne un attribut de l'objet courant ainsi que le paramtre age reu par la mthode. Il faut alors lever l'ambigut en
dsignant l'attribut age par this.age.
using System;
public class personne{
// attributs
private string prenom;
private string nom;
private int age;
// mthode
public void initialise(string P, string N, int age){
this.prenom=P;
this.nom=N;
this.age=age;
}
// mthode
Classes, Structures, Interfaces 35
public void identifie(){
Console.Out.WriteLine(prenom+","+nom+","+age);
}
}
public class test1{
public static void Main(){
personne p1=new personne();
p1.initialise("Jean","Dupont",30);
p1.identifie();
}
}
E:\data\serge\MSNET\c#\objetsPoly\1>C:\WINNT\Microsoft.NET\Framework\v1.0.2914\csc.exe personne1.cs
Microsoft (R) Visual C# Compiler Version 7.00.9254 [CLR version v1.0.2914]
Copyright (C) Microsoft Corp 2000-2001. All rights reserved.
E:\data\serge\MSNET\c#\objetsPoly\1>personne1
Jean,Dupont,30
- on compile la classe personne dans un fichier particulier appel un assemblage (assembly). Ce fichier a une extension .dll
- on compile la classe test1 en rfrenant l'assemblage qui contient la classe personne.
E:\data\serge\MSNET\c#\objetsPoly\2>dir
26/04/2002 08:24 520 personne.cs
26/04/2002 08:26 169 test1.cs
26/04/2002 08:26 3 584 personne.dll
La compilation a produit un fichier personne.dll. C'est l'option de compilation /t:library qui indique de produire un fichier "assembly".
Maintenant compilons le fichier test1.cs :
E:\data\serge\MSNET\c#\objetsPoly\2>dir
26/04/2002 08:24 520 personne.cs
26/04/2002 08:26 169 test1.cs
26/04/2002 08:26 3 584 personne.dll
26/04/2002 08:53 3 072 test1.exe
L'option de compilation /r:personne.dll indique au compilateur qu'il trouvera certaines classes dans le fichier personne.dll. Lorsque dans
le fichier source test1.cs, il trouvera une rfrence la classe personne classe non dclare dans le source test1.cs, il cherchera la classe
personne dans les fichiers .dll rfrencs par l'option /r. Il trouvera ici la classe personne dans l'assemblage personne.dll. On aurait pu
mettre dans cet assemblage d'autres classes. Pour utiliser lors de la compilation plusieurs fichiers de classes compiles, on crira :
E:\data\serge\MSNET\c#\objetsPoly\2>test1
Jean,Dupont,30
On a maintenant deux mthodes portant le nom initialise : c'est lgal tant qu'elles admettent des paramtres diffrents. C'est le cas
ici. Le paramtre est maintenant une rfrence P une personne. Les attributs de la personne P sont alors affects l'objet courant
(this). On remarquera que la mthode initialise a un accs direct aux attributs de l'objet P bien que ceux-ci soient de type private. C'est
toujours vrai : un objet O1 d'une classe C a toujours accs aux attributs des objets de la mme classe C.
Voici un test de la nouvelle classe personne, celle-ci ayant t compile dans personne.dll comme il a t expliqu prcdemment :
using System;
public class test1{
public static void Main(){
personne p1=new personne();
p1.initialise("Jean","Dupont",30);
Console.Out.Write("p1=");
p1.identifie();
personne p2=new personne();
p2.initialise(p1);
Console.Out.Write("p2=");
p2.identifie();
}
}
et ses rsultats :
p1=Jean,Dupont,30
p2=Jean,Dupont,30
Si une classe a un constructeur acceptant n arguments argi, la dclaration et l'initialisation d'un objet de cette classe pourra se faire
sous la forme :
Lorsqu'une classe a un ou plusieurs constructeurs, l'un de ces constructeurs doit tre obligatoirement utilis pour crer un objet de
cette classe. Si une classe C n'a aucun constructeur, elle en a un par dfaut qui est le constructeur sans paramtres : public C(). Les
attributs de l'objet sont alors initialiss avec des valeurs par dfaut. C'est ce qui s'est pass lorsque dans les programmes prcdents,
o on avait crit :
personne p1;
p1=new personne();
using System;
public class personne{
// attributs
private string prenom;
private string nom;
private int age;
// constructeurs
public personne(String P, String N, int age){
initialise(P,N,age);
}
public personne(personne P){
initialise(P);
}
Nos deux constructeurs se contentent de faire appel aux mthodes initialise correspondantes. On rappelle que lorsque dans un
constructeur, on trouve la notation initialise(P) par exemple, le compilateur traduit par this.initialise(P). Dans le constructeur, la
mthode initialise est donc appele pour travailler sur l'objet rfrenc par this, c'est dire l'objet courant, celui qui est en cours de
construction.
using System;
public class test1{
public static void Main(){
personne p1=new personne("Jean","Dupont",30);
Console.Out.Write("p1=");
p1.identifie();
personne p2=new personne(p1);
Console.Out.Write("p2=");
p2.identifie();
}
}
p1=Jean,Dupont,30
p2=Jean,Dupont,30
using System;
p1=Jean,Dupont,30
p2=Jean,Dupont,30
p3=Jean,Dupont,30
p1=Micheline,Benot,67
p2=Micheline,Benot,67
p3=Jean,Dupont,30
p1 rfrence l'objet personne("Jean","Dupont",30) mais n'est pas l'objet lui-mme. En C, on dirait que c'est un pointeur, c.a.d. l'adresse
de l'objet cr. Si on crit ensuite :
p1=null
Ce n'est pas l'objet personne("Jean","Dupont",30) qui est modifi, c'est la rfrence p1 qui change de valeur. L'objet
personne("Jean","Dupont",30) sera "perdu" s'il n'est rfrenc par aucune autre variable.
Lorsqu'on crit :
personne p2=p1;
on initialise le pointeur p2 : il "pointe" sur le mme objet (il dsigne le mme objet) que le pointeur p1. Ainsi si on modifie l'objet
"point" (ou rfrenc) par p1, on modifie celui rfrenc par p2.
Lorsqu'on crit :
il y a cration d'un nouvel objet, copie de l'objet rfrenc par p1. Ce nouvel objet sera rfrenc par p3. Si on modifie l'objet
"point" (ou rfrenc) par p1, on ne modifie en rien celui rfrenc par p3. C'est ce que montrent les rsultats obtenus.
using System;
public class test1{
public static void Main(){
new personne(new personne("Jean","Dupont",30)).identifie();
}
}
// constructeurs
public personne(String P, String N, int age){
Console.Out.WriteLine("Constructeur personne(String, String, int)");
initialise(P,N,age);
}
public personne(personne P){
Console.Out.WriteLine("Constructeur personne(personne)");
initialise(P);
}
using System;
public class personne{
// attributs
private String prenom;
private String nom;
private int age;
// constructeurs
public personne(String P, String N, int age){
this.prenom=P;
this.nom=N;
this.age=age;
}
public personne(personne P){
this.prenom=P.prenom;
this.nom=P.nom;
this.age=P.age;
}
// identifie
public void identifie(){
Console.Out.WriteLine(prenom+","+nom+","+age);
}
// accesseurs
public String getPrenom(){
return prenom;
}
public String getNom(){
return nom;
}
public int getAge(){
return age;
}
//modifieurs
public void setPrenom(String P){
this.prenom=P;
}
public void setNom(String N){
this.nom=N;
}
public void setAge(int age){
this.age=age;
}
}//classe
using System;
public class test1{
public static void Main(){
personne P=new personne("Jean","Michelin",34);
Classes, Structures, Interfaces 40
Console.Out.WriteLine("P=("+P.getPrenom()+","+P.getNom()+","+P.getAge()+")");
P.setAge(56);
Console.Out.WriteLine("P=("+P.getPrenom()+","+P.getNom()+","+P.getAge()+")");
}
}
P=(Jean,Michelin,34)
P=(Jean,Michelin,56)
Considrons la classe personne suivante o les accesseurs et modifieurs prcdents ont t remplacs par des proprits en lecture et
criture :
using System;
public class personne{
// attributs
private String _prenom;
private String _nom;
private int _age;
// constructeurs
public personne(String P, String N, int age){
this._prenom=P;
this._nom=N;
this._age=age;
}
public personne(personne P){
this._prenom=P._prenom;
this._nom=P._nom;
this._age=P._age;
}
// identifie
public void identifie(){
Console.Out.WriteLine(_prenom+","+_nom+","+_age);
}
// proprits
public string prenom{
get { return _prenom; }
set { _prenom=value; }
}//prenom
public string nom{
get { return _nom; }
set { _nom=value; }
}//nom
public int age{
get { return _age; }
set {
// age valide ?
if(value>=0){
_age=value;
} else
throw new Exception("ge ("+value+") invalide");
}//if
}//age
}//classe
Une proprit permet de lire (get) ou de fixer (set) la valeur d'un attribut. Dans notre exemple, nous avons prfix les noms des
attributs du signe _ afin que les proprits portent le nom des attributs primitifs. En effet, une proprit ne peut porter le mme
nom que l'attribut qu'elle gre car alors il y a un conflit de noms dans la classe. Nous avons donc appel nos attributs _prenom, _nom,
_age et modifi les constructeurs et mthodes en consquence. Nous avons ensuite cr trois proprits nom, prenom et age. Une
proprit est dclare comme suit :
Comment ces mthodes get et set sont-elles appeles ? Considrons le programme de test suivant :
using System;
Dans l'instruction
Console.Out.WriteLine("P=("+P.prenom+","+P.nom+","+P.age+")");
on cherche avoir les valeurs des proprits prenom, nom et age de la personne P. C'est la mthode get de ces proprits qui est alors
appele et qui rend la valeur de l'attribut qu'elles grent.
Dans l'instruction
P.age=56;
on veut fixer la valeur de la proprit age. C'est alors la mthode set de cette proprit qui est alors appele. Elle recevra 56 dans son
paramtre value.
Une proprit P d'une classe C qui ne dfinirait que la mthode get est dite en lecture seule. Si c est un objet de classe C,
l'opration c.P=valeur sera alors refuse par le compilateur.
Les proprits nous permettent donc de manipuler des attributs privs comme s'ils taient publics.
Pour le rfrencer, on crit personne._nbPersonnes pour montrer que c'est un attribut de la classe personne elle-mme. Ici, nous avons
cr un attribut priv auquel on n'aura pas accs directement en-dehors de la classe. On cre donc une proprit publique pour
donner accs l'attribut de classe nbPersonnes. Pour rendre la valeur de nbPersonnes la mthode get de cette proprit n'a pas besoin
d'un objet personne particulier : en effet _nbPersonnes n'est pas l'attribut d'un objet particulier, il est l'attribut de toute une classe. Aussi
a-t-on besoin d'une proprit dclare elle-aussi static :
// proprit de classe
public static long nbPersonnes{
get{ return _nbPersonnes;}
}//nbPersonnes
// identifie
public void identifie(){
Console.Out.WriteLine(_prenom+","+_nom+","+_age);
}
// proprit de classe
public static long nbPersonnes{
get{ return _nbPersonnes;}
}//nbPersonnes
// proprits d'instance
public string prenom{
get { return _prenom; }
set { _prenom=value; }
}//prenom
public string nom{
get { return _nom; }
set { _nom=value; }
}//nom
using System;
public class test1{
public static void Main(){
personne p1=new personne("Jean","Dupont",30);
personne p2=new personne(p1);
new personne(p1);
Console.Out.WriteLine("Nombre de personnes cres : "+personne.nbPersonnes);
}// main
}//test1
Si une rfrence d'objet R1 est transmise une fonction, elle sera recopie dans le paramtre formel correspondant R2. Aussi les
rfrences R2 et R1 dsignent-elles le mme objet. Si la fonction modifie l'objet point par R2, elle modifie videmment celui
rfrenc par R1 puisque c'est le mme.
R1 objet
Recopie
R2
using System;
public class test1{
public static void Main(){
// une personne p1
personne p1=new personne("Jean","Dupont",30);
// affichage p1
Console.Out.Write("Paramtre effectif avant modification : ");
p1.identifie();
// modification p1
modifie(p1);
// affichage p1
Console.Out.Write("Paramtre effectif aprs modification : ");
p1.identifie();
}// main
private static void modifie(personne P){
// affichage personne P
Console.Out.Write("Paramtre formel avant modification : ");
P.identifie();
// modification P
P.prenom="Sylvie";
P.nom="Vartan";
P.age=52;
// affichage P
Console.Out.Write("Paramtre formel aprs modification : ");
P.identifie();
}// modifie
}// class
La mthode modifie est dclare static parce que c'est une mthode de classe : on n'a pas la prfixer par un objet pour l'appeler.
On voit qu'il n'y a construction que d'un objet : celui de la personne p1 de la fonction Main et que l'objet a bien t modifi par la
fonction modifie.
import personne;
using System;
public class test1{
Classes, Structures, Interfaces 44
public static void Main(){
// un tableau de personnes
personne[] amis=new personne[3];
amis[0]=new personne("Jean","Dupont",30);
amis[1]=new personne("Sylvie","Vartan",52);
amis[2]=new personne("Neil","Armstrong",66);
// affichage
Console.Out.WriteLine("----------------"); int i;
for(i=0;i<amis.Length;i++)
amis[i].identifie();
}
}
L'instruction personne[] amis=new personne[3]; cre un tableau de 3 lments de type personne. Ces 3 lments sont initialiss ici avec la
valeur null, c.a.d. qu'ils ne rfrencent aucun objet. De nouveau, par abus de langage, on parle de tableau d'objets alors que ce n'est
qu'un tableau de rfrences d'objets. La cration du tableau d'objets, qui est un objet lui-mme (prsence de new) ne cre aucun
objet du type de ses lments : il faut le faire ensuite.
Pour exprimer que la classe enseignant hrite des proprits de la classe personne, on crira :
personne est appele la classe parent (ou mre) et enseignant la classe drive (ou fille). Un objet enseignant a toutes les qualits d'un
objet personne : il a les mmes attributs et les mmes mthodes. Ces attributs et mthodes de la classe parent ne sont pas rptes
dans la dfinition de la classe fille : on se contente d'indiquer les attributs et mthodes rajouts par la classe fille :
using System;
// proprit de classe
public static long nbPersonnes{
get{ return _nbPersonnes;}
}//nbPersonnes
// proprits d'instance
public string prenom{
get { return _prenom; }
set { _prenom=value; }
}//prenom
public string nom{
get { return _nom; }
set { _nom=value; }
}//nom
public int age{
get { return _age; }
set {
// age valide ?
if(value>=0){
_age=value;
} else
throw new Exception("ge ("+value+") invalide");
}//if
}//age
public string identite{
get { return "personne("+_prenom+","+_nom+","+age+")";}
}
}//classe
La mthode identifie a t remplace par la proprit identit en lecture seule et qui identifie la personne. Nous crons une classe
enseignant hritant de la classe personne :
using System;
public class enseignant : personne {
// attributs
private int _section;
// constructeur
public enseignant(string P, string N, int age,int section) : base(P,N,age) {
this._section=section;
// suivi
Console.Out.WriteLine("Construction enseignant(string,string,int,int)");
}//constructeur
// proprit section
public int section{
get { return _section; }
set { _section=value; }
}// section
}//classe
" un attribut section qui est le n de section auquel appartient l'enseignant dans le corps des enseignants (une section par
discipline en gros)
" un nouveau constructeur permettant d'initialiser tous les attributs d'un enseignant
La dclaration
public class enseignant : personne {
// constructeur
public enseignant(String P, String N, int age,int section) : base(P,N,age) {
Classes, Structures, Interfaces 46
this._section=section;
}//constructeur
La dclaration
public enseignant(String P, String N, int age,int section) : base(P,N,age) {
dclare que le constructeur reoit quatre paramtres P, N, age, section et en passe trois (P,N,age) sa classe de base, ici la classe
personne. On sait que cette classe a un constructeur personne(string, string, int) qui va permettre de construire une personne avec les
paramtres passss (P,N,age). Une fois la construction de la classe de base termine, la construction de l'objet enseignant se poursuit
par l'excution du corps du constructeur :
this.s_ection=section;
// constructeur
public enseignant(String P, String N, int age,int section){
this._prenom=P;
this._nom=N
this._age=age
this._section=section;
}
C'est impossible. La classe personne a dclar privs (private) ses trois champs _prenom, _nom et _age. Seuls des objets de la mme classe
ont un accs direct ces champs. Tous les autres objets, y compris des objets fils comme ici, doivent passer par des mthodes
publiques pour y avoir accs. Cela aurait t diffrent si la classe personne avait dclar protgs (protected) les trois champs : elle
autorisait alors des classes drives avoir un accs direct aux trois champs. Dans notre exemple, utiliser le constructeur de la classe
parent tait donc la bonne solution et c'est la mthode habituelle : lors de la construction d'un objet fils, on appelle d'abord le
constructeur de l'objet parent puis on complte les initialisations propres cette fois l'objet fils (section dans notre exemple).
On remarquera que pour compiler la classe fille enseignant, il a fallu rfrencer le fichier personne.dll qui contient la classe personne.
using System;
public class test1{
public static void Main(){
Console.Out.WriteLine(new enseignant("Jean","Dupont",30,27).identite);
}
}
Ce programme ce contente de crer un objet enseignant (new) et de l'identifier. La classe enseignant n'a pas de mthode identit mais sa
classe parent en a une qui de plus est publique : elle devient par hritage une mthode publique de la classe enseignant. Les rsultats
obtenus sont les suivants :
On voit que :
" un objet personne a t construit avant l'objet enseignant
" l'identit obtenue est celle de l'objet personne
using System;
public class enseignant : personne {
// attributs
private int _section;
// constructeur
public enseignant(string P, string N, int age,int section) : base(P,N,age) {
this._section=section;
// suivi
Console.Out.WriteLine("Construction enseignant(string,string,int,int)");
}//constructeur
// proprit section
public int section{
get { return _section; }
set { _section=value; }
}// section
// surcharge proprit identit
public new string identite{
get { return "enseignant("+base.identite+","+_section+")"; }
}//proprit identit
}//classe
La mthode identite de la classe enseignant s'appuie sur la mthode identite de sa classe mre (base.identite) pour afficher sa partie
"personne" puis complte avec le champ _section qui est propre la classe enseignant. Notons la dclaration de la proprit identite :
public new string identite{
Soit un objet enseignant E. Cet objet contient en son sein un objet personne :
enseignant
personne
E
identite
identite
La proprit identit est dfinie la fois dans la classe enseignant et sa classe mre personne. Dans la classe fille enseignant, la proprit
identite doit tre prcde du mot cl new pour indiquer qu'on redfinit une nouvelle proprit identite pour la classe enseignant.
public new string identite{
Si E est un ojet enseignant, E.identite dsigne la mthode identite de la classe enseignant. On dit que la proprit identite de la classe mre
est "surcharge" par la proprit identite de la classe fille. De faon gnrale, si O est un objet et M une mthode, pour excuter la
mthode O.M, le systme cherche une mthode M dans l'ordre suivant :
" dans la classe de l'objet O
" dans sa classe mre s'il en a une
" dans la classe mre de sa classe mre si elle existe
" etc
L'hritage permet donc de surcharger dans la classe fille des mthodes/proprits de mme nom dans la classe mre. C'est ce qui
permet d'adapter la classe fille ses propres besoins. Associe au polymorphisme que nous allons voir un peu plus loin, la surcharge
de mthodes/proprits est le principal intrt de l'hritage.
using System;
public class test1{
public static void Main(){
Console.Out.WriteLine(new enseignant("Jean","Dupont",30,27).identite);
}
}
Classes, Structures, Interfaces 48
Les rsultats obtenus sont cette fois les suivants :
2.2.4 Le polymorphisme
Considrons une ligne de classes : C0 $ C1 $ C2 $ $Cn
o Ci $ Cj indique que la classe Cj est drive de la classe Ci. Cela entrane que la classe Cj a toutes les caractristiques de la classe Ci
plus d'autres. Soient des objets Oi de type Ci. Il est lgal d'crire :
Oi=Oj avec j>i
En effet, par hritage, la classe Cj a toutes les caractristiques de la classe Ci plus d'autres. Donc un objet Oj de type Cj contient en
lui un objet de type Ci. L'opration
Oi=Oj
fait que Oi est une rfrence l'objet de type Ci contenu dans l'objet Oj.
Le fait qu'une variable Oi de classe Ci puisse en fait rfrencer non seulement un objet de la classe Ci mais en fait tout objet driv
de la classe Ci est appel polymorphisme : la facult pour une variable de rfrencer diffrents types d'objets.
personne p;
...
affiche(p);
que
enseignant e;
...
affiche(e);
Dans ce dernier cas, le paramtre formel de type personne de la fonction affiche va recevoir une valeur de type enseignant. Comme le
type enseignant drive du type personne, c'est lgal.
La mthode p.identite rend une chane de caractres identifiant l'objet personne. Que se passe-t-il dans le cas de notre exemple
prcdent dans le cas d'un objet enseignant :
using System;
public class test1{
public static void Main(){
// un enseignant
enseignant e=new enseignant("Lucile","Dumas",56,61);
affiche(e);
// une personne
personne p=new personne("Jean","Dupont",30);
affiche(p);
Classes, Structures, Interfaces 49
}
// affiche
public static void affiche(personne p){
// affiche identit de p
Console.Out.WriteLine(p.identite);
}//affiche
}
L'excution montre que l'instruction p.identite a excut chaque fois la proprit identite d'une personne, la personne contenue dans
l'enseignant e, puis la personne p elle-mme. Elle ne s'est pas adapte l'objet rellement pass en paramtre affiche. On aurait prfr
avoir l'identit complte de l'enseignant e. Il aurait fallu pour cela que la notation p.identite rfrence la proprit identite de l'objet
rellement point par p plutt que la proprit identite de partie "personne" de l'objet rellement point par p.
Il est possible d'obtenir ce rsultat en dclarant identite comme une proprit virtuelle (virtual) dans la classe de base personne :
Le mot cl virtual fait de identite une proprit virtuelle. Ce mot cl peut s'appliquer galement aux mthodes. Les classes filles qui
redfinissent une proprit ou mthode virtuelle doivent utiliser alors le mot cl override au lieu de new pour qualifier leur
proprit/mthode redfinie. Ainsi dans la classe enseignant, la proprit identite est dfinie comme suit :
Le programme de test :
using System;
public class test1{
public static void Main(){
// un enseignant
enseignant e=new enseignant("Lucile","Dumas",56,61);
affiche(e);
// une personne
personne p=new personne("Jean","Dupont",30);
affiche(p);
}
// affiche
public static void affiche(personne p){
// affiche identit de p
Console.Out.WriteLine(p.identite);
}//affiche
}
Cette fois-ci, on a bien eu l'identit complte de l'enseignant. Surchargeons maintenant une mthode plutt qu'une proprit. La
classe object est la classe "mre" de toutes les classes C#. Ainsi lorsqu'on crit :
on crit implicitement :
La mthode ToString rend le nom de la classe laquelle appartient l'objet comme le montre l'exemple suivant :
using System;
public class test1{
public static void Main(){
// un enseignant
Console.Out.WriteLine(new enseignant("Lucile","Dumas",56,61).ToString());
// une personne
Console.Out.WriteLine(new personne("Jean","Dupont",30).ToString());
}
}
On remarquera que bien que nous n'ayons pas redfini la mthode ToString dans les classes personne et enseignant, on peut cependant
constater que la mthode ToString de la classe object est quand mme capable d'afficher le nom rel de la classe de l'objet.
// ToString
public override string ToString(){
// on rend la proprit identite
return identite;
}//ToString
La dfinition est la mme dans les deux classes. Considrons le programme de test suivant :
using System;
public class test1{
public static void Main(){
// un enseignant
enseignant e=new enseignant("Lucile","Dumas",56,61);
affiche(e);
// une personne
personne p=new personne("Jean","Dupont",30);
affiche(p);
}
// affiche
public static void affiche(personne p){
// affiche identit de p
Console.Out.WriteLine(""+p);
}//affiche
}
Attardons-nous sur la mthode affiche qui admet pour paramtre une personne p. Que signifie l'expression ""+p ? Le compilateur va
ici chercher transformet l'objet p en string et cherche toujours pour cela l'existence d'une mthode appele ToSTring. Donc ""+p
devient ""+p.Tostring(). La mthode ToString tant virtuelle, le compilateur va excuter la mthode ToString de l'objet rellement
point par p. C'est ce que montrent les rsultats d'excution :
On peut redfinir galement les oprateurs unaires n'ayant qu'un seul oprande. Ainsi si op1 est un objet de type C1, l'opration
op1++ peut tre redfinie par une mthode statique de la classe C1 :
Ce qui a t dit ici est vrai pour la plupart des oprateurs avec cependant quelques exceptions :
les oprateurs == et != doivent tre redfinis en mme temps
les oprateurs && ,||, [], (), +=, -=, ... ne peuvent tre redfinis
2.3.2 Un exemple
On cre une classe listeDePersonnes drive de la classe ArrayList. Cette classe implmente un tableau dynamique et est prsente
dans le chapitre qui suit. De cette classe, nous n'utilisons que les lments suivants :
la mthode T.Add(Object o) permettant d'ajouter au tableau T un objet o. Ici l'objet o sera un objet personne.
la proprit T.Count qui donne le nombre d'lments du tableau T
la notation T[i] qui donne l'lment i du tableau T
La classe listeDePersonnes va hriter de tous les attributs, mthodes et proprits de la classe ArrayList.
Nous redfinissons la mthode ToString afin d'afficher une liste de personnes sous la forme (personne1, personne2, ..) o personnei est
lui-mme le rsultat de la mthode ToString de la classe personne.
Enfin nous redfinissons l'oprateur + afin de pouvoir crire l'opration l+p o l est un objet listeDePersonnes et p un objet personne.
L'opration l+p ajoute la personne p la liste de personnes l. Cette opration rend une valeur de type listeDePersonnes, ce qui permet
d'enchaner les oprateurs + comme il a t expliqu plus haut. Ainsi l'opration l+p1+p2 est interprte (priorit des oprateurs)
comme (l+p1)+p2. L'opration l+p1 rend une nouvelle liste liste de personnes l1. L'opration (l+p1)+p2 devient alors l1+p2 qui
ajoute la personne p2 la liste de personnes l1.
using System;
using System.Collections;
// classe personne
public class listeDePersonnes : ArrayList{
// redfinition oprateur +
// pour ajouter une personne la liste
public static listeDePersonnes operator +(listeDePersonnes l, personne p){
l.Add(p);
return l;
}// operator +
// toString
public override string ToString(){
// rend (l1, l2, ..., ln)
string liste="(";
int i;
// on parcourt le tableau dynamique
for (i=0;i<Count-1;i++){
liste+="["+base[i]+"]"+",";
Classes, Structures, Interfaces 52
}//for
// dernier lmenr
if(Count!=0) liste+="["+base[i]+"]";
liste+=")";
return liste;
}//ToString
public static void Main(){
// une liste de personnes
listeDePersonnes l=new listeDePersonnes();
// ajout de personnes
l=l+new personne("jean",10)+new personne("pauline",12);
// affichage
Console.Out.WriteLine("l="+l);
l=l+new personne ("tintin",27);
Console.Out.WriteLine("l="+l);
}//Main
}//class
Les rsultats :
E:\data\serge\MSNET\c#\objets\8>C:\WINNT\Microsoft.NET\Framework\v1.0.2914\csc.exe /r:personne.dll
lstpersonnes.cs
E:\data\serge\MSNET\c#\objets\8>lstpersonnes
l=([jean,10],[pauline,12])
l=([jean,10],[pauline,12],[tintin,27])
On appelle cette mthode, un indexeur car elle donne un sens l'expression obj[i] qui rappelle la notation des tableaux alors que obj
n'est pas un tableau mais un objet. La mthode get de l'objet obj est appele lorsqu'on crit variable=obj[i] et la mthode set lorsqu'on
crit obj[i]=valeur.
Pour indiquer que la mthode public personne this[int i] de la classe listeDePersonnes ne redfinit pas (override) la mthode
public object this[ int index ] de la classe ArrayList on est oblig d'ajouter le mot cl new la dclaration de l'indexeur de
listeDePersonnes. On crira donc :
Compltons cette mthode. La mthode get est appele lorsqu'on crit variable=l[i] par exemple o l est une listeDePersonnes. On doit
alors retourner la personne n i de la liste l. Ceci se fait en retournant l'objet n i de la classe ArrayList sous-jacente la classe
listeDePersonnes avec la notation base[i]. L'objet retourn tant de type Object, un transtypage vers la classe personne est ncessaire.
La mthode set est appele lorsqu'on crit l[i]=p o p est une personne. Il s'agit alors d'affecter la personne p l'lment i de la liste l.
Ici, la personne p reprsente par le mot cl value est affecte l'lment i de la classe de base ArrayList.
Maintenant, on veut pouvoir crire galement personne p=l["nom"], c.a.d indexer la liste l non plus par un n d'lment mais par un
nom de personne. Pour cela on dfinit un nouvel indexeur :
La premire ligne
indique qu'on indexe la classe listeDePersonnes par une chane de caractres N et que le rsultat de l[N] est un entier. Cet entier sera la
position dans la liste de la personne portant le nom N ou -1 si cette personne n'est pas dans la liste. On ne dfinit que la proprit
get interdisant ainsi l'criture l["nom"]=valeur qui aurait ncessit la dfinition de la proprit set. Le mot cl new n'est pas ncessaire
dans la dclaration de l'indexeur car la classe de base ArrayList ne dfinit pas d'indexeur this[string].
Dans le corps du get, on parcourt la liste des personnes la recherche du nom N pass en paramtre. Si on le trouve en position i,
on renvoie i sinon on renvoie -1.
using System;
using System.Collections;
// classe personne
public class listeDePersonnes : ArrayList{
// redfinition oprateur +
// pour ajouter une personne la liste
public static listeDePersonnes operator +(listeDePersonnes l, personne p){
l.Add(p);
return l;
}// operator +
// un indexeur
public new personne this[int i]{
get { return (personne) base[i]; }
set { base[i]=value; }
}//indexeur
// un indexeur
public int this[string N]{
get {
// on recherche la personne de nom N
int i;
for (i=0;i<Count;i++){
if (((personne) base[i]).nom==N) return i;
}//for
return -1;
}//get
}//indexeur[nom]
// toString
public override string ToString(){
// rend (l1, l2, ..., ln)
string liste="(";
int i;
// on parcourt le tableau dynamique
for (i=0;i<Count-1;i++){
liste+="["+base[i]+"]"+",";
}//for
// dernier lmenr
if(Count!=0) liste+="["+base[i]+"]";
liste+=")";
return liste;
}//ToString
public static void Main(){
// une liste de personnes
listeDePersonnes l=new listeDePersonnes();
// ajout de personnes
l=l+new personne("jean",10)+new personne("pauline",12);
// affichage
Console.Out.WriteLine("l="+l);
l=l+new personne ("tintin",27);
Console.Out.WriteLine("l="+l);
// changement lment 1
l[1]=new personne("milou",5);
// affichage lment 1
Console.Out.WriteLine("l[1]="+l[1]);
// affichage liste l
E:\data\serge\MSNET\c#\objets\9>C:\WINNT\Microsoft.NET\Framework\v1.0.2914\csc.exe /r:personne.dll
lstpersonnes.cs
Microsoft (R) Visual C# Compiler Version 7.00.9254 [CLR version v1.0.2914]
Copyright (C) Microsoft Corp 2000-2001. All rights reserved.
E:\data\serge\MSNET\c#\objets\9>lstpersonnes
l=([jean,10],[pauline,12])
l=([jean,10],[pauline,12],[tintin,27])
l[1]=milou,5
l=([jean,10],[milou,5],[tintin,27])
personne(milou)=milou,5
personne(haddock) n'existe pas
struct nomStructure{
// attributs
...
// proprits
...
// constructeurs
...
// mthodes
...
}
Il y a malgr une similitude de dclaration des diffrences importantes entre classe et structure. La notion d'hritage n'existe par
exemple pas avec les structures. Si on crit une classe qui ne doit pas tre drive quelles sont les diffrences entre structure et
classe qui vont nous aider choisir entre les deux ? Aidons-nous de l'exemple suivant pour le dcouvrir :
// structure personne
struct personne{
public string nom;
public int age;
}
// classe PERSONNE
class PERSONNE{
public string nom;
public int age;
}
// une classe de test
public class test
{
static void Main() {
// une personne p1
personne p1;
p1.nom="paul";
p1.age=10;
Console.Out.WriteLine("p1=personne("+p1.nom+","+p1.age+")");
// une personne p2
personne p2=p1;
Console.Out.WriteLine("p2=personne("+p2.nom+","+p2.age+")");
// p2 est modifi
p2.nom="nicole";
p2.age=30;
// vrification p1 et p2
Console.Out.WriteLine("p1=personne("+p1.nom+","+p1.age+")");
Console.Out.WriteLine("p2=personne("+p2.nom+","+p2.age+")");
// une PERSONNE P1
PERSONNE P1=new PERSONNE();
P1.nom="paul";
P1.age=10;
Classes, Structures, Interfaces 55
Console.Out.WriteLine("P1=PERSONNE("+P1.nom+","+P1.age+")");
// une PERSONNE P2
PERSONNE P2=P1;
Console.Out.WriteLine("P2=PERSONNE("+P2.nom+","+P2.age+")");
// P2 est modifi
P2.nom="nicole";
P2.age=30;
// vrification P1 et P2
Console.Out.WriteLine("P1=PERSONNE("+P1.nom+","+P1.age+")");
Console.Out.WriteLine("P2=PERSONNE("+P2.nom+","+P2.age+")");
}//Main
}//classe
p1=personne(paul,10)
p2=personne(paul,10)
p1=personne(paul,10)
p2=personne(nicole,30)
P1=PERSONNE(paul,10)
P2=PERSONNE(paul,10)
P1=PERSONNE(nicole,30)
P2=PERSONNE(nicole,30)
L o dans les pages prcdentes de ce chapitre on utilisait une classe personne, nous utilisons maintenant une structure personne :
struct personne{
public string nom;
public int age;
}
La dclaration personne p1; cre une structure (nom,age) et la valeur de p1 est cette structure elle-mme. Rappelons que dans le
cas d'une classe l'opration quivalente tait :
personne p1 = new personne(...);
qui crait un objet personne (grosso modo l'quivalent de notre structure) et p1 tait alors l'adresse (la rfrence) de cet objet.
Rsumons
" dans le cas de la structure, la valeur de p1 est la structure elle-mme
" dans le cas de la classe, la valeur de p1 est l'adresse de l'objet cr
Structure p1
p1 nom
age
Objet p1
nom
p1 age
p1 paul
10
p2 paul
10
La structure de p1 est donc duplique dans p2. C'est une recopie de valeur. Dans le cas des classes, la valeur de p1 est recopie
dans p2, mais comme cette valeur est en fait l'adresse de l'objet, celui-ci n'est pas dupliqu. Il a simplement deux rfrences sur lui :
Dans le cas de la structure, si on modifie la valeur de p2 on ne modifie pas la valeur de p1, ce que montre le programme. Dans le cas
de l'objet, si on modifie l'objet point par p2, celui point par p1 est modifi puisque c'est le mme. C'est ce que montrent galement
les rsultats du programme.
Une fois cette diffrence fondamentale comprise, la structure se montre trs proche de la classe comme le montre le nouvel
exemple suivant :
using System;
// structure personne
struct personne{
// attributs
private string _nom;
private int _age;
// proprits
public string nom{
get {return _nom;}
set {_nom=value;}
}//nom
public int age{
get {return _age;}
set {_age=value;}
}//nom
// Constructeur
public personne(string NOM, int AGE){
_nom=NOM;
_age=AGE;
}//constructeur
// TOSTRING
public override string ToString(){
return "personne("+nom+","+age+")";
}//ToString
}
// une classe de test
public class test {
static void Main() {
// une personne p1
personne p1=new personne("paul",10);
Console.Out.WriteLine("p1="+p1);
// une personne p2
personne p2=p1;
Console.Out.WriteLine("p2="+p2);
// p2 est modifi
p2.nom="nicole";
p2.age=30;
// vrification p1 et p2
Console.Out.WriteLine("p1="+p1);
Console.Out.WriteLine("p2="+p2);
}//Main
}//classe
p1=personne(paul,10)
p2=personne(paul,10)
p1=personne(paul,10)
p2=personne(nicole,30)
La seule notable diffrence ici entre structure et classe, c'est qu'avec une classe les objets p1 et p2 auraient eu la mme valeur la fin
du programme, celle de p2.
La proprit Current et les mthodes MoveNext et Reset devront tre dfinies dans la classe C.
using System;
public struct lve{
public string nom;
public double note;
// constructeur
public lve(string NOM, double NOTE){
nom=NOM;
note=NOTE;
}//constructeur
}//lve
// ToString
public override string ToString(){
string valeur="matire="+matire +", notes=(";
int i;
// on concatne toutes les notes
for (i=0;i<lves.Length-1;i++){
valeur+="["+lves[i].nom+","+lves[i].note+"],";
};
//dernire note
if(lves.Length!=0){ valeur+="["+lves[i].nom+","+lves[i].note+"]";}
valeur+=")";
// fin
return valeur;
}//ToString
}//classe
La classe notes rassemble les notes d'une classe dans une matire :
public class notes{
// attribut
protected string matire;
protected lve[] lves;
Nous dcidons de driver cette classe notes dans une classe notesStats qui aurait deux attributs supplmentaires, la moyenne et l'cart-
type des notes :
Cela signifie que la classe notesStats doit avoir deux mthodes appeles moyenne et cartType avec la signature indique dans l'interface
Istats. La classe notesStats est la suivante :
// ToString
public override string ToString(){
return base.ToString()+",moyenne="+_moyenne+",cart-type="+_cartType;
}//ToString
// mthodes de l'interface Istats
public double moyenne(){
// rend la moyenne des notes
return _moyenne;
}//moyenne
public double cartType(){
// rend l'cart-type
return _cartType;
}//cartType
}//classe
La moyenne _moyenne et l'cart-type _ecartType sont calculs ds la construction de l'objet. Aussi les mthodes moyenne et cartType
n'ont-elles qu' rendre la valeur des attributs _moyenne et _ecartType. Les deux mthodes rendent -1 si le tableau des lves est vide.
// classe de test
public class test{
public static void Main(){
// qqs lves & notes
lve[] ELEVES=new lve[] { new lve("paul",14),new lve("nicole",16), new lve("jacques",18)};
// qu'on enregistre dans un objet notes
notes anglais=new notes("anglais",ELEVES);
// et qu'on affiche
Console.Out.WriteLine(""+anglais);
// idem avec moyenne et cart-type
anglais=new notesStats("anglais",ELEVES);
Console.Out.WriteLine(""+anglais);
}
matire=anglais, notes=([paul,14],[nicole,16],[jacques,18])
matire=anglais, notes=([paul,14],[nicole,16],[jacques,18]),moyenne=16,cart-type=1,63299316185545
La classe notesStats aurait trs bien pu implmenter les mthodes moyenne et cartType pour elle-mme sans indiquer qu'elle
implmentait l'interface Istats. Quel est donc l'intrt des interfaces ? C'est le suivant : une fonction peut admettre pour paramtre
une donne ayant le type d'une interface I. Tout objet d'une classe C implmentant l'interface I pourra alors tre paramtre de cette
fonction. Considrons l'exemple suivant :
using System;
// une interface Iexemple
public interface Iexemple{
int ajouter(int i,int j);
int soustraire(int i,int j);
}
public class classe1: Iexemple{
public int ajouter(int a, int b){
return a+b+10;
}
public int soustraire(int a, int b){
return a-b+20;
}
}//classe
public class classe2: Iexemple{
public int ajouter(int a, int b){
return a+b+100;
}
public int soustraire(int a, int b){
return a-b+200;
}
}//classe
L'interface Iexemple dfinit deux mthodes ajouter et soustraire. Les classes classe1 et classe2 implmentent cette interface. On
remarquera que ces classes ne font rien d'autre ceci par souci de simplification de l'exemple. Maintenant considrons l'exemple
suivant :
// classe de test
public class test{
// une fonction statique
private static void calculer(int i, int j, Iexemple inter){
Console.Out.WriteLine(inter.ajouter(i,j));
Console.Out.WriteLine(inter.soustraire(i,j));
}//calculer
// la fonction Main
public static void Main(){
// cration de deux objets classe1 et classe2
classe1 c1=new classe1();
classe2 c2=new classe2();
// appels de la fonction statique calculer
calculer(4,3,c1);
calculer(14,13,c2);
}//Main
}//classe test
La fonction statique calculer admet pour paramtre un lment de type Iexemple. Elle pourra donc recevoir pour ce paramtre aussi
bien un objet de type classe1 que de type classe2. C'est ce qui est fait dans la fonction Main avec les rsultats suivants :
17
21
127
201
On voit donc qu'on a l une proprit proche du polymorphisme vu pour les classes. Si donc un ensemble de classes Ci non lies
entre-elles par hritage (donc on ne peut utiliser le polymorphisme de l'hritage) prsentent un ensemble de mthodes de mme
signature, il peut tre intressant de regrouper ces mthodes dans une interface I dont hriteraient toutes les classes concernes.
Des instances de ces classes Ci peuvent alors tre utilises comme paramtres de fonctions admettant un paramtre de type I, c.a.d.
des fonctions n'utilisant que les mthodes des objets Ci dfinies dans l'interface I et non les attributs et mthodes particuliers des
diffrentes classes Ci.
Notons enfin que l'hritage d'interfaces peut tre multiple, c.a.d. qu'on peut crire
Console.Out.WriteLine(...)
Namespace: System
Assembly: Mscorlib (in Mscorlib.dll
on dcouvre qu'elle fait partie de l'espace de noms System. Cela signifie que la classe Console devrait tre dsigne par System.Console et
on devrait en fait crire :
System.Console.Out.WriteLine(...)
using System;
...
Console.Out.WriteLine(...)
On dit qu'on importe l'espace de noms System avec la clause using. Lorsque le compilateur va rencontrer le nom d'une classe (ici
Console) il va chercher la trouver dans les diffrents espaces de noms imports par les clauses using. Ici il trouvera la classe Console
dans l'espace de noms System. Notons maintenant la seconde information attache la classe Console :
Cette ligne indique dans quelle "assemblage" se trouve la dfinition de la classe Console. Lorsqu'on compile en-dehors de Visual
Studio.NET et qu'on doit donner les rfrences des diffrentes dll contenant les classes que l'on doit utiliser cette information peut
s'avrer utile. On rappelle que pour rfrencer les dll ncessaires la compilation d'une classe, on crit :
Lorsqu'on cre une classe, on peut la crer l'intrieur d'un espace de noms. Le but de ces espaces de noms est d'viter les conflits
de noms entre classes lorsque celles-ci sont vendues par exemple. Considrons deux entreprises E1 et E2 distribuant des classes
empaquetes respectivement dans les dll, E1.dll et E2.dll. Soit un client C qui achte ces deux ensembles de classes dans lesquelles
les deux entreprises ont dfini toutes deux une classe personne. Le client C compile un programme de la faon suivante :
Si le source prog.cs utilise la classe personne, le compilateur ne saura pas s'il doit prendre la classe personne de E1.dll ou celle de E2.dll. Il
signalera une erreur. Si l'entreprise E1 prend soin de crer ses classes dans un espace de noms appel E1 et l'entreprise E2 dans un
espace de noms appel E2, les deux classes personne s'appelleront alors E1.personne et E2.personne. Le client devra employer dans ses
classes soit E1.personne, soit E2.personne mais pas personne. L'espace de noms permet de lever l'ambigut.
namespace espaceDeNoms{
// dfinition de la classe
}
Pour l'exemple, crons dans un espace de noms notre classe personne tudie prcdemment. Nous choisirons istia.st comme espace
de noms. La classe personne devient :
nous avons import l'espace de noms istia.st avec une clause using :
using istia.st;
Cela produit un fichier test1.exe qui excut donne les rsultats suivants :
Jean,Dupont,30
On se place dans le cas simplifi d'un contribuable n'ayant que son seul salaire dclarer :
on calcule le nombre de parts du salari nbParts=nbEnfants/2 +1 s'il n'est pas mari, nbEnfants/2+2 s'il est mari, o
nbEnfants est son nombre d'enfants.
s'il a au moins trois enfants, il a une demie part de plus
on calcule son revenu imposable R=0.72*S o S est son salaire annuel
on calcule son coefficient familial QF=R/nbParts
on calcule son impt I. Considrons le tableau suivant :
Chaque ligne a 3 champs. Pour calculer l'impt I, on recherche la premire ligne o QF<=champ1. Par exemple, si QF=23000 on
trouvera la ligne
24740 0.15 2072.5
L'impt I est alors gal 0.15*R - 2072.5*nbParts. Si QF est tel que la relation QF<=champ1 n'est jamais vrifie, alors ce sont les
coefficients de la dernire ligne qui sont utiliss. Ici :
0 0.65 49062
ce qui donne l'impt I=0.65*R - 49062*nbParts.
Un objet impt est cr avec les donnes permettant le calcul de l'impt d'un contribuable. C'est la partie stable de l'objet. Une fois
cet objet cr, on peut appeler de faon rpte sa mthode calculer qui calcule l'impt du contribuable partir de son statut
marital (mari ou non), son nombre d'enfants et son salaire annuel.
using System;
class test
{
public static void Main()
{
// programme interactif de calcul d'impt
// l'utilisateur tape trois donnes au clavier : mari nbEnfants salaire
// le programme affiche alors l'impt payer
E:\data\serge\MSNET\c#\impots\3>test
Paramtres du calcul de l'impt au format mari nbEnfants salaire ou rien pour arrter :q s d
syntaxe : mari nbEnfants salaire
mari : o pour mari, n pour non mari
nbEnfants : nombre d'enfants
salaire : salaire annuel en F
Argument mari incorrect : tapez o ou n
Paramtres du calcul de l'impt au format mari nbEnfants salaire ou rien pour arrter :o s d
syntaxe : mari nbEnfants salaire
mari : o pour mari, n pour non mari
nbEnfants : nombre d'enfants
salaire : salaire annuel en F
Argument nbEnfants incorrect : tapez un entier positif ou nul
Classes, Structures, Interfaces 64
Paramtres du calcul de l'impt au format mari nbEnfants salaire ou rien pour arrter :o 2 d
syntaxe : mari nbEnfants salaire
mari : o pour mari, n pour non mari
nbEnfants : nombre d'enfants
salaire : salaire annuel en F
Argument salaire incorrect : tapez un entier positif ou nul
Paramtres du calcul de l'impt au format mari nbEnfants salaire ou rien pour arrter :q s d f
syntaxe : mari nbEnfants salaire
mari : o pour mari, n pour non mari
nbEnfants : nombre d'enfants
salaire : salaire annuel en F
Paramtres du calcul de l'impt au format mari nbEnfants salaire ou rien pour arrter :o 2 200000
impt=22504 F
Paramtres du calcul de l'impt au format mari nbEnfants salaire ou rien pour arrter :
On tape en (1) le nom de la classe dsire. Cela ramne en (2) divers thmes possibles. On choisit celui qui convient et on a le
rsultat en (3), ici la classe HashTable. Cette mthode convient si on connat le nom de la classe que l'on cherche. Si on veut explorer
la liste des possibilts offertes par la plate-forme .NET ou pourra utiliser le fichier HTML C:\Program
Files\Microsoft.Net\FrameworkSDK\StartHere.htm qui sert de point de dpart pour l'aide sur le SDK :
L, on suivra le lien .NET Framework Class Library. On y trouve la liste de toutes les classes de .NET :
On y trouve le prototype de la classe ainsi que des exemples d'utilisation. En suivant ci-dessus le lien HashTable Members, on a accs
la description complte de la classe :
3.2.1 Help/Contents
Prenez l'option Help/Contents du menu.
L'aide au langage C# est accessible via Visual Studio.NET/Visual Basic and Visual C#/Visual C# language/C# Programmer's Reference :
A partir de l, les diffrentes sous-rubriques nous permettent d'avoir de l'aide sur diffrents thmes de C#. On prtera attention aux
tutoriels de C# :
3.2.2 Help/Index
L'option Help/index permet de chercher une aide plus cible que l'aide prcdente. Il suffit de taper le mot cl cherch :
// split, join
using System;
public class splitJoin{
public static void Main(string[] args){
// la ligne analyser
string ligne ="un:deux::trois:";
// les sparateurs de champs
char[] sparateurs=new char[] {':'};
// split
string[] champs=ligne.Split(sparateurs);
int i;
for (i=0;i<champs.Length;i++)
Console.Out.WriteLine("Champs[" + i + "]=" + champs[i]);
// join
Console.Out.WriteLine("join=[" + System.String.Join(":",champs)+"]");
// attente
Console.ReadLine();
}//Main
}//classe
Champs[0]=un
Champs[1]=deux
Champs[2]=
Champs[3]=trois
Champs[4]=
join=[un:deux::trois:]
separator tableau de caractres. Ces caractres reprsentent les caractres utiliss pour sparer les champs de la
chane de caractres. Ainsi si la chane est champ1, champ2, champ3 on pourra utiliser separator=new
char[] {','}. Si le sparateur est une suite d'espaces on utilisera separator=null.
rsultat tableau de chanes de caractres o chaque lment est un champ de la chane.
// tableaux
// imports
using System;
public class tab1{
public static void Main(string[] args){
// lecture des lments d'un tableau taps au clavier
Boolean termin=false;
int i=0;
double[] lments1=null;
double[] lments2=null;
double lment=0;
string rponse=null;
Boolean erreur=false;
while (! termin){
// question
Console.Out.Write("Elment (rel) " + i + " du tableau (rien pour terminer) : ");
// lecture de la rponse
rponse=Console.ReadLine().Trim();
// fin de saisie si chane vide
if (rponse.Equals("")) break;
// vrification saisie
try{
lment=Double.Parse(rponse);
erreur=false;
}catch {
Console.Error.WriteLine("Saisie incorrecte, recommencez");
erreur=true;
}//try-catch
// si pas d'erreur
if (! erreur){
// un lmt de plus dans le tableau
i+=1;
// nouveau tableau pour accueillir le nouvel lment
lments2=new double[i];
// copie ancien tableau vers nouveau tableau
if(i!=1) Array.Copy(lments1,lments2,i-1);
// nouveau tableau devient ancien tableau
Exemples de classes .NET 75
lments1=lments2;
// plus besoin du nouveau tableau
lments2=null;
// insertion nouvel lment
lments1[i-1]=lment;
}//if
}//while
// affichage tableau non tri
System.Console.Out.WriteLine("Tableau non tri");
for (i=0;i<lments1.Length;i++)
Console.Out.WriteLine("lments[" + i + "]=" + lments1[i]);
// tri du tableau
System.Array.Sort(lments1);
// affichage tableau tri
System.Console.Out.WriteLine("Tableau tri");
for (i=0;i<lments1.Length;i++)
Console.Out.WriteLine("lments[" + i + "]=" + lments1[i]);
// Recherche
while ( ! termin){
// question
Console.Out.WriteLine("Elment cherch (rien pour arrter) : ");
// lecture-vrification rponse
rponse=Console.ReadLine().Trim();
// fini ?
if (rponse.Equals("")) break;
// vrification
try{
lment=Double.Parse(rponse);
erreur=false;
}catch {
Console.Error.WriteLine("Erreur, recommencez...");
erreur=true;
}//try-catch
// si pas d'erreur
if (! erreur){
// on cherche l'lment dans le tableau tri
i=System.Array.BinarySearch(lments1,0,lments1.Length,lment);
// Affichage rponse
if (i>=0)
Console.Out.WriteLine("Trouv en position " + i);
else Console.Out.WriteLine("Pas dans le tableau");
}//if
}//while
}//Main
}//classe
La premire partie du programme construit un tableau partir de donnes numriques tapes au clavier. Le tableau ne peut tre
dimensionn priori puisqu'on ne connat pas le nombre d'lments que va taper l'utilisateur. On travaille alors avec deux tableaux
lments1 et lments2.
Le tableau lments1 contient les valeurs actuellement saisies. Lorsque l'utilisateur ajoute une nouvelle valeur, on construit un tableau
lments2 avec un lment de plus que lments1, on copie le contenu de lments1 dans lments2 (Array.Copy), on fait "pointer"
lments1 sur lments2 et enfin on ajoute le nouvel lment lments1. C'est un processus complexe qui peut tre simplifi si au lieu
d'utiliser un tableau de taille fixe (Array) on utilise un tableau de taille variable (ArrayList).
Le tableau est tri avec la mthode Array.Sort. Cette mthode peut tre appele avec diffrents paramtres prcisant les rgles de
tri. Sans paramtres, c'est ici un tri en ordre croissant qui est fait par dfault. Enfin, la mthode Array.BinarySearch permet de
chercher un lment dans un tableau tri.
// constructeur
ArrayList()
// construit un tableau vide
// proprits
int Count
// nombre d'lments du tableau
// mthodes
public virtual int Add(object value);
ajoute l'objet value la fin du tableau
public virtual void AddRange(System.Collections.ICollection c)
ajoute la collection (peut tre un tableau) la fin du tableau
public virtual void Clear()
efface le tableau
public virtual int IndexOf(object value);
indice de l'objet value dans le tableau ou -1 s'il n'existe pas
public virtual int IndexOf(object value, int startIndex);
idem mais en cherchant partir de l'lment n startIndex
public virtual int LastIndexOf(object value);
public virtual int LastIndexOf(object value, int startIndex);
idem mais rend l'indice de la dernire occurrence de value dans le tableau
public virtual void Remove(object obj);
enve l'objet obj s'il existe dans le tableau
public virtual void RemoveAt(int index);
enlve l'lment i du tableau
public virtual int BinarySearch(object value)
rend la position de l'objet value dans le tableau ou -1 s'il ne s'y trouve pas. Le tableau doit tre tri
public virtual void Sort()
trie le tableau. Celui-ci doit contenir des objets ayant une relation d'ordre prdfinie (chanes, nombres)
public virtual void Sort(System.Collections.IComparer comparer)
trie le tableau selon la relation d'ordre tablie par la fonction comparer
Reprenons l'exemple trait avec des objets de type Array et traitons-le avec des objets de type ArrayList :
// tableaux dynamiques
// imports
using System;
using System.Collections;
public class tab1{
public static void Main(string[] args){
// lecture des lments d'un tableau taps au clavier
Boolean termin=false;
int i=0;
ArrayList lments=new ArrayList();
double lment=0;
string rponse=null;
Boolean erreur=false;
while (! termin){
Exemples de classes .NET 77
// question
Console.Out.Write("Elment (rel) " + i + " du tableau (rien pour terminer) : ");
// lecture de la rponse
rponse=Console.ReadLine().Trim();
// fin de saisie si chane vide
if (rponse.Equals("")) break;
// vrification saisie
try{
lment=double.Parse(rponse);
erreur=false;
}catch {
Console.Error.WriteLine("Saisie incorrecte, recommencez");
erreur=true;
}//try-catch
// si pas d'erreur
if (! erreur){
// un lmt de plus dans le tableau
lments.Add(lment);
}//if
}//while
// affichage tableau non tri
System.Console.Out.WriteLine("Tableau non tri");
for (i=0;i<lments.Count;i++)
Console.Out.WriteLine("lments[" + i + "]=" + lments[i]);
// tri du tableau
lments.Sort();
// affichage tableau tri
System.Console.Out.WriteLine("Tableau tri");
for (i=0;i<lments.Count;i++)
Console.Out.WriteLine("lments[" + i + "]=" + lments[i]);
// Recherche
while ( ! termin){
// question
Console.Out.WriteLine("Elment cherch (rien pour arrter) : ");
// lecture-vrification rponse
rponse=Console.ReadLine().Trim();
// fini ?
if (rponse.Equals("")) break;
// vrification
try{
lment=Double.Parse(rponse);
erreur=false;
}catch {
Console.Error.WriteLine("Erreur, recommencez...");
erreur=true;
}//try-catch
// si pas d'erreur
if (! erreur){
// on cherche l'lment dans le tableau tri
i=lments.BinarySearch(lment);
// Affichage rponse
if (i>=0)
Console.Out.WriteLine("Trouv en position " + i);
else Console.Out.WriteLine("Pas dans le tableau");
}//if
}//while
}//Main
}//classe
E:\data\serge\MSNET\c#\bases\3>sort2
Elment (rel) 0 du tableau (rien pour terminer) : 6,7
Elment (rel) 0 du tableau (rien pour terminer) : -4,5
Elment (rel) 0 du tableau (rien pour terminer) : 8,3
Elment (rel) 0 du tableau (rien pour terminer) : 2
Elment (rel) 0 du tableau (rien pour terminer) :
Tableau non tri
lments[0]=6,7
lments[1]=-4,5
lments[2]=8,3
lments[3]=2
Tableau tri
lments[0]=-4,5
lments[1]=2
lments[2]=6,7
lments[3]=8,3
Elment cherch (rien pour arrter) :
2
Trouv en position 1
Elment cherch (rien pour arrter) :
1
Pas dans le tableau
Elment cherch (rien pour arrter) :
cl valeur
cl1 valeur1
cl2 valeur2
.. ...
Les cls sont uniques, c.a.d. qu'il ne peut y avoir deux cls indentiques. Les mthodes et proprits principales de la classe
Hashtable sont les suivantes :
using System;
using System.Collections;
public class HashTable1{
public static void Main(String[] args){
String[] liste=new String[] {"jean:20","paul:18","mlanie:10","violette:15"};
int i;
String[] champs=null;
char[] sparateurs=new char[]{':'};
// remplissage du dictionnaire
Hashtable dico=new Hashtable();
for (i=0; i<=liste.Length-1;i++){
champs=liste[i].Split(sparateurs);
dico.Add(champs[0],champs[1]);
}//for
// nbre d'lments dans le dictionnaire
Console.Out.WriteLine("Le dictionnaire a " + dico.Count + " lments");
// liste des cls
Console.Out.WriteLine("[Liste des cls]");
IEnumerator cls=dico.Keys.GetEnumerator();
while(cls.MoveNext()){
Console.Out.WriteLine(cls.Current);
}
// liste des valeurs
Console.Out.WriteLine("[Liste des valeurs]");
IEnumerator valeurs=dico.Values.GetEnumerator();
while(valeurs.MoveNext()){
Console.Out.WriteLine(valeurs.Current);
}
// liste des cls & valeurs
Console.Out.WriteLine("[Liste des cls & valeurs]");
cls.Reset();
while(cls.MoveNext()){
Console.Out.WriteLine("cl="+cls.Current+" valeur="+dico[cls.Current]);
}
// on supprime la cl "paul"
Console.Out.WriteLine("[Suppression d'une cl]");
dico.Remove("paul");
// liste des cls & valeurs
Console.Out.WriteLine("[Liste des cls & valeurs]");
cls=dico.Keys.GetEnumerator();
while(cls.MoveNext()){
Console.Out.WriteLine("cl="+cls.Current+" valeur="+dico[cls.Current]);
}
// recherche dans le dictionnaire
String nomCherch=null;
Console.Out.Write("Nom recherch (rien pour arrter) : ");
nomCherch=Console.ReadLine().Trim();
Object value=null;
while (! nomCherch.Equals("")){
E:\data\serge\MSNET\c#\bases\7>hashtable1
Le dictionnaire a 4 lments
[Liste des cls]
mlanie
paul
violette
jean
[Liste des valeurs]
10
18
15
20
[Liste des cls & valeurs]
cl=mlanie valeur=10
cl=paul valeur=18
cl=violette valeur=15
cl=jean valeur=20
[Suppression d'une cl]
[Liste des cls & valeurs]
cl=mlanie valeur=10
cl=violette valeur=15
cl=jean valeur=20
Nom recherch (rien pour arrter) : paul
Nom paul inconnu
Nom recherch (rien pour arrter) : jean
jean,20
Nom recherch (rien pour arrter) :
Le programme utilise galement un objet Ienumerator pour parcourir les collections de cls et de valeurs du dictionnaire de type
ICollection (cf ci-dessus les proprits Keys et Values). Une collection est un ensemble d'objets qu'on peut parcourir. L'interface
ICollection est dfinie comme suit :
La proprit Count nous permet de connatre le nombre d'lments de la collection. L'interface ICollection drive de l'interface
IEnumerable :
Cette interface n'a qu'une mthode GetEnumerator qui nous permet d'obtenir un objet de type IEnumerator :
La mthode GetEnumerator() d'une collection ICollection nous permet de parcourir la collection avec les mthodes suivantes :
MoveNext positionne sur l'lment suivant de la collection. Rend vrai (true) si cet lment existe, faux (false)
sinon. Le premier MoveNext positionne sur le 1er lment. L'lment "courant" de la collection est
alors disponible dans la proprit Current de l'numrateur
Current proprit : lment courant de la collection
Reset repositionne l'numrateur en dbut de collection, c.a.d. avant le 1er lment.
La structure d'itration sur les lments d'une collection (ICollection) C est donc la suivante :
// dfinir la collection
ICollection C=...;
// obtenir un numrateur de cette collection
IEnumerator itrateur=C.GetEnumerator();
// parcourir la collection avec cet numrateur
while(itrateur.MoveNext()){
// on a un lment courant
// exploiter itrateur.Current
}//while
// constructeur
public StreamReader(string path)
ouvre un flux partir du fichier path. Une exception est lance si celui-ci n'existe pas
// mthodes
public virtual void Close()
ferme le flux
public virtual string ReadLine()
lit une ligne du flux ouvert
public virtual string ReadToEnd()
lit le reste du flux depuis la position courante
Voici un exemple :
E:\data\serge\MSNET\c#\bases\4>more infos.txt
12620:0:0
13190:0,05:631
15640:0,1:1290,5
E:\data\serge\MSNET\c#\bases\4>file1
12620:0:0
13190:0,05:631
15640:0,1:1290,5
24740:0,15:2072,5
31810:0,2:3309,5
39970:0,25:4900
48360:0,3:6898,5
55790:0,35:9316,5
92970:0,4:12106
127860:0,45:16754,5
151250:0,5:23147,5
172040:0,55:30710
195000:0,6:39312
0:0,65:49062
// constructeur
public StreamWriter(string path)
ouvre un flux d'criture dans le fichier path. Une exception est lance si celui-ci ne peut tre cr.
// proprits
public bool AutoFlush { virtual get; virtual set; }
// si gal vrai, l'criture dans le flux ne passe pas par l'intermdiaire d'une mmoire tampon sinon
l'criture dans le flux n'est pas immdiate : il y a d'abord criture dans une mmoire tampon puis dans le
flux lorsque la mmoire tampon est pleine. Par dfaut c'est le mode bufferis qui est utilis. Il convient bien
pour les flux fichier mais gnralement pas pour les flux rseau.
public string NewLine { virtual get; virtual set; }
pour fixer ou connatre la marque de fin de ligne utiliser par la mthode WriteLine
// mthodes
public virtual void Close()
ferme le flux
public virtual string WriteLine(string value)
crit value dans le flux ouvert suivi d'un saut de ligne
public virtual string Write(string value)
idem mais sans le saut de ligne
public virtual void Flush()
crit la mmoire tampon dans le flux si on travaille en mode bufferis
E:\data\serge\MSNET\c#\bases\4b>file1
ligne (rien pour arrter) : ligne1
ligne (rien pour arrter) : ligne2
ligne (rien pour arrter) : ligne3
ligne (rien pour arrter) :
E:\data\serge\MSNET\c#\bases\4b>more infos.txt
ligne1
ligne2
ligne3
Un lment dans un modle peut tre prsent en 1 ou plusieurs exemplaires. Considrons quelques exemples autour du symbole \d
qui reprsente 1 chiffre :
modle signification
\d un chiffre
\d? 0 ou 1 chiffre
\d* 0 ou davantage de chiffres
\d+ 1 ou davantage de chiffres
\d{2} 2 chiffres
\d{3,} au moins 3 chiffres
\d{5,7} entre 5 et 7 chiffres
Imaginons maintenant le modle capable de dcrire le format attendu pour une chane de caractres :
modle signification
^modle le modle commence la chane
modle$ le modle finit la chane
^modle$ le modle commence et finit la chane
modle le modle est cherch partout dans la chane en commenant par le dbut de celle-ci.
Les sous-ensembles d'un modle peuvent tre "rcuprs". Ainsi non seulement, on peut vrifier qu'une chane correspond un
modle particulier mais on peut rcuprer dans cette chane les lments correspondant aux sous-ensembles du modle qui ont t
entours de parenthses. Ainsi si on analyse une chane contenant une date jj/mm/aa et si on veut de plus rcuprer les lments
jj, mm, aa de cette date on utilisera le modle (\d\d)/(\d\d)/(\d\d).
Une fois l'expression rgulire modle construit, on peut la comparer des chanes de caractres avec la mthode IsMatch :
// expression rgulires
using System;
using System.Text.RegularExpressions;
public class regexp1{
public static void Main(){
// une expression rgulire modle
string modle1=@"^\s*\d+\s*$";
Regex regex1=new Regex(modle1);
// comparer un exemplaire au modle
string exemplaire1=" 123 ";
if (regex1.IsMatch(exemplaire1)){
affiche("["+exemplaire1 + "] correspond au modle ["+modle1+"]");
}else{
affiche("["+exemplaire1 + "] ne correspond pas au modle ["+modle1+"]");
}//if
string exemplaire2=" 123a ";
if (regex1.IsMatch(exemplaire2)){
affiche("["+exemplaire2 + "] correspond au modle ["+modle1+"]");
}else{
affiche("["+exemplaire2 + "] ne correspond pas au modle ["+modle1+"]");
}//if
}//Main
public static void affiche(string msg){
Console.Out.WriteLine(msg);
}//affiche
}//classe
// expression rgulires
using System;
using System.Text.RegularExpressions;
public class regexp1{
public static void Main(){
// plusieurs occurrences du modle dans l'exemplaire
string modle2=@"\d+";
Regex regex2=new Regex(modle2);
string exemplaire3=" 123 456 789 ";
MatchCollection rsultats=regex2.Matches(exemplaire3);
affiche("Modle=["+modle2+"],exemplaire=["+exemplaire3+"]");
affiche("Il y a " + rsultats.Count + " occurrences du modle dans l'exemplaire ");
for (int i=0;i<rsultats.Count;i++){
affiche(rsultats[i].Value+" en position " + rsultats[i].Index);
}//for
}//Main
public static void affiche(string msg){
Console.Out.WriteLine(msg);
}//affiche
}//classe
La classe MatchCollection a une proprit Count qui est le nombre d'lments de la collection. Si rsultats est un objet
MatchCollection, rsultats[i] est l'lment i de cette collection et est de type Match. Dans notre exemple, rsultats est l'ensemble des
lments de la chane exemplaire3 correspondant au modle modle2 et rsultats[i] l'un de ces lments. La classe Match a deux
proprits qui nous intressent ici :
" Value : la valeur de l'objet Match donc l'lment correspondant au modle
" Index : la position o l'lment a t trouv dans la chane explore
// expression rgulires
using System;
using System.Text.RegularExpressions;
public class regexp1{
public static void Main(){
// capture d'lments dans le modle
string modle3=@"(\d\d):(\d\d):(\d\d)";
Regex regex3=new Regex(modle3);
string exemplaire4="Il est 18:05:49";
// vrification modle
Match rsultat=regex3.Match(exemplaire4);
if (rsultat.Success){
// l'exemplaire correspond au modle
affiche("L'exemplaire ["+exemplaire4+"] correspond au modle ["+modle3+"]");
// on affiche les groupes
for (int i=0;i<rsultat.Groups.Count;i++){
affiche("groupes["+i+"]=["+rsultat.Groups[i].Value+"] en position "+rsultat.Groups[i].Index);
}//for
}else{
// l'exemplaire ne correspond pas au modle
affiche("L'exemplaire["+exemplaire4+" ne correspond pas au modle ["+modle3+"]");
}
}//Main
// vrification modle
Match rsultat=regex3.Match(exemplaire4);
if (rsultat.Success){
// l'exemplaire correspond au modle
affiche("L'exemplaire ["+exemplaire4+"] correspond au modle ["+modle3+"]");
// on affiche les groupes
for (int i=0;i<rsultat.Groups.Count;i++){
affiche("groupes["+i+"]=["+rsultat.Groups[i].Value+"] en position "+rsultat.Groups[i].Index);
}//for
}else{
La chane exemplaire4 est compare au modle regex3 au travers de la mthode Match. Celle-ci rend un objet Match dj prsent.
Nous utilisons ici deux nouvelles proprits de cette classe :
" Success : indique s'il y a eu correspondance
" Groups : collection o
o Groups[0] correspond la partie de la chane correspondant au modle
o Groups[i] (i>=1) correspond au groupe de parenthses n i
// expression rgulires
using System;
using System.Text.RegularExpressions;
public class regexp1{
public static void Main(){
// une expression rgulire modle
string modle,chaine;
Regex regex=null;
MatchCollection rsultats;
// on demande l'utilisateur les modles et les exemplaires comparer celui-ci
while(true){
// on demande le modle
Console.Out.Write("Tapez le modle tester ou fin pour arrter :");
modle=Console.In.ReadLine();
// fini ?
if(modle.Trim().ToLower()=="fin") break;
// on cre l'exepression rgulire
try{
regex=new Regex(modle);
}catch(Exception ex){
Console.Error.WriteLine("Erreur : "+ex.Message);
continue;
}//trycatch
// on demande l'utilisateur les exemplaires comparer au modle
while(true){
Console.Out.Write("Tapez la chane comparer au modle ["+modle+"] ou fin pour arrter :");
chaine=Console.In.ReadLine();
// fini ?
if(chaine.Trim().ToLower()=="fin") break;
// on fait la comparaison
rsultats=regex.Matches(chaine);
// succs ?
if(rsultats.Count==0){
Console.Out.WriteLine("Je n'ai pas trouv de correspondances");
continue;
}//if
// on affiche les lments correspondant au modle
for(int i=0;i<rsultats.Count;i++){
Console.Out.WriteLine("J'ai trouv la correspondance ["+rsultats[i].Value
+"] en position "+rsultats[i].Index);
// des sous-lments
if(rsultats[i].Groups.Count!=1){
for(int j=1;j<rsultats[i].Groups.Count;j++){
Console.Out.WriteLine("\tsous-lment ["+rsultats[i].Groups[j].Value+"] en position "+
rsultats[i].Groups[j].Index);
}//for j
}//if
}//for i
// chane suivante
}//while
// modle suivant
}//while
}//Main
public static void affiche(string msg){
Console.Out.WriteLine(msg);
}//affiche
}//classe
Le sparateur de champs de lachane est ici un des caractres du tableau separator. La mthode Split de la classe Regex nous permet
d'exprimer le sparateur en fonction d'un modle :
Supposons par exemple que vous ayez dans un fichier texte des lignes de la forme champ1, champ2, .., champn. Les champs sont
spars par une virgule mais celle-ci peut tre prcde ou suivie d'espaces. La mthode Split de la classe string ne convient alors pas.
Celle de la mthode RegEx apporte la solution. Si ligne est la ligne lue, les champs pourront tre obtenus par
string[] champs=new Regex("s*,\s*").Split(ligne);
using System;
using System.Text.RegularExpressions;
public class split1{
public static void Main(){
// une ligne
string ligne="abc , def , ghi";
// un modle
Regex modle=new Regex(@"\s*,\s*");
// dcomposition de ligne en champs
string[] champs=modle.Split(ligne);
// affichage
for(int i=0;i<champs.Length;i++){
Console.Out.WriteLine("champs["+i+"]=["+champs[i]+"]");
}//for
}//Main
}//classe
champs[0]=[abc]
champs[1]=[def]
champs[2]=[ghi]
paul : 10
helene : 15
jacques : 11
sylvain : 12
// BinaryWriter
using System;
using System.IO;
using System.Text.RegularExpressions;
L'argument du constructeur doit tre un flux (Stream). Ici c'est un flux construit partir d'un fichier (FileStream) dont on
donne :
o le nom
o l'opration faire, ici FileMode.Create pour crer le fichier
o le type d'accs, ici FileAccess.Write pour un accs en criture au fichier
La classe BinaryWriter dispose de diffrentes mthodes Write surcharges pour crire les diffrents types de donnes simples
Les rsultats de l'excution prcdente vont nous tre donns par le programme qui suit. Celui-ci accepte galement deux
arguments :
On fait donc l'opration inverse. On lit un fichier binaire pour crer un fichier texte. Si le fichier texte produit est identique au
fichier originel on saura que la conversion texte --> binaire --> texte s'est bien passe. Le code est le suivant :
// BinaryReader
using System;
using System.IO;
// syntaxe pg bin texte
// on lit un fichier binaire bin et on range son contenu dans un fichier texte (texte)
// le fichier binaire a une structure string, int
// le fichier texte a des lignes de la forme nom : age
L'argument du constructeur doit tre un flux (Stream). Ici c'est un flux construit partir d'un fichier (FileStream) dont
on donne :
le nom
l'opration faire, ici FileMode.Open pour ouvrir un fichier existant
le type d'accs, ici FileAccess.Read pour un accs en lecture au fichier
La classe BinaryReader dispose de diffrentes mthodes ReadXX pour lire les diffrents types de donnes simples
Si on excute les deux programmes la chane transformant personnes.txt en personnes.bin puis personnes.bin en personnes.txt2 on a :
E:\data\serge\MSNET\c#\fichiers\BINARY~1\1>more personnes.txt
paul : 10
helene : 15
jacques : 11
sylvain : 12
E:\data\serge\MSNET\c#\fichiers\BINARY~1\2>more personnes.txt2
paul:10
helene:15
jacques:11
sylvain:12
E:\data\serge\MSNET\c#\fichiers\BINARY~1\2>dir
29/04/2002 18:19 54 personnes.txt
29/04/2002 18:19 44 personnes.bin
29/04/2002 18:20 44 personnes.txt2
using System;
using System.Drawing;
using System.Windows.Forms;
// la classe formulaire
public class Form1 : Form {
// le constructeur
public Form1() {
// titre de la fentre
this.Text = "Mon premier formulaire";
// dimensions de la fentre
this.Size=new System.Drawing.Size(300,100);
}//constructeur
// fonction de test
public static void Main(string[] args) {
// on affiche le formulaire
Application.Run(new Form1());
}
}//classe
La classe de base Form dfinit une fentre de base avec des boutons de fermeture, agrandissement/rduction, une taille ajustable, ...
et gre les vnements sur ces objets graphiques. Ici nous spcialisons la classe de base en lui fixant un titre et ses largeur (300) et
hauteur (100). Ceci est fait dans son constructeur :
public Form1() {
// titre de la fentre
this.Text = "Mon premier formulaire";
// dimensions de la fentre
this.Size=new System.Drawing.Size(300,100);
}//constructeur
Le titre de la fentre est fixe par la proprit Text et les dimensions par la proprit Size. Size est dfini dans l'espace de noms
System.Drawing et est une structure.
Interfaces graphiques 93
Un formulaire de type Form1 est cr et affich, puis l'application se met l'coute des vnements qui se produisent sur le
formulaire (clics, dplacements de souris, ...) et fait excuter ceux que le formulaire gre. Ici, notre formulaire ne gre pas d'autre
vnement que ceux grs par la classe de base Form (clics sur boutons fermeture, agrandissement/rduction, changement de taille
de la fentre, dplacement de la fentre, ...).
using System;
using System.Drawing;
using System.Windows.Forms;
// la classe formulaire
public class Form1 : Form {
// attributs
Button cmdTest;
// le constructeur
public Form1() {
// le titre
this.Text = "Mon premier formulaire";
// les dimensions
this.Size=new System.Drawing.Size(300,100);
// un bouton
// cration
this.cmdTest = new Button();
// position
cmdTest.Location = new System.Drawing.Point(110, 20);
// taille
cmdTest.Size = new System.Drawing.Size(80, 30);
// libell
cmdTest.Text = "Test";
// gestionnaire d'vt
cmdTest.Click += new System.EventHandler(cmdTest_Click);
// ajout bouton au formulaire
this.Controls.Add(cmdTest);
}//constructeur
// gestionnaire d'vnement
private void cmdTest_Click(object sender, EventArgs evt){
// il y a eu un clic sur le bouton - on le dit
MessageBox.Show("Clic sur bouton", "Clic sur
bouton",MessageBoxButtons.OK,MessageBoxIcon.Information);
}//cmdTest_Click
// fonction de test
public static void Main(string[] args) {
// on affiche le formulaire
Application.Run(new Form1());
}
}//classe
// cration
this.cmdTest = new Button();
// position
cmdTest.Location = new System.Drawing.Point(110, 20);
// taille
cmdTest.Size = new System.Drawing.Size(80, 30);
// libell
cmdTest.Text = "Test";
// gestionnaire d'vt
cmdTest.Click += new System.EventHandler(cmdTest_Click);
// ajout bouton au formulaire
this.Controls.Add(cmdTest);
La proprit Location fixe les coordonnes (110,20) du point suprieur gauche du bouton l'aide d'une structure Point. Les largeur et
hauteur du bouton sont fixes (80,30) l'aide d'une structure Size. La proprit Text du bouton permet de fixer le libell du
bouton. La classe bouton possde un vnement Click dfini comme suit :
public event EventHandler Click;
Un objet EventHandler est construit avec le nom d'une mthode f ayant la signature suivante :
public delegate void EventHandler(
object sender,
EventArgs e
);
Interfaces graphiques 94
Ici, lors d'un clic sur le bouton cmdTest, la mthode cmdTest_Click sera appele. Celle-ci est dfinie comme suit conformment au
modle EventHandler prcdent :
// gestionnaire d'vnement
private void cmdTest_Click(object sender, EventArgs evt){
// il y a eu un clic sur le bouton - on le dit
MessageBox.Show("Clic sur bouton", "Clic sur bouton", MessageBoxButtons.OK,
MessageBoxIcon.Information);
}//cmdTest_Click
La classe MessageBox sert afficher des messages dans une fentre. Nous avons utilis ici le constructeur
avec
Le paramtre buttons peut prendre ses valeurs parmi les constantes suivantes :
constante boutons
AbortRetryIgnore
OK
OKCancel
RetryCancel
YesNo
Interfaces graphiques 95
YesNoCancel
Le paramtre icon peut prendre ses valeurs parmi les constantes suivantes :
Warning
La mthode Show est une mthode statique qui rend un rsultat de type System.Windows.Forms.DialogResult qui est une
numration :
// from module
'c:\winnt\assembly\gac\system.windows.forms\1.0.2411.0__b77a5c561934e089\system.windows.forms.dll'
public enum System.Windows.Forms.DialogResult
Interfaces graphiques 96
{
Abort = 0x00000003,
Cancel = 0x00000002,
Ignore = 0x00000005,
No = 0x00000007,
None = 0x00000000,
OK = 0x00000001,
Retry = 0x00000004,
Yes = 0x00000006,
} // end of System.Windows.Forms.DialogResult
Pour savoir sur quel bouton a appuy l'utilisateur pour fermer la fentre de type MessageBox on crira :
DialogResult res=MessageBox.Show(..);
if (res==DialogResult.Yes){ // il a appuy sur le bouton oui...}
2
1
4
3
5
slectionnez le type de projet que vous voulez construire, ici un projet C# (1)
slectionnez le type d'application que vous voulez construire, ici une application windows (2)
indiquez dans quel dossier vous voulez placer le sous-dossier du projet (3)
indiquez le nom du projet (4). Ce sera galement le nom du dossier qui contiendra les fichiers du projet
le nom de ce dossier est rappel en (5)
3. Un certain nombre de dossiers et de fichiers sont alors crs sous le dossier projet1 :
2
1
En prenant des contrles dans la barre d'outils (toolbox 2) et en les dposant sur la surface de la fentre (1), nous pouvons
construire une interface graphique. Si nos amenons la souris sur la "toolbox" celle-ci s'agrandit et laisse apparatre un
certain nombre de contrles :
Interfaces graphiques 98
Pour l'instant, nous n'en utilisons aucun. Toujours sur l'cran de VS.NET, nous trouvons la fentre de l'explorateur de
solutions "Explorer Solution" :
Dans un premier temps, nous ne nous servirons peu de cette fentre. Elle montre l'ensemble des fichiers formant le projet.
Un seul d'entre-eux nous intresse : le fichier source de notre programme, ici Form1.cs. En cliquant droit sur Form1.cs, on
obtient un menu permettant d'accder soit au code source de notre interface graphique (View code) soit l'interface
graphique elle-mme (View Designer) :
On peut accder ces deux entits directement partir de la fentre "Solution Explorer" :
Ici Form1.cs[Design] dsigne la fentre de conception et Form1.cs la fentre de code. Il suffit de cliquer sur l'un des onglets
pour passer d'une fentre l'autre.
Une autre fentre importante prsente sur l'cran de VS.NET est la fentre des proprits :
Interfaces graphiques 99
Les proprits exposes dans la fentre sont celles du contrle actuellement slectionn dans la fentre de conception
graphique.
On y retrouve les fentres principales qui viennent d'tre dcrites ainsi que leurs raccourcis clavier.
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
namespace projet1
{
/// <summary>
/// Summary description for Form1.
/// </summary>
public class Form1 : System.Windows.Forms.Form
Interfaces graphiques 100
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.Container components = null;
public Form1()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose( bool disposing )
{
if( disposing )
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );
}
La classe de base Form dfinit une fentre de base avec des boutons de fermeture, agrandissement/rduction, une taille ajustable, ...
et gre les vnements sur ces objets graphiques.
Le constructeur du formulaire utilise une mthode InitializeComponent dans laquelle les contrles du formulaires sont crs et
initialiss.
public Form1()
{
InitializeComponent();
// autres initialisations
}
Tout autre travail faire dans le constructeur peut tre fait aprs l'appel InitializeComponent. La mthode InitializeComponent
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
this.Size = new System.Drawing.Size(300,300);
this.Text = "Form1";
}
fixe le titre de la fentre "Form1", sa largeur (300) et sa hauteur (300). Le titre de la fentre est fixe par la proprit Text et les
dimensions par la proprit Size. Size est dfini dans l'espace de noms System.Drawing et est une structure.
Un formulaire de type Form1 est cr et affich, puis l'application se met l'coute des vnements qui se produisent sur le
formulaire (clics, dplacements de souris, ...) et fait excuter ceux que le formulaire gre. Ici, notre formulaire ne gre pas d'autre
vnement que ceux grs par la classe de base Form (clics sur boutons fermeture, agrandissement/rduction, changement de taille
de la fentre, dplacement de la fentre, ...).
Le formulaire utilise un attribut components qui n'est utilis nulle part. La mthode dispose ne sert galement rien ici. Il en de mme
de certains espaces de noms (Collections, ComponentModel, Data) utiliss et de celui dfini pour le projet projet1. Aussi, dans cet
exemple le code peut tre simplifi ce qui suit :
using System;
using System.Drawing;
using System.Windows.Forms;
public class Form1 : System.Windows.Forms.Form
{
// constructeur
public Form1()
{
// construction du formulaire avec ses composants
InitializeComponent();
// autres initialisations
}//constructeur
4.2.5 Conclusion
Nous accepterons maintenant tel quel le code gnr par VS.NET et nous contenterons d'y ajouter le ntre notamment pour grer
les vnements lis aux diffrents contrles du formulaire.
Cliquez droit dans la fentre en-dehors de tout composant et choisissez l'option Properties pour avoir accs aux proprits de la
fentre :
Une fois le composant choisi dans le "toolbox", utilisez la touche "Echap" pour faire disparatre
la barre d'outils, puis dposez et dimensionnez le composant. faites-le pour les trois composants
ncessaires : Label, TextBox, Button. Pour aligner et dimensionner correctement les composants,
utilisez le menu Format :
% l'tiquette 1 (Label)
Slectionnez le composant pour avoir sa fentre de
proprits. Dans celle-ci, modifiez les proprits suivantes :
name : lblSaisie, text : Saisie
% le champ de saisie 2 (TextBox)
Slectionnez le composant pour avoir sa fentre de
proprits. Dans celle-ci, modifiez les proprits suivantes :
name : txtSaisie, text : ne rien mettre
% le bouton 3 (Button) : name : cmdAfficher, text : Afficher
% la fentre elle-mme : name : frmSaisies&Boutons, text :
Saisies & boutons - 1
Fermez la fentre. Il nous reste crire la procdure lie un clic sur le bouton Afficher. Slectionnez le bouton pour avoir accs sa
fentre de proprits. Celle-ci a plusieurs onglets :
Les proprits et vnements d'un contrle sont accessibles par catgories ou par ordre alphabtique :
La colonne de gauche de la fentre liste les vnements possibles sur le bouton. Un clic sur un bouton correspond l'vnement
Click. La colonne de droite contient le nom de la procdure appele lorsque l'vnement correspondant se produit. Double-cliquez
sur la cellule de l'vnement Click. On passe alors automatiquement dans la fentre de code pour crire le gestionnaire de
l'vnement Click sur le bouton cmdAfficher :
Nous n'utiliserons aucun de ces paramtres ici. Il ne nous reste plus qu' complter le code. Ici, nous voulons prsenter une bote
de dialogue avec dedans le contenu du champ txtSaisie :
La syntaxe
this.cmdAfficher.Click +=
sert ajouter un gestionnaire pour l'vnement Click sur le bouton cmdAfficher. Ce gestionnaire doit tre de type System.EventHandler.
Le constructeur de cette classe admet un paramtre qui est la rfrence d'une mthode dont le prototype doit tre void f(object,
EventArgs). Le premier paramtre est la rfrence de l'objet la source de l'vnement, ici le bouton. Le second paramtre est un
objet de type EventArgs ou d'une classe drive.
Le type EventArgs est trs gnral et n'apporte en fait aucune information. Pour un clic sur un bouton, c'est suffisant. Pour un
dplacement de souris sur un formulaire, on aurait un vnement dfini par :
C'est une fonction dlgue (delegate) de fonctions de signature void f (object, MouseEventArgs). La classe MouseEventArgs est elle
dfinie par :
// from module
'c:\winnt\assembly\gac\system.windows.forms\1.0.2411.0__b77a5c561934e089\system.windows.forms.dll'
public class System.Windows.Forms.MouseEventArgs :
EventArgs
{
// Fields
// Constructors
Interfaces graphiques 107
public MouseEventArgs(System.Windows.Forms.MouseButtons button, int clicks, int x, int y, int delta);
// Properties
public MouseButtons Button { get; }
public int Clicks { get; }
public int Delta { get; }
public int X { get; }
public int Y { get; }
// Methods
public virtual bool Equals(object obj);
public virtual int GetHashCode();
public Type GetType();
public virtual string ToString();
} // end of System.Windows.Forms.MouseEventArgs
On voit que la classe MouseEventArgs est plus riche que la classe EventArgs. On peut par exemple connatre les coordonnes de la
souris X et Y au moment o se produit l'vnement.
4.3.2 Conclusion
Des deux projets tudis, nous pouvons conclure qu'une fois l'interface graphique construite avec VS.NET, le travail du
dveloppeur consiste crire les gestionnaires des vnements qu'il veut grer pour cette interface graphique.
L'vnement Load se produit avant mme que le formulaire ne soit affich. L'vnement Closing se produit lorsque le formulaire est
en cours de fermeture. On peut encore arrter cette fermeture par programmation.
L'vnement habituellement utilis pour TextBox est TextChanged qui signale que l'utilisateur modifi le champ de saisie. Voici un
exemple qui utilise l'vnement TextChanged pour suivre les volutions d'un champ de saisie :
1
2
4
3
Le code pertinent de cette application est celui des trois gestionnaires d'vnements :
On notera la faon de terminer l'application dans la procdure cmdQuitter_Click : Application.Exit(). On se rappellera ici comment elle
est lance dans la procdure Main de la classe :
2
3
Pour qu'un TextBox devienne multilignes on positionne les proprits suivantes du contrle :
Le code utile est celui qui traite le clic sur le bouton Ajouter :
Par dfaut, le type d'un ComboBox est DropDown. Pour dcouvrir la classe ComboBox, tapez ComboBox dans l'index de l'aide
(Help/Index).
C'est une proprit indexe, Items[i] dsignant l'lment i du Combo. Elle est en lecture seule. La classe
ComboBox.ObjectCollection est dfinie comme suit :
// from module
'c:\winnt\assembly\gac\system.windows.forms\1.0.2411.0__b77a5c561934e089\system.windows.forms.dll'
public class System.Windows.Forms.ComboBox+ObjectCollection :
object,
System.Collections.IList,
System.Collections.ICollection,
System.Collections.IEnumerable
{
// Fields
// Constructors
public ObjectCollection(System.Windows.Forms.ComboBox owner);
// Properties
public int Count { virtual get; }
public bool IsReadOnly { virtual get; }
public object this[ int index ] { virtual get; virtual set; }
// Methods
public int Add(object item);
public void AddRange(object[] items);
public virtual void Clear();
public virtual bool Contains(object value);
public void CopyTo(object[] dest, int arrayIndex);
public virtual bool Equals(object obj);
public virtual System.Collections.IEnumerator GetEnumerator();
public virtual int GetHashCode();
public Type GetType();
public virtual int IndexOf(object value);
public virtual void Insert(int index, object item);
public virtual void Remove(object value);
public virtual void RemoveAt(int index);
public virtual string ToString();
} // end of System.Windows.Forms.ComboBox+ObjectCollection
On peut s'tonner qu'un combo puisse contenir des objets alors qu'habituellement il contient des chanes de caractres. Au niveau
visuel, ce sera le cas. Si un ComboBox contient un objet obj, il affiche la chane obj.ToString(). On se rappelle que tout objet une
mthode ToString hrite de la classe object et qui rend une chane de caractres "reprsentative" de l'objet.
L'lment slectionn dans le combo C est C.SelectedItem ou C.Items[C.SelectedIndex] o C.SelectedIndex est le n de l'lment
slectionn, ce n partant de zro pour le premier lment.
Interfaces graphiques 111
Lors du choix d'un lment dans la liste droulante se produit l'vnement SelectedIndexChanged qui peut tre alors utilis pour tre
averti du changement de slection dans le combo. Dans l'application suivante, nous utilisons cet vnement pour afficher l'lment
qui a t slectionn dans la liste.
public frmCombo()
{
// cration formulaire
InitializeComponent();
// remplissage combo
cmbNombres.Items.AddRange(new string[] {"zro","un","deux","trois","quatre"});
// nous slectionnons le 1er lment de la liste
cmbNombres.SelectedIndex=0;
}//constructeur
Nous traitons l'vnement SelectedIndexChanged du combo qui signale un nouvel lment slectionn :
1 2
3 4
7 6 8
Fonctionnement
L'utilisateur tape du texte dans le champ 1. Il l'ajoute la liste 1 avec le bouton Ajouter (2). Le champ de saisie (1) est alors
vid et l'utilisateur peut ajouter un nouvel lment.
Il peut transfrer des lments d'une liste l'autre en slectionnant l'lment transfrer dans l'une des listes et en
choississant le bouton de transfert adquat 5 ou 6. L'lment transfr est ajout la fin de la liste de destination et enlev
de la liste source.
Il peut double-cliquer sur un lment de la liste 1. Ce lment est alors transfr dans la bote de saisie pour modification
et enlev de la liste 1.
Dans les conditions prcdentes, tous les boutons doivent tre teints lors du dmarrage de l'application. C'est la proprit Enabled
des boutons qu'il faut alors positionner false. On peut le faire au moment de la conception ce qui aura pour effet de gnrer le
code correspondant dans la mthode InitializeComponent ou de le faire nous-mmes dans le constructeur comme ci-dessous :
public Form1()
{
// cration initiale du formulaire
InitializeComponent();
// initialisations complmentaires
// on inhibe un certain nombre de boutons
btnAjouter.Enabled=false;
btn1TO2.Enabled=false;
btn2TO1.Enabled=false;
btnEffacer1.Enabled=false;
btnEffacer2.Enabled=false;
}
L'tat du bouton Ajouter est contrl par le contenu du champ de saisie. C'est l'vnement TextChanged qui nous permet de suivre les
changements de ce contenu :
L'tat des boutons de transfert dpend du fait qu'un lment a t slectionn ou non dans la liste qu'ils contrlent :
qui transfre dans la liste l2 l'lment slectionn dans la liste l1. Cela nous permet d'avoir une seule mthode au lieu de deux pour
transfrer un lment de listBox1 vers listBox2 ou de listBox2 vers listBox1. Avat de faire le transfert, on s'assure qu'il y a bien un
lment slectionn dans la liste l1 :
// un lment slectionn ?
if(l1.SelectedIndex==-1) return;
La proprit SelectedIndex vaut -1 si aucun lment n'est actuellement slectionn.
on opre le transfert de la liste X vers la liste Y et on change l'tat de certains boutons pour reflter le nouvel tat des listes.
Si on construit les trois boutons radio l'un aprs l'autre, ils font partie par dfaut d'un mme groupe. Aussi lorsque l'un est coch,
les autres ne le sont pas. L'vnement qui nous intresse pour ces six contrles est l'vnement CheckChanged indiquant que l'tat de
la case cocher ou du bouton radio a chang. Cet tat est reprsent dans les deux cas par la proprit boolenne Check qui vrai
signifie que le contrle est coch. Nous avons ici utilis une seule mthode pour traiter les six vnements CheckChanged, la mthode
affiche. Aussi dans la mthode InitializeComponent trouve-t-on les instructions suivantes :
La syntaxe if (sender is CheckBox) permet de vrifier si l'objet sender est de type CheckBox. Cela nous permet ensuite de faire
un transtypage vers le type exact de sender. La mthode affiche crit dans la liste lstValeurs le nom du composant l'origine de
l'vnement et la valeur de sa proprit Checked. A l'excution, on voit qu'un clic sur un bouton radio provoque deux vnements
CheckChanged : l'un sur l'ancien bouton coch qui passe "non coch" et l'autre sur le nouveau bouton qui passe "coch".
1 3
2
4
% Un variateur ScrollBar permet l'utilisateur de choisir une valeur dans une plage de valeurs entires symbolise par la
"bande" du variateur sur laquelle se dplace un curseur. La valeur du variateur est disponible dans sa proprit Value.
% Pour un variateur horizontal, l'extrmit gauche reprsente la valeur minimale de la plage, l'extrmit droite la valeur
maximale, le curseur la valeur actuelle choisie. Pour un variateur vertical, le minimum est reprsent par l'extrmit haute,
le maximum par l'extrmit basse. Ces valeurs sont reprsentes par les proprits Minimum et Maximum et valent par
dfaut 0 et 100.
% Un clic sur les extrmits du variateur fait varier la valeur d'un incrment (positif ou ngatif) selon l'extrmit clique
appele SmallChange qui est par dfaut 1.
% Un clic de part et d'autre du curseur fait varier la valeur d'un incrment (positif ou ngatif) selon l'extrmit clique
appele LargeChange qui est par dfaut 10.
% Lorsqu'on clique sur l'extrmit suprieure d'un variateur vertical, sa valeur diminue. Cela peut surprendre l'utilisateur
moyen qui s'attend normalement voir la valeur "monter". On rgle ce problme en donnant une valeur ngative aux
proprits SmallChange et LargeChange
% Ces cinq proprits (Value, Minimum, Maximum, SmallChange, LargeChange) sont accessibles en lecture et
criture.
% L'vnement principal du variateur est celui qui signale un changement de valeur : l'vnement Scroll.
Un composant NumericUpDown est proche du variateur : il a lui aussi les proprits Minimum, Maximum et Value, par dfaut 0,
100, 0. Mais ici, la proprit Value est affiche dans une bote de saisie faisant partie intgrante du contrle. L'utilisateur peut lui
mme modifier cette valeur sauf si on a mis la proprit ReadOnly du contrle vrai. La valeur de l'incrment est fix par la
proprit Increment, par dfaut 1. L'vnement principal du composant NumericUpDown est celui qui signale un changement de valeur
: l'vnement ValueChanged
Voici un programme permettant de mieux apprhender quels moments se produisent les diffrents vnements souris :
Pour suivre les dplacements de la souris sur les trois contrles, on n'crit qu'un seul gestionnaire :
et dans le constructeur (InitializeComponent), on donne le mme gestionnaire d'vnements Form1_MouseMove aux trois contrles :
Il faut savoir ici qu' chaque fois que la souris entre dans le domaine d'un contrle son systme de coordonnes change. Son origine
(0,0) est le coin suprieur gauche du contrle sur lequel elle se trouve. Ainsi l'excution, lorsqu'on passe la souris du formulaire au
bouton, on voit clairement le changement de coordonnes. Afin de mieux voir ces changements de domaine de la souris, on peut
utiliser la proprit Cursor des contrles :
Cette proprit permet de fixer la forme du curseur de souris lorsque celle-ci entre dans le domaine du contrle. Ainsi dans notre
exemple, nous avons fix le curseur Default pour le formulaire lui-mme, Hand pour la liste 2 et No pour le bouton 3 comme
le montrent les copies d'cran ci-dessous.
Dans le code du constructeur, le code gnr par ces choix est le suivant :
this.lstEvts.Cursor = System.Windows.Forms.Cursors.Hand;
this.btnEffacer.Cursor = System.Windows.Forms.Cursors.No;
Par ailleurs, pour dtecter les entres et sorties de la souris sur la liste 2, nous traitons les vnements MouseEnter et MouseLeave
de cette mme liste :
// affiche
private void affiche(String message){
// on affiche le message en haut de la liste des evts
lstEvts.Items.Insert(0,message);
}
private void lstEvts_MouseEnter(object sender, System.EventArgs e) {
affiche ("MouseEnter sur liste");
}
private void lstEvts_MouseLeave(object sender, System.EventArgs e) {
affiche ("MouseLeave sur liste");
}
Le contrle 1 est un TextBox en lecture seule (ReadOnly=true) et de nom txtStatut. L'arborescence du menu est la suivante :
Les options de menu sont des contrles comme les autres composants visuels et ont des proprits et vnements. Par exemple le
tableau des proprits de l'option de menu A1 :
Les proprits des diffrentes options de menu de notre exemple sont les suivantes :
Name Text
mnuA options A
mnuA1 A1
mnuA2 A2
mnuA3 A3
mnuB options B
mnuB1 B1
mnuSep1 - (sparateur)
mnuB2 B2
mnuB3 B3
mnuB31 B31
mnuB32 B32
On a alors un menu vide qui s'installe sur le formulaire avec des cases vides intitules "Type Here". Il suffit d'y indiquer les
diffrentes options du menu :
Pour insrer un sparateur entre deux options comme ci-dessus entre les options B1 et B2, positionnez-vous l'emplacement du
sparateur dans le menu, cliquez droit et prenez l'option Insert Separator :
Les options de menu sont traites comme des composants : elles ont des proprits et des vnements. Dans la structure du menu,
slectionnez l'option A1 et cliquez droit pour avoir accs aux proprits du contrle :
Vous avez alors accs la fentre des proprits dans laquelle on slectionnera l'onglet vnements. Slectionnez les vnements et
tapez affiche en face de l'vnement Click. Cela signifie que l'on souhaite que le clic sur l'option A1 soit traite par une mthode
appele affiche.
Dans cette mthode, nous nous contenterons d'afficher la proprit Text de l'option de menu la source de l'vnement :
La source de l'vnement sender est de type object. Les options de menu sont elle de type MenuItem, aussi est-on oblig ici de faire un
transtypage de object vers MenuItem.
Pour toutes les options de menu, on fixe le gestionnaire du clic la mthode affiche. Slectionnez par exemple l'option A2 et ses
vnements. En face de l'vnement Click, on a une liste droulante dans laquelle sont prsentes les mthodes existantes pouvant
traiter cet vnement. Ici on n'a que la mthode affiche qu'on slectionne. On rpte ce processus pour tous les composants menu.
Le code utile de cette application outre celui de la mthode affiche est celui de la construction du menu dans le constructeur du
formulaire (InitializeComponent) :
this.Menu = this.mainMenu1;
2 3 4
Lorsqu'ils sont pris dans le "ToolBox " et dposs sur le formulaire, ils sont placs dans une zone part en bas du formulaire. Les
composants "Dialog" sont pris dans le "ToolBox" :
// from module
'c:\winnt\assembly\gac\system.windows.forms\1.0.2411.0__b77a5c561934e089\system.windows.forms.dll'
public sealed class System.Windows.Forms.SaveFileDialog :
System.Windows.Forms.FileDialog,
System.ComponentModel.IComponent,
IDisposable
{
// Fields
// Constructors
public SaveFileDialog();
// Properties
public bool AddExtension { get; set; }
public bool CheckFileExists { virtual get; virtual set; }
public bool CheckPathExists { get; set; }
public IContainer Container { get; }
public bool CreatePrompt { get; set; }
public string DefaultExt { get; set; }
public bool DereferenceLinks { get; set; }
public string FileName { get; set; }
public string[] FileNames { get; }
public string Filter { get; set; }
public int FilterIndex { get; set; }
public string InitialDirectory { get; set; }
public bool OverwritePrompt { get; set; }
public bool RestoreDirectory { get; set; }
public bool ShowHelp { get; set; }
public ISite Site { virtual get; virtual set; }
public string Title { get; set; }
public bool ValidateNames { get; set; }
// Events
public event EventHandler Disposed;
public event CancelEventHandler FileOk;
public event EventHandler HelpRequest;
// Methods
public virtual System.Runtime.Remoting.ObjRef CreateObjRef(Type requestedType);
public virtual void Dispose();
public virtual bool Equals(object obj);
public virtual int GetHashCode();
public virtual object GetLifetimeService();
public Type GetType();
public virtual object InitializeLifetimeService();
public System.IO.Stream OpenFile();
public virtual void Reset();
public System.Windows.Forms.DialogResult ShowDialog();
public virtual string ToString();
} // end of System.Windows.Forms.SaveFileDialog
string Filter les types de fichiers proposs dans la liste droulante des types de fichiers de la bote de dialogue
int FilterIndex le n du type de fichier propos par dfaut dans la liste ci-dessus. Commence 0.
string InitialDirectory le dossier prsent initialement pour la sauvegarde du fichier
string FileName le nom du fichier de sauvegarde indiqu par l'utilisateur
DialogResult.ShowDialog() mthode qui affiche la bote de dialogue de sauvegarde. Rend un rsultat de type DialogResult.
4
3
1 liste droulante construite partir de la proprit Filter. Le type de fichier propos par dfaut est fix par FilterIndex
2 dossier courant, fix par InitialDirectory si cette proprit a t renseigne
3 nom du fichier choisi ou tap directement par l'utilisateur. Sera disponible dans la proprit FileName
4 boutons Enregistrer/Annuler. Si le bouton Enregistrer est utilis, la fonction ShowDialog rend le rsultat DialogResult.OK
saveFileDialog1.InitialDirectory=Application.ExecutablePath;
On notera la syntaxe des filtres filtre1|filtre2|..|filtren avec filtrei= Texte|modle de fichier. Ici l'utilisateur aura le choix
entre les fichiers *.txt et *.*.
saveFileDialog1.FilterIndex = 0;
Interfaces graphiques 126
Ici, ce sont les fichiers de type *.txt qui seront prsents tout d'abord l'utilisateur.
if(saveFileDialog1.ShowDialog() == DialogResult.OK) {
Pendant que la bote de dialogue est affiche, l'utilisateur n'a plus accs au formulaire principal (bote de dialogue dite
modale). L'utilisateur fixe le nom du fichier sauvegarder et quitte la bote soit par le bouton Enregistrer, soit par le
bouton Annuler soit en fermant la bote. Le rsultat de la mthode ShowDialog est DialogResult.OK uniquement si
l'utilisateur a utilis le bouton Enregistrer pour quitter la bote de dialogue.
Ceci fait, le nom du fichier crer est maintenant dans la proprit FileName de l'objet saveFileDialog1. On est alors
ramen la cration classique d'un fichier texte. On y crit le contenu du TextBox : txtTexte.Text tout en grant les
exceptions qui peuvent se produire.
La classe OpenFileDialog est trs proche de la classe SaveFileDialog et est dfinie comme suit :
// from module
'c:\winnt\assembly\gac\system.windows.forms\1.0.2411.0__b77a5c561934e089\system.windows.forms.dll'
public sealed class System.Windows.Forms.OpenFileDialog :
System.Windows.Forms.FileDialog,
System.ComponentModel.IComponent,
IDisposable
{
// Fields
// Constructors
public OpenFileDialog();
// Properties
public bool AddExtension { get; set; }
public bool CheckFileExists { virtual get; virtual set; }
public bool CheckPathExists { get; set; }
public IContainer Container { get; }
public string DefaultExt { get; set; }
public bool DereferenceLinks { get; set; }
public string FileName { get; set; }
public string[] FileNames { get; }
public string Filter { get; set; }
public int FilterIndex { get; set; }
public string InitialDirectory { get; set; }
public bool Multiselect { get; set; }
public bool ReadOnlyChecked { get; set; }
public bool RestoreDirectory { get; set; }
public bool ShowHelp { get; set; }
public bool ShowReadOnly { get; set; }
public ISite Site { virtual get; virtual set; }
public string Title { get; set; }
public bool ValidateNames { get; set; }
// Events
public event EventHandler Disposed;
public event CancelEventHandler FileOk;
public event EventHandler HelpRequest;
// Methods
public virtual System.Runtime.Remoting.ObjRef CreateObjRef(Type requestedType);
public virtual void Dispose();
public virtual bool Equals(object obj);
public virtual int GetHashCode();
public virtual object GetLifetimeService();
public Type GetType();
public virtual object InitializeLifetimeService();
public System.IO.Stream OpenFile();
public virtual void Reset();
public System.Windows.Forms.DialogResult ShowDialog();
public virtual string ToString();
} // end of System.Windows.Forms.OpenFileDialog
string Filter les types de fichiers proposs dans la liste droulante des types de fichiers de la bote de dialogue
int FilterIndex le n du type de fichier propos par dfaut dans la liste ci-dessus. Commence 0.
string InitialDirectory le dossier prsent initialement pour la recherche du fichier ouvrir
string FileName le nom du fichier ouvrir indiqu par l'utilisateur
DialogResult.ShowDialog() mthode qui affiche la bote de dialogue de sauvegarde. Rend un rsultat de type DialogResult.
4
3
1 liste droulante construite partir de la proprit Filter. Le type de fichier propos par dfaut est fix par FilterIndex
2 dossier courant, fix par InitialDirectory si cette proprit a t renseigne
3 nom du fichier choisi ou tap directement par l'utilisateur. Sera disponible dans la proprit FileName
4 boutons Ouvrir/Annuler. Si le bouton Ouvrir est utilis, la fonction ShowDialog rend le rsultat DialogResult.OK
saveFileDialog1.InitialDirectory=Application.ExecutablePath;
saveFileDialog1.FilterIndex = 0;
Ici, ce sont les fichiers de type *.txt qui seront prsents tout d'abord l'utilisateur.
" La bote de dialogue est affiche et son rsultat rcupr
Interfaces graphiques 128
if(openFileDialog1.ShowDialog() == DialogResult.OK) {
Pendant que la bote de dialogue est affiche, l'utilisateur n'a plus accs au formulaire principal (bote de dialogue dite
modale). L'utilisateur fixe le nom du fichier ouvrir et quitte la bote soit par le bouton Ouvrir, soit par le bouton Annuler
soit en fermant la bote. Le rsultat de la mthode ShowDialog est DialogResult.OK uniquement si l'utilisateur a utilis le bouton
Ouvrir pour quitter la bote de dialogue.
" Ceci fait, le nom du fichier crer est maintenant dans la proprit FileName de l'objet openFileDialog1. On est alors
ramen la lecture classique d'un fichier texte. On notera la mthode qui permet de lire la totalit d'un fichier :
txtTexte.Text=fichier.ReadToEnd();
" le contenu du fichier est mis dans le TextBox txtTexte. On gre les exceptions qui peuvent se produire.
6
7
Les classes FontDialog et ColorDialog ont une mthode ShowDialog analogue la mthode ShowDialog des classes OpenFileDialog et
SaveFileDialog.
Si l'utilisateur quitte la bote de dialogue avec le bouton OK, le rsultat de la mthode ShowDialog est DialogResult.OK et la police
choisie est dans la proprit Font de l'objet FontDialog utilis.
Nous avons les lments pour traiter les clics sur les boutons Couleur et Police :
4.7.3 Timer
Nous nous proposons ici d'crire l'application suivante :
1 2
Le chronomtre en marche :
Le chronomtre arrt :
Pour changer toutes les secondes le contenu du TextBox txtChrono, il nous faut un composant qui gnre un vnement toutes les
secondes, vnement qu'on pourra intercepter pour mettre jour l'affichage du chronomtre. Ce composant c'est le Timer :
Une fois ce composant install sur le formulaire (dans la partie des composants non visuels), un objet de type Timer est cr dans le
constructeur du formulaire. La classe System.Windows.Forms.Timer est dfinie comme suit :
// from module
'c:\winnt\assembly\gac\system.windows.forms\1.0.2411.0__b77a5c561934e089\system.windows.forms.dll'
public class System.Windows.Forms.Timer :
System.ComponentModel.Component,
System.ComponentModel.IComponent,
IDisposable
{
// Fields
// Constructors
public Timer();
public Timer(System.ComponentModel.IContainer container);
// Properties
public IContainer Container { get; }
public bool Enabled { virtual get; virtual set; }
Interfaces graphiques 131
public int Interval { get; set; }
public ISite Site { virtual get; virtual set; }
// Events
public event EventHandler Disposed;
public event EventHandler Tick;
// Methods
public virtual System.Runtime.Remoting.ObjRef CreateObjRef(Type requestedType);
public virtual void Dispose();
public virtual bool Equals(object obj);
public virtual int GetHashCode();
public virtual object GetLifetimeService();
public Type GetType();
public virtual object InitializeLifetimeService();
public void Start();
public void Stop();
public virtual string ToString();
} // end of System.Windows.Forms.Timer
Dans notre exemple le timer s'appelle timer1 et timer1.Interval est mis 1000 ms (1s). L'vnement Tick se produira donc toutes les
secondes. Le clic sur le bouton Arrt/Marche est trait par la procdure suivante :
Le libell du bouton Arret/Marche est soit "Arrt" soit "Marche". On est donc oblig de faire un test sur ce libell pour savoir quoi
faire.
" dans le cas de "Marche", on note l'heure de dbut dans une variable qui est une variable globale de l'objet formulaire, le
timer est lanc (Enabled=true) et le libell du bouton passe "Arrt".
" dans le cas de "Arrt", on arrte le timer (Enabled=false) et on passe le libell du bouton "Marche".
L'attribut dbut ci-dessus est connu dans toutes les mthodes de la classe. Il nous reste traiter l'vnement Tick sur l'objet timer1,
vnement qui se produit toutes les secondes :
0
2
1
6
7 8
Rgles de fonctionnement
" le bouton Calculer reste teint tant qu'il n'y a rien dans le champ du salaire
" si lorsque le calcul est lanc, il s'avre que le salaire est incorrect, l'erreur est signale :
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
public class Form1 : System.Windows.Forms.Form
{
private System.Windows.Forms.Label label1;
private System.Windows.Forms.RadioButton rdOui;
private System.Windows.Forms.RadioButton rdNon;
private System.Windows.Forms.Label label2;
private System.Windows.Forms.TextBox txtSalaire;
private System.Windows.Forms.Label label3;
private System.Windows.Forms.Label label4;
private System.Windows.Forms.GroupBox groupBox1;
private System.Windows.Forms.Button btnCalculer;
private System.Windows.Forms.Button btnEffacer;
private System.Windows.Forms.Button btnQuitter;
private System.Windows.Forms.TextBox txtImpots;
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.Container components = null;
private System.Windows.Forms.NumericUpDown incEnfants;
// tableaux de donnes ncessaires au calcul de l'impt
private decimal[] limites=new decimal[]
{12620M,13190M,15640M,24740M,31810M,39970M,48360M,55790M,92970M,127860M,151250M,172040M,195000M,0M};
private decimal[] coeffR=new decimal[]
{0M,0.05M,0.1M,0.15M,0.2M,0.25M,0.3M,0.35M,0.4M,0.45M,0.55M,0.5M,0.6M,0.65M};
private decimal[] coeffN=new decimal[]
{0M,631M,1290.5M,2072.5M,3309.5M,4900M,6898.5M,9316.5M,12106M,16754.5M,23147.5M,30710M,39312M,49062M};
// objet impt
impt objImpt=null;
public Form1()
{
//
InitializeComponent();
// initialisation du formulaire
btnEffacer_Click(null,null);
btnCalculer.Enabled=false;
// cration d'un objet impt
try{
objImpt=new impt(limites,coeffR,coeffN);
}catch (Exception ex){
MessageBox.Show("Impossible de crer l'objet impt
("+ex.Message+")","Erreur",MessageBoxButtons.OK,MessageBoxIcon.Error);
// on inhibe le champ de saisie du salaire
txtSalaire.Enabled=false;
}//try-catch
}//constructeur
}
#endregion
[STAThread]
static void Main()
{
Application.Run(new Form1());
}
dfinit un type appel opration qui est en fait un prototype de fonction acceptant deux entiers et rendant un entier. C'est le mot cl
delegate qui fait de opration une dfinition de prototype de fonction.
Une variable op de type opration aura pour rle d'enregistrer une liste de fonctions correspondant au prototype opration :
int f1(int,int)
int f2(int,int)
...
int fn(int,int)
L'enregistrement d'une fonction fi dans la variable op se fait par op=new opration(fi). Pour ajouter une fonction fj la liste des
fonctions dj enregistres, on crit op+= new opration(fj). Pour enlever une fonction fk dj enregistre on crit op-=new opration(fk).
Si dans notre exemple on crit n=op(n1,n2), l'ensemble des fonctions enregistres dans la variable op seront excutes avec les
paramtres n1 et n2. Le rsultat n rcupr sera celui de la dernire fonction excute. Il n'est pas possible d'obtenir les rsultats
produits par l'ensemble des fonctions. Pour cette raison, si on enregistre une liste de fonctions dans une fonction dlgue, celles-ci
rendent le plus souvent le rsultat void.
//fonctions dlgues
using System;
public class class1{
// dfinition d'un prototype de fonction
// accepte 2 entiers en paramtre et rend un entier
public delegate int opration(int n1, int n2);
// deux mthodes d'instance correspondant au prototype
public int ajouter(int n1, int n2){
Console.Out.WriteLine("ajouter("+n1+","+n2+")");
return n1+n2;
}//ajouter
public int soustraire(int n1, int n2){
Console.Out.WriteLine("soustraire("+n1+","+n2+")");
return n1-n2;
}//soustraire
// une mthode statique correspondant au prototype
public static int augmenter(int n1, int n2){
Console.Out.WriteLine("augmenter("+n1+","+n2+")");
return n1+2*n2;
}//augmenter
// programme de test
public static void Main(){
// on dfinit un objet de type opration pour y enregistrer des fonctions
// on enregistre la fonction statique augmenter
opration op=new opration(class1.augmenter);
// on excute le dlgu
int n=op(4,7);
Console.Out.WriteLine("n="+n);
// cration d'un objet c1 de type class1
class1 c1=new class1();
// on enregistre dans le dlgu la mthode ajouter de c1
Interfaces graphiques 136
op=new class1.opration(c1.ajouter);
// excution de l'objet dlgu
n=op(2,3);
Console.Out.WriteLine("n="+n);
// on enregistre dans le dlgu la mthode soustraire de c1
op=new class1.opration(c1.soustraire);
n=op(2,3);
Console.Out.WriteLine("n="+n);
//enregistrement de deux fonctions dans le dlgu
op=new class1.opration(c1.ajouter);
op+=new class1.opration(c1.soustraire);
// excution de l'objet dlgu
op(0,0);
// on retire une fonction du dlgu
op-=new opration(c1.soustraire);
// on excute le dlgu
op(1,1);
}//Main
}//classe
augmenter(4,7)
n=18
ajouter(2,3)
n=5
soustraire(2,3)
n=-1
ajouter(0,0)
soustraire(0,0)
ajouter(1,1)
Comme nous le verrons dans l'exemple suivant, cela sert surtout la gestion des vnements. Une classe C1 peut gnrer des
vnements evti. Lors d'un vnement evti, un objet de type C1 lancera l'excution d'un objet evtiDclench de type delegate. Toutes les
fonctions enregistres dans l'objet delegate evtiDclench seront alors excutes. Si un objet C2 utilisant un objet C1 veut tre averti de
l'occurrence de l'vnement evti sur l'objet C1, il enregistrera l'une de ses mthodes C2.f dans l'objet dlgu C1.evtiDclench de
l'objet C1 afin que la mthode C2.f soit excute chaque fois que l'vnement evti se produit sur l'objet C1. Comme l'objet dlgu
C1.evtiDclench peut enregistrer plusieurs fonctions, diffrents objets Ci pourront s'enregistrer auprs du dlgu C1.evtiDclench
pour tre prvenus de l'vnement evti sur C1.
//gestion d'vnements
using System;
public class myEventArgs : EventArgs{
// la classe d'un vt
// attribut
private string _saisie;
// constructeur
public myEventArgs(string saisie){
_saisie=saisie;
}//constructeur
// proprit saisie en lecture seule
public override string ToString(){
return _saisie;
}//ToString
}// classe myEventArgs
public class metteur{
// la classe mettrice d'un vt
// attribut
private string _nom; // nom de l'metteur
// constructeur
public metteur(string nom){
_nom=nom;
}//constructeur
// ToString
public override string ToString(){
return _nom;
Interfaces graphiques 137
}//ToString
// le prototype des fonctions charges de traiter l'vt
public delegate void _evtHandler(object sender, myEventArgs evt);
// le pool des gestionnaires d'vts
public event _evtHandler evtHandler;
// mthode de demande d'mission d'un vt
public void envoyerEvt(myEventArgs evt){
// on prvient tous les abonns
// on fait comme si l'vt provenait d'ici
evtHandler(this,evt);
}//envoyerEvt
}//metteur
// une classe de traitement de l'vt
public class souscripteur{
// attribut
private string nom; // nom du souscripteur
private metteur sender; // l'metteur des vts
// constructeur
public souscripteur(string nom, metteur e){
// on note le nom du souscripteur
this.nom=nom;
// et l'metteur des vts
this.sender=e;
// on s'inscrit pour recevoir les evts de l'metteur e
e.evtHandler+=new metteur._evtHandler(traitementEvt);
}//souscripteur
// gestionnaire d'vt
public void traitementEvt(object sender, myEventArgs evt){
// affichage evt
Console.Out.WriteLine("L'objet [" + sender + "] a signal la saisie errone [" + evt + "] au
souscripteur [" + nom + "]");
}//traitement1
}// classe souscripteur
// un programme de test
public class test{
public static void Main(){
// cration d'un metteur d'evts
metteur metteur1=new metteur("metteur1");
// cration d'un tableau de souscripteurs
// pour les vts mis par metteur1
souscripteur[] souscripteurs=new souscripteur[] {new souscripteur("s1",metteur1), new
souscripteur("s2",metteur1)};
// on lit une suite d'entiers au clavier
// ds que l'un est erron, on met un vt
Console.Out.Write("Nombre entier (rien pour arrter) : ");
string saisie=Console.In.ReadLine().Trim();
// tant que la ligne saisie est non vide
while(saisie!=""){
// la saisie est-elle un nombre entier ?
try{
int n=int.Parse(saisie);
}catch(Exception){
// ce n'est pas un entier
// on prvient tout le monde
metteur1.envoyerEvt(new myEventArgs(saisie));
}//try-catch
// nouvelle saisie
Console.Out.Write("Nombre entier (rien pour arrter) : ");
saisie=Console.In.ReadLine().Trim();
}//while
// fin
Environment.Exit(0);
}//Main
}//classe test
Le code prcdent est assez complexe. Dtaillons-le. Dans une gestion d'vnements, il y a un metteur d'vnements (sender) qui
envoie le dtail des vnements (EventArgs) des souscripteurs qui se sont dclars intresss par les vnements en question. La
classe mettrice des vnements est ici la suivante :
public class metteur{
// la classe mettrice d'un vt
// attribut
private string _nom; // nom de l'metteur
// constructeur
public metteur(string nom){
_nom=nom;
}//constructeur
// ToString
public override string ToString(){
Interfaces graphiques 138
return _nom;
}//ToString
Chaque objet metteur a un nom fix par construction. La mthode ToString a t redfinie de telle faon que lorsqu'on transforme un
objet metteur en string c'est son nom qu'on rcupre. La classe dfinit le prototype des fonctions qui peuvent traiter les vnements
qu'elle met :
Le premier argument d'une fonction de traitement d'un vnement sera l'objet qui met l'vnement. Le second argument sera de
type myEventArgs, un objet qui donnera des dtails sur l'vnement et sur lequel nous reviendrons.
Une fois le prototype (delegate) des gestionnaires d'vnements dfini, il nous faut un objet pour enregistrer des fonctions
correspondant ce prototype et qui seront excutes lorsque l'objet qui les enregistre recevra les paramtres permettant de les
excuter.
public event _evtHandler evtHandler;
On notera le mot cl event qui impose au delegate d'tre de type void f(object, EventArgs). Les fonctions enregistres dans evtHandler
seront excutes par une instruction evtHandler(o,evt) o o est de type object ou driv et evt de type myEventArgs ou driv. Cette
excution ne peut se produire que dans un objet de la classe qui dfinit l'vnement evtHandler, c.a.d. un objet de type metteur. Afin
de pouvoir dclencher un vnement de l'extrieur d'un objet metteur, nous ajoutons la classe la mthode envoyerEvt :
// mthode de demande d'mission d'un vt
public void envoyerEvt(myEventArgs evt){
// on prvient tous les abonns
// on fait comme si l'vt provenait d'ici
evtHandler(this,evt);
}//envoyerEvt
Nous devons dfinir quel sera le type d'vnements dclenchs par la classe metteur. Nous avons pour cela dfini la classe
myEventArgs :
public class myEventArgs : EventArgs{
// la classe d'un vt
// attribut
private string _saisie;
// constructeur
public myEventArgs(string saisie){
_saisie=saisie;
}//constructeur
// proprit saisie en lecture seule
public override string ToString(){
return _saisie;
}//ToString
}// classe myEventArgs
Nous avons vu que les fonctions de traitement des vnements devaient correspondre au prototype void f(object, EventArgs).
EventArgs est une classe qui donne des informations sur l'vnement qui s'est produit. Pour chaque nouveau type d'vnement, on
est donc amen driver cette classe. C'est ce qui est fait ici. Les vnements qui vont nous intresser sont des saisies au clavier
errones. On va demander un utilisateur de taper des nombres entiers au clavier et ds qu'il tapera une chane qui ne reprsente
pas un entier, on dclenchera un vnement. Comme dtail de l'vnement, nous nous conterons de donner la saisie errone. C'est
le sens de l'attribut _saisie de la classe. Un objet myEventArgs est donc construit avec pour paramtre la saisie errone. On redfinir
par ailleurs la mthode ToString pour que lorsqu'on transforme un objet myEventArgs en chane, on obtienne l'attribut _saisie.
Nous avons dfini l'metteur des vnements et le type d'vnements qu'il met. Nous dfinissons ensuite le type des souscripteurs
intresss par ces vnements.
// une classe de traitement de l'vt
public class souscripteur{
// attribut
private string nom; // nom du souscripteur
Interfaces graphiques 139
private metteur sender; // l'metteur des vts
// constructeur
public souscripteur(string nom, metteur e){
// on note le nom du souscripteur
this.nom=nom;
// et l'metteur des vts
this.sender=e;
// on s'inscrit pour recevoir les evts de l'metteur e
e.evtHandler+=new metteur._evtHandler(traitementEvt);
}//souscripteur
// gestionnaire d'vt
public void traitementEvt(object sender, myEventArgs evt){
// affichage evt
Console.Out.WriteLine("L'objet [" + sender + "] a signal la saisie errone [" + evt + "] au
souscripteur [" + nom + "]");
}//traitement1
}// classe souscripteur
Un souscripteur sera dfini par deux paramtres : son nom (attribut nom) et l'objet metteur dont il veut traiter les vnements
(attribut sender). Ces deux paramtres seront passs au constructeur de l'objet. Au cours de cette mme construction, le souscripteur
s'abonne aux vnements de l'metteur :
e.evtHandler+=new metteur._evtHandler(traitementEvt);
La fonction enregistre auprs de l'metteur est traitementEvt. Cette mthode de la classe souscripteur affiche les deux arguments
qu'elle a reues (sender, evt) ainsi que le nom du rcepteur (nom).
Ont t dfinis, le type des vnements produits, le type de l'metteur de ces vnements, le type des souscripteurs. Il ne nous reste
plus qu' les mettre en oeuvre :
// un programme de test
public class test{
public static void Main(){
// cration d'un metteur d'evts
metteur metteur1=new metteur("metteur1");
// cration d'un tableau de souscripteurs
// pour les vts mis par metteur1
souscripteur[] souscripteurs=new souscripteur[] {new souscripteur("s1",metteur1), new
souscripteur("s2",metteur1)};
// on lit une suite d'entiers au clavier
// ds que l'un est erron, on met un vt
Console.Out.Write("Nombre entier (rien pour arrter) : ");
string saisie=Console.In.ReadLine().Trim();
// tant que la ligne saisie est non vide
while(saisie!=""){
// la saisie est-elle un nombre entier ?
try{
int n=int.Parse(saisie);
}catch(Exception){
// ce n'est pas un entier
// on prvient tout le monde
metteur1.envoyerEvt(new myEventArgs(saisie));
}//try-catch
// nouvelle saisie
Console.Out.Write("Nombre entier (rien pour arrter) : ");
saisie=Console.In.ReadLine().Trim();
}//while
// fin
Environment.Exit(0);
}//Main
}//classe test
Nous crons un tableau de deux souscripteurs pour les vnements mis par l'objet metteur1 :
Nous demandons l'utilisateur de taper des nombres entiers au clavier. Ds qu'une saisie est errone, nous demandons metteur1
d'envoyer un vnement ses souscripteurs :
E:\data\serge\MSNET\c#\vnements\2>evt1
Nombre entier (rien pour arrter) : 4
Nombre entier (rien pour arrter) : a
L'objet [metteur1] a signal la saisie errone [a] au souscripteur [s1]
L'objet [metteur1] a signal la saisie errone [a] au souscripteur [s2]
Nombre entier (rien pour arrter) : 1.6
L'objet [metteur1] a signal la saisie errone [1.6] au souscripteur [s1]
L'objet [metteur1] a signal la saisie errone [1.6] au souscripteur [s2]
Nombre entier (rien pour arrter) :
Application Base de
donnes
I1 I2
Afin d'viter qu'une application crite pour une base de donnes B1 doive tre r-crite si on migre vers une base de donnes B2
diffrente, un effort de normalisation a t fait sur l'interface I1. Si on utilise des bases de donnes utilisant des pilotes "normaliss",
la base B1 sera fournie avec un pilote P1, la base B2 avec un pilote P2, et l'interface I1 de ces deux pilotes sera identique. Aussi
n'aura-t-on pas r-crire l'application. On pourra ainsi, par exemple, migrer une base de donnes ACCESS vers une base de
donnes MySQL sans changer l'application.
Les pilotes ODBC permettent l'accs des bases de donnes. Les sources de donnes pour les pilotes OLE DB sont plus varies :
bases de donnes, messageries, annuaires, ... Il n'y a pas de limite. Toute source de donnes peut faire l'objet d'un pilote Ole DB si
un diteur le dcide. L'intrt est videmment grand : on a un accs uniforme une grande varit de donnes.
La plate-forme .NET est livre avec deux types de classes d'accs aux donnes :
Les premires classes permettent un accs direct au SGBD SQL Server de Microsoft sans pilote intermdiaire. Les secondes
permettent l'accs aux sources de donnes OLE DB.
La plate-forme .NET est fournie (mai 2002) avec trois pilotes OLE DB pour respectivement : SQL Server, Oracle et Microsoft Jet
(Access). Si on veut travailler avec une base de donnes ayant un pilote ODBC mais pas de pilote OLE DB, on ne peut pas. Ainsi
on ne peut pas travailler avec le SGBD MySQL qui (mai 2002) ne fournit pas de pilote OLE DB. Il existe cependant une srie de
classes permettant l'accs aux sources de donnes ODBC, les classes odbc.net. Elles ne sont pas livres en standard avec le SDK et
il faut aller les chercher sur le site de Microsoft. Dans les exemples qui vont suivre, nous utiliserons surtout ces classes ODBC car la
plupart des bases de donnes sous windows sont livres avec un tel pilote. Voici par exemple, une liste des pilotes ODBC installs
sur une machine Win 2000 (Menu Dmarrer/Paramtres/Panneau de configuration/Outils d'administration) :
1. mode connect
2. mode dconnect
En mode connect, l'application
1. ouvre une connexion avec la source de donnes
2. travaille avec la source de donnes en lecture/criture
3. ferme la connexion
Dans les deux cas, c'est l'opration d'exploitation et de mise jour des donnes qui prend du temps. Imaginons que ces mises jour
soient faites par un utilisateur faisant des saisies, cette opration peut prendre des dizaines de minutes. Pendant tout ce temps, en
mode connect, la connexion avec la base est maintenue et les modifications immdiatement rpercutes. En mode dconnect, il
n'y a pas de connexion la base pendant la mise jour des donnes. Les modifications sont faites uniquement sur la copie
mmoire. Elles sont rpercutes sur la source de donnes en une seule fois lorsque tout est termin.
Une connexion est coteuse en ressources systme. S'il y a beaucoup de connexions simultanes, le mode dconnect
permet de rduire leurs dures un minimum. C'est le cas des applications web ayant des milliers d'utilisateurs.
L'inconvnient du mode dconnect est la gestion dlicate des mises jour simultanes. L'utilisateur U1 obtient des
donnes au temps T1 et commence les modifier. Au temps T2, l'utilisateur U2 accde lui aussi la source de donnes et
obtient les mmes donnes. Entre-temps l'utilisateur U1 a modifi certaines donnes mais ne les a pas encore transmises
la source de donnes. U2 travaille donc avec des donnes dont certaines sont errones. Les classes .NET offrent des
solutions pour grer ce problme mais il n'est pas simple rsoudre.
En mode connect, la mise jour simultane de donnes par plusieurs utilisateurs ne pose normalement pas de problme.
La connexion avec la base de donnes tant maintenue, c'est la base de donnes elle-mme qui gre ces mises jour
simultanes. Ainsi Oracle verrouille une ligne de la base de donnes ds qu'un utilisateur la modifie. Elle restera verrouille
donc inaccessible aux autres utilisateurs jusqu' ce que celui qui l'a modifie valide (commit) sa modification ou
l'abandonne (rollback).
Si les donnes doivent circuler sur le rseau, le mode dconnect est choisir. Il permet d'avoir une photo des donnes
dans un objet appel dataset qui reprsente une base de donnes lui tout seul. Cet objet peut circuler sur le rseau entre
machines.
nom type
code code de larticle sur 4 caractres
nom son nom (chane de caractres)
prix son prix (rel)
stock_actuel son stock actuel (entier)
stock_minimum le stock minimum (entier) en-dea duquel il faut rapprovisionner larticle
Nous utiliserons cette base aussi bien au travers d'un pilote ODBC qu'un pilote OLE DB afin de montrer la similitude des deux
approches et parce que nous disposons de ces deux types de pilotes pour ACCESS.
Pour dfinir la base ACCESS comme source de donnes ODBC, procdez comme suit :
activez l'administrateur de sources de donnes ODBC comme il a t montr plus haut et slectionnez l'onglet User DSN
(DSN=Data Source Name)
Donnez le nom articles-access la source de donnes, mettez une description libre et utilisez le bouton Slectionner pour
dsigner le fichier .mdb de la base. Terminez par OK.
Pour dfinir la base MySQL DBARTICLES comme source de donnes ODBC, procdez comme suit :
activez l'administrateur de sources de donnes ODBC comme il a t montr plus haut et slectionnez l'onglet User DSN.
Ajoutez une nouvelle source de donnes avec Add et slectionnez le pilote ODBC de MySQL.
2
3
4
5
Les tapes 2 et 3 sont ralises de faon rpte, la fermeture de connexion nayant lieu qu la fin de lexploitation de la base. Cest
un schma relativement classique dont vous avez peut-tre lhabitude si vous avez exploit une base de donnes de faon
interactive. Ces tapes sont les mmes que la base soit utilise au travers d'un pilote ODBC ou d'un pilote OLE DB. Nous
prsentons ci-dessous un exemple avec les classes .NET de gestion des sources de donnes ODBC. Le programme s'appelle liste et
admet comme paramtre le nom DSN d'une source de donnes ODBC ayant une table ARTICLES. Il affiche alors le contenu de
cette table :
E:\data\serge\MSNET\c#\adonet\5>liste
syntaxe : pg dsnArticles
E:\data\serge\MSNET\c#\adonet\5>liste articles-access
----------------------------------------
code,nom,prix,stock_actuel,stock_minimum
----------------------------------------
E:\data\serge\MSNET\c#\adonet\5>liste mysql-artices
Erreur d'exploitation de la base de donnes (ERROR [IM002] [Microsoft][ODBC Driver Manager] Data source
name not found and no default driver specified)
E:\data\serge\MSNET\c#\adonet\5>liste mysql-articles
----------------------------------------
code,nom,prix,stock_actuel,stock_minimum
----------------------------------------
Sur les rsultats ci-dessus, nous voyons que le programme a list aussi bien le contenu de la base ACCESS que de la base MySQL.
Etudions maintenant le code de ce programme :
using System;
using System.Data;
using Microsoft.Data.Odbc;
class listArticles
{
static void Main(string[] args){
// application console
// affiche le contenu d'une table ARRTICLES d'une base DSN
// dont le nom est pass en paramtre
const string syntaxe="syntaxe : pg dsnArticles";
Accs aux bases de donnes 148
const string tabArticles="articles"; // la table des articles
// vrification des paramtres
// a-t-on 2 paramtres
if(args.Length!=1){
// msg d'erreur
Console.Error.WriteLine(syntaxe);
// fin
Environment.Exit(1);
}//if
// on rcupre le paramtre
string dsnArticles=args[0]; // la base DSN
// prparation de la connexion la bd
OdbcConnection articlesConn=null; // la connexion
OdbcDataReader myReader=null; // le lecteur de donnes
try{
// on tente d'accder la base de donnes
// chane de connexion la base
string connectString="DSN="+dsnArticles+";";
articlesConn = new OdbcConnection(connectString);
articlesConn.Open();
// excution d'une commande SQL
string sqlText = "select * from " + tabArticles;
OdbcCommand myOdbcCommand = new OdbcCommand(sqlText);
myOdbcCommand.Connection = articlesConn;
myReader=myOdbcCommand.ExecuteReader();
// Exploitation de la table rcupre
// affichage des colonnes
string ligne="";
int i;
for(i=0;i<myReader.FieldCount-1;i++){
ligne+=myReader.GetName(i)+",";
}//for
ligne+=myReader.GetName(i);
Console.Out.WriteLine("\n"+"".PadLeft(ligne.Length,'-')+"\n"+ligne+"\n"+"".PadLeft(ligne.Length,'-
')+"\n");
// affichage des donnes
while (myReader.Read()) {
// exploitation ligne courante
ligne="";
for(i=0;i<myReader.FieldCount;i++){
ligne+=myReader[i]+" ";
}
Console.WriteLine(ligne);
}//while
}//try
catch(Exception ex){
Console.Error.WriteLine("Erreur d'exploitation de la base de donnes "+ex.Message+")");
Environment.Exit(2);
}//catch
finally{
try{
// fermeture lecteur
myReader.Close();
// fermeture connexion
articlesConn.Close();
}catch{}
}//finally
// fin
Environment.Exit(0);
}//main
}//classe
Les classes de gestion des sources ODBC se trouvent dans l'espace de noms Microsoft.Data.Odbc qu'on doit donc importer. Par
ailleurs, un certain nombre de classes se trouve dans l'espace de noms System.Data.
using System.Data;
using Microsoft.Data.Odbc;
L'espace de noms Microsoft.Data.Odbc se trouve dans "l'assembly" microsoft.data.odbc.dll. Aussi pour compiler le programme prcdent
crit-on :
Si on dfinit une source de donnes comme source de donnes ODBC l'aide de l'administrateur de sources de donnes ODBC,
ces paramtres ont dj t donns et enregistrs. Il suffit alors de passer le paramtre DSN qui donne le nom DSN de la source de
donnes. C'est ce qui est fait ici :
Une fois l'objet OdbcConnection construit, on ouvre la connexion avec la mthode Open. Cette ouverture peut chouer comme toute
autre opration sur la base. C'est pourquoi l'ensemble du code d'accs la base est-il dans un try-catch. Une fois la connexion tablie,
on peut mettre des requtes SQL sur la base.
Dans notre exemple, aprs avoir ouvert la connexion la base, nous mettons une requte SQL SELECT pour avoir le contenu de
la table ARTICLES :
1. Une jointure est faite avec toutes les tables qui sont derrire le mot cl from
2. Seules les colonnes qui sont derrire le mot cl select sont conserves
3. Seules les lignes vrifiant la condition du mot cl where sont conserves
4. Les lignes rsultantes ordonnes selon lexpression du mot cl order by forment le rsultat de la requte.
Le rsultat dun select est une table. Si on considre la table ARTICLES prcdente et quon veuille les noms des articles dont le
stock actuel est au-dessous du seuil minimal, on crira :
L'exploitation du rsultat d'un select est typiquement une exploitation squentielle analogue celle des fichiers texte : on ne peut
qu'avancer dans la table, pas reculer :
while (objetOdbcDataReadet.Read()){
// on a une ligne - on l'exploite
....
// ligne suivante
}//while
La seule difficult est dans l'instruction o les valeurs des diffrentes colonnes de la ligne courante sont concatnes :
for(i=0;i<myReader.FieldCount;i++){
ligne+=myReader[i]+" ";
}
La notation ligne+=myReader[i] +" " est traduit par ligne+=myReader.Item[i].ToString()+" " o Item[i] est la valeur de la colonne i de la
ligne courante.
// fermeture lecteur
myReader.Close();
// fermeture connexion
articlesConn.Close();
Ces classes sont dans l'espace de noms System.Data.OleDb. Le programme prcdent peut tre transform aisment pour grer une
base OLE DB :
on remplace partout OdbcXX par OleDbXX
on modifie la chane de connexion. Pour une base ACCESS sans login/mot de passe, la chane de connexion est
Provider=Microsoft.JET.OLEDB.4.0;Data Source=[fichier.mdb]. La partie paramtrable de cette chane est le nom du fichier
ACCESS utiliser. Nous modifierons notre programme pour qu'il accepte en paramtre le nom de ce fichier.
l'espace de noms importer est maintenant System.Data.OleDb.
using System;
using System.Data;
using System.Data.OleDb;
class listArticles
{
static void Main(string[] args){
// application console
// affiche le contenu d'une table ARRTICLES d'une base DSN
// dont le nom est pass en paramtre
const string syntaxe="syntaxe : pg base_access_articles";
const string tabArticles="articles"; // la table des articles
// vrification des paramtres
// a-t-on 2 paramtres
if(args.Length!=1){
// msg d'erreur
Console.Error.WriteLine(syntaxe);
// fin
Environment.Exit(1);
}//if
// on rcupre le paramtre
string dbArticles=args[0]; // la base de donnes
// prparation de la connexion la bd
OleDbConnection articlesConn=null; // la connexion
OleDbDataReader myReader=null; // le lecteur de donnes
try{
// on tente d'accder la base de donnes
// chane de connexion la base
string connectString="Provider=Microsoft.JET.OLEDB.4.0;Data Source="+dbArticles+";";
articlesConn = new OleDbConnection(connectString);
articlesConn.Open();
// excution d'une commande SQL
string sqlText = "select * from " + tabArticles;
OleDbCommand myOleDbCommand = new OleDbCommand(sqlText);
myOleDbCommand.Connection = articlesConn;
myReader=myOleDbCommand.ExecuteReader();
// Exploitation de la table rcupre
// affichage des colonnes
string ligne="";
int i;
for(i=0;i<myReader.FieldCount-1;i++){
ligne+=myReader.GetName(i)+",";
Accs aux bases de donnes 152
}//for
ligne+=myReader.GetName(i);
Console.Out.WriteLine("\n"+"".PadLeft(ligne.Length,'-')+"\n"+ligne+"\n"+"".PadLeft(ligne.Length,'-
')+"\n");
// affichage des donnes
while (myReader.Read()) {
// exploitation ligne courante
ligne="";
for(i=0;i<myReader.FieldCount;i++){
ligne+=myReader[i]+" ";
}
Console.WriteLine(ligne);
}//while
}//try
catch(Exception ex){
Console.Error.WriteLine("Erreur d'exploitation de la base de donnes ("+ex.Message+")");
Environment.Exit(2);
}//catch
finally{
try{
// fermeture lecteur
myReader.Close();
// fermeture connexion
articlesConn.Close();
}catch{}
}//finally
// fin
Environment.Exit(0);
}//main
}//classe
E:\data\serge\MSNET\c#\adonet\6>csc liste.cs
E:\data\serge\MSNET\c#\adonet\6>dir
07/05/2002 15:09 2 325 liste.CS
07/05/2002 15:09 4 608 liste.exe
20/08/2001 11:54 86 016 ARTICLES.MDB
E:\data\serge\MSNET\c#\adonet\6>liste articles.mdb
----------------------------------------
code,nom,prix,stock_actuel,stock_minimum
----------------------------------------
E:\data\serge\MSNET\c#\adonet\7>sql mysql-articles
----------------------------------------
code,nom,prix,stock_actuel,stock_minimum
----------------------------------------
Requte SQL (fin pour arrter) : select * from articles where stock_actuel<stock_minimum
Requte SQL (fin pour arrter) : insert into articles values ("1","1",1,1,1)
Il y a eu 1 ligne(s) modifie(s)
----------------------------------------
code,nom,prix,stock_actuel,stock_minimum
----------------------------------------
Requte SQL (fin pour arrter) : update articles set nom="2" where nom="1"
Il y a eu 1 ligne(s) modifie(s)
----------------------------------------
code,nom,prix,stock_actuel,stock_minimum
----------------------------------------
Requte SQL (fin pour arrter) : delete from articles where code="1"
Il y a eu 1 ligne(s) modifie(s)
----------------------------------------
code,nom,prix,stock_actuel,stock_minimum
----------------------------------------
Requte SQL (fin pour arrter) : select * from articles order by nom asc
----------------------------------------
code,nom,prix,stock_actuel,stock_minimum
----------------------------------------
using System;
using System.Data;
using Microsoft.Data.Odbc;
using System.Text.RegularExpressions;
using System.Collections;
Nous ne commentons ici que ce qui est nouveau par rapport au programme prcdent :
ce qui nous permet ensuite de vrifier simplement si le 1er mot (champs[0]) de la requte tape est l'une des
quatre commandes acceptes :
// requte valide ?
if (champs.Length==0 || ! dicoCommandes.ContainsKey(champs[0])){
// msg d'erreur
Console.Error.WriteLine("Requte invalide. Utilisez select, insert, update, delete");
// requte suivante
continue;
}//if
Auparavant la requte avait t dcompose en champs l'aide de la mthode Split de la classe RegEx :
Les mots composant la requte peuvent tre spars d'un nombre quelconque d'espaces.
L'excution d'une requte select n'utilise pas la mme mthode que celle d'une requte d'une mise jour (insert, update, delete).
Aussi doit-on faire un test et excuter une fonction diffrente pour chacu de ces deux cas :
// excution de la requte
try{
if(champs[0]=="select"){
executeSelect(sqlCommand);
} else executeUpdate(sqlCommand);
}//try
catch(Exception ex){
// msg d'erreur
Console.Error.WriteLine("Erreur d'exploitation de la base de donnes ("+ex.Message+")");
}//catch
L'excution d'une requte SQL peut gnrer une exception qui est ici gre.
// calcul de l'impt
public long calculer(bool mari, int nbEnfants, int salaire){
// calcul du nombre de parts
decimal nbParts;
if (mari) nbParts=(decimal)nbEnfants/2+2;
else nbParts=(decimal)nbEnfants/2+1;
if (nbEnfants>=3) nbParts+=0.5M;
// calcul revenu imposable & Quotient familial
decimal revenu=0.72M*salaire;
decimal QF=revenu/nbParts;
// calcul de l'impt
limites[limites.Length-1]=QF+1;
int i=0;
while(QF>limites[i]) i++;
// retour rsultat
return (long)(revenu*coeffR[i]-nbParts*coeffN[i]);
}//calculer
}//classe
Nous lui ajoutons un nouveau constructeur permettant d'initialiser les tableaux limites, coeffR, coeffN partir d'une base de donnes
ODBC :
using System.Data;
using Microsoft.Data.Odbc;
using System.Collections;
// constructeur 2
public impt(string DSNimpots, string Timpots, string colLimites, string colCoeffR, string colCoeffN){
// initialise les trois tableaux limites, coeffR, coeffN partir
// du contenu de la table Timpots de la base ODBC DSNimpots
// colLimites, colCoeffR, colCoeffN sont les trois colonnes de cette table
// peut lancer une exception
string connectString="DSN="+DSNimpots+";"; // chane de connexion la base
OdbcConnection impotsConn=null; // la connexion
OdbcCommand sqlCommand=null; // la commande SQL
// la requte SELECT
string selectCommand="select "+colLimites+","+colCoeffR+","+colCoeffN+" from "+Timpots;
// tableaux pour rcuprer les donnes
ArrayList tLimites=new ArrayList();
ArrayList tCoeffR=new ArrayList();
ArrayList tCoeffN=new ArrayList();
// on tente d'accder la base de donnes
impotsConn = new OdbcConnection(connectString);
impotsConn.Open();
// on cre un objet command
sqlCommand=new OdbcCommand(selectCommand,impotsConn);
// on excute la requte
OdbcDataReader myReader=sqlCommand.ExecuteReader();
// Exploitation de la table rcupre
while (myReader.Read()) {
Accs aux bases de donnes 157
// les donnes de la ligne courante sont mis dans les tableaux
tLimites.Add(myReader[colLimites]);
tCoeffR.Add(myReader[colCoeffR]);
tCoeffN.Add(myReader[colCoeffN]);
}//while
// libration des ressources
myReader.Close();
impotsConn.Close();
Le programme de test est le suivant : il reoit en arguments les paramtres transmettre au constructeur de la classe impt. Aprs
avoir construit un objet impt, il fait des calculs d'impt payer :
using System;
class test
{
public static void Main(string[] arguments)
{
// programme interactif de calcul d'impt
// l'utilisateur tape trois donnes au clavier : mari nbEnfants salaire
// le programme affiche alors l'impt payer
// Fields
// Constructors
public Thread(System.Threading.ThreadStart start);
// Properties
public ApartmentState ApartmentState { get; set; }
public static Context CurrentContext { get; }
public CultureInfo CurrentCulture { get; set; }
public static IPrincipal CurrentPrincipal { get; set; }
public static Thread CurrentThread { get; }
public CultureInfo CurrentUICulture { get; set; }
public bool IsAlive { get; }
public bool IsBackground { get; set; }
public bool IsThreadPoolThread { get; }
public string Name { get; set; }
public ThreadPriority Priority { get; set; }
public ThreadState ThreadState { get; }
// Methods
public void Abort();
public void Abort(object stateInfo);
public static LocalDataStoreSlot AllocateDataSlot();
public static LocalDataStoreSlot AllocateNamedDataSlot(string name);
public virtual bool Equals(object obj);
public static void FreeNamedDataSlot(string name);
public static object GetData(LocalDataStoreSlot slot);
public static AppDomain GetDomain();
public static int GetDomainID();
public virtual int GetHashCode();
public static LocalDataStoreSlot GetNamedDataSlot(string name);
public Type GetType();
public void Interrupt();
public void Join();
public bool Join(int millisecondsTimeout);
public bool Join(TimeSpan timeout);
public static void ResetAbort();
public void Resume();
public static void SetData(LocalDataStoreSlot slot, object data);
public static void Sleep(int millisecondsTimeout);
public static void Sleep(TimeSpan timeout);
public static void SpinWait(int iterations);
public void Start();
public void Suspend();
public virtual string ToString();
} // end of System.Threading.Thread
Regardons une premire application mettant en vidence l'existence d'un thread principal d'excution, celui dans lequel s'excute la
fonction Main d'une classe :
// utilisation de threads
using System;
using System.Threading;
Les threads d'excution 161
public class thread1{
public static void Main(){
// init thread courant
Thread main=Thread.CurrentThread;
// affichage
Console.Out.WriteLine("Thread courant : " + main.Name);
// on change le nom
main.Name="main";
// vrification
Console.Out.WriteLine("Thread courant : " + main.Name);
// boucle infinie
while(true){
// affichage
Console.Out.WriteLine(main.Name + " : " +DateTime.Now.ToString("hh:mm:ss"));
// arrt temporaire
Thread.Sleep(1000);
}//while
}//main
}//classe
E:\data\serge\MSNET\c#\threads\2>thread1
Thread courant :
Thread courant : main
main : 06:13:55
main : 06:13:56
main : 06:13:57
main : 06:13:58
main : 06:13:59
^C
ThreadStart est de type delegate et dfinit le prototype d'une fonction sans paramtres. Une construction classique est la
suivante :
Thread T=new Thread(new ThreadStart(run));
La fonction run passe en paramtres sera excute au lancement du Thread.
2. L'excution du thread T est lanc par T.Start() : la fonction run passe au constructeur de T va alors tre excute par le
thread T. Le programme qui excute l'instruction T.start() n'attend pas la fin de la tche T : il passe aussitt l'instruction
qui suit. On a alors deux tches qui s'excutent en parallle. Elles doivent souvent pouvoir communiquer entre elles pour
savoir o en est le travail commun raliser. C'est le problme de synchronisation des threads.
3. Une fois lanc, le thread s'excute de faon autonome. Il s'arrtera lorsque la fonction start qu'il excute aura fini son travail.
4. On peut envoyer certains signaux la tche T :
a. T.Suspend() lui dit de s'arrter momentanment
b. T.Resume() lui dit de reprendre son travail
c. T.Abort() lui dit de s'arrter dfinitivement
5. On peut aussi attendre la fin de son excution par T.join(). On a l une instruction bloquante : le programme qui l'excute
est bloqu jusqu' ce que la tche T ait termin son travail. C'est un moyen de synchronisation.
using System;
using System.Threading;
// fin de main
Console.Out.WriteLine("fin du thread " +main.Name);
}//Main
public static void affiche(){
// affichage dbut d'excution
Console.Out.WriteLine("Dbut d'excution de la mthode affiche dans le Thread " +
Thread.CurrentThread.Name
+ " : " + DateTime.Now.ToString("hh:mm:ss"));
// mise en sommeil pendant 1 s
Thread.Sleep(1000);
// affichage fin d'excution
Console.Out.WriteLine("Fin d'excution de la mthode affiche dans le Thread " +
Thread.CurrentThread.Name
+ " : " + DateTime.Now.ToString("hh:mm:ss"));
}//
}//classe
Le thread principal, celui qui excute la fonction Main, cre 5 autres threads chargs d'excuter la mthode statique affiche. Les
rsultats sont les suivants :
on voit tout d'abord que le lancement de l'excution d'un thread n'est pas bloquante. La mthode Main a lanc l'excution
de 5 threads en parallle et a termin son excution avant eux. L'opration
lance l'excution du thread tches[i] mais ceci fait, l'excution se poursuit immdiatement avec l'instruction qui suit sans
attendre la fin d'excution du thread.
tous les threads crs doivent excuter la mthode affiche. L'ordre d'excution est imprvisible. Mme si dans l'exemple,
l'ordre d'excution semble suivre l'ordre des demandes d'excution, on ne peut en conclure de gnralits. Le systme
d'exploitation a ici 6 threads et un processeur. Il va distribuer le processeur ces 6 threads selon des rgles qui lui sont
propres.
on voit dans les rsultats une consquence de la mthode Sleep. dans l'exemple, c'est le thread 0 qui excute le premier la
mthode affiche. Le message de dbut d'excution est affich puis il excute la mthode Sleep qui le suspend pendant 1
seconde. Il perd alors le processeur qui devient ainsi disponible pour un autre thread. L'exemple montre que c'est le thread
1 qui va l'obtenir. Le thread 1 va suivre le mme parcours ainsi que les autres threads. Lorsque la seconde de sommeil du
thread 0 va tre termine, son excution peut reprendre. Le systme lui donne le processeur et il peut terminer l'excution
de la mthode affiche.
Modifions notre programme pour le terminer la mthode Main par les instructions :
Les threads d'excution 163
// fin de main
Console.Out.WriteLine("fin du thread " +main.Name);
Environment.Exit(0);
Les threads crs par la fonction Main ne sont pas excuts. C'est l'instruction
Environment.Exit(0);
qui fait cela : elle supprime tous les threads de l'application et non simplement le thread Main. La solution ce problme est que la
mthode Main attende la fin d'excution des threads qu'elle a crs avant de se terminer elle-mme. Cela peut se faire avec la
mthode Join de la classe Thread :
C1
Serveur S1
C2
Cn
Nous utilisons tous les jours des applications de l'internet correspondant ce schma : services Web, messagerie lectronique,
consultation de forums, transfert de fichiers... Dans le schma ci-dessus, le serveur S1 doit servir les clients Ci de faon simultane.
Si nous prenons l'exemple d'un serveur FTP (File Transfer Protocol) qui dlivre des fichiers ses clients, nous savons qu'un
transfert de fichier peut prendre parfois plusieurs heures. Il est bien sr hors de question qu'un client monopolise tout seul le
serveur une telle dure. Ce qui est fait habituellement, c'est que le serveur cre autant de threads d'excution qu'il y a de clients.
Chaque thread est alors charg de s'occuper d'un client particulier. Le processeur tant partag cycliquement entre tous les threads
actifs de la machine, le serveur passe alors un peu de temps avec chaque client assurant ainsi la simultanit du service.
thread 1 client 1
thread 2 client 2
thread n client n
// utilisation de threads
using System;
using System.Threading;
public class thread1{
// variables de classe
static int cptrThreads=0; // compteur de threads
//main
public static void Main(String[] args){
// mode d'emploi
const string syntaxe="pg nbThreads";
const int nbMaxThreads=100;
// vrification nbre d'arguments
if(args.Length!=1){
// erreur
Console.Error.WriteLine(syntaxe);
// arrt
Environment.Exit(1);
}//if
// vrification qualit de l'argument
int nbThreads=0;
try{
nbThreads=int.Parse(args[0]);
if(nbThreads<1 || nbThreads>nbMaxThreads)
throw new Exception();
}catch{
// erreur
Console.Error.WriteLine("Nombre de threads incorrect (entre 1 et 100)");
// fin
Environment.Exit(2);
}//catch
// cration et gnration des threads
Thread[] threads=new Thread[nbThreads];
for(int i=0;i<nbThreads;i++){
// cration
threads[i]=new Thread(new ThreadStart(incrmente));
// nommage
threads[i].Name=""+i;
// lancement
threads[i].Start();
}//for
// attente de la fin des threads
for(int i=0;i<nbThreads;i++)
threads[i].Join();
// affichage compteur
Console.Out.WriteLine("Nombre de threads gnrs : " +cptrThreads);
Les threads d'excution 165
}//Main
public static void incrmente(){
// augmente le compteur de threads
// lecture compteur
int valeur=cptrThreads;
// suivi
Console.Out.WriteLine("A "+DateTime.Now.ToString("hh:mm:ss")+ ", le thread
"+Thread.CurrentThread.Name+" a lu la valeur du compteur : " +cptrThreads);
// attente
Thread.Sleep(1000);
// incrmentation compteur
cptrThreads=valeur+1;
// suivi
Console.Out.WriteLine("A "+DateTime.Now.ToString("hh:mm:ss")+ ", le thread
"+Thread.CurrentThread.Name+" a crit la valeur du compteur : " +cptrThreads);
}//incrmente
}//classe
Nous ne nous attarderons pas sur la partie gnration de threads dj tudie. Intressons-nous plutt la mthode incrmente,
utilise par chaque thread pour incrmenter le compteur statique cptrThreads.
1. le compteur est lu
2. le thread s'arrte 1 s. Il perd donc le processeur
3. le compteur est incrment
L'tape 2 n'est l que pour forcer le thread perdre le processeur. Celui-ci va tre donn un autre thread. Dans la pratique, rien
n'assure qu'un thread ne sera pas interrompu entre le moment o il va lire le compteur et le moment o il va l'incrmenter. Mme si
on crit cptrThreads++, donnant ainsi l'illusion d'une instruction unique, le risque existe de perdre le processeur entre le moment o
on lit la valeur du compteur et celui on crit sa valeur incrmente de 1. En effet, l'opration de haut niveau cptrThreads++ va faire
l'objet de plusieurs instructions lmentaires au niveau du processeur. L'tape 2 de sommeil d'une seconde n'est donc l que pour
systmatiser ce risque.
E:\data\serge\MSNET\c#\threads\5>comptage 5
A 09:15:58, le thread 0 a lu la valeur du compteur : 0
A 09:15:58, le thread 1 a lu la valeur du compteur : 0
A 09:15:58, le thread 2 a lu la valeur du compteur : 0
A 09:15:58, le thread 3 a lu la valeur du compteur : 0
A 09:15:58, le thread 4 a lu la valeur du compteur : 0
A 09:15:59, le thread 0 a crit la valeur du compteur : 1
A 09:15:59, le thread 1 a crit la valeur du compteur : 1
A 09:15:59, le thread 2 a crit la valeur du compteur : 1
A 09:15:59, le thread 3 a crit la valeur du compteur : 1
A 09:15:59, le thread 4 a crit la valeur du compteur : 1
Nombre de threads gnrs : 1
D'o vient le problme ? Le second thread a lu une mauvaise valeur du fait que le premier avait t interrompu avant d'avoir
termin son travail qui tait de mettre jour le compteur dans la fentre. Cela nous amne la notion de ressource critique et de
section critique d'un programme:
" une ressource critique est une ressource qui ne peut tre dtenue que par un thread la fois. Ici la ressource critique
est le compteur.
" une section critique d'un programme est une squence d'instructions dans le flux d'excution d'un thread au cours de
laquelle il accde une ressource critique. On doit assurer qu'au cours de cette section critique, il est le seul avoir
accs la ressource.
// lecture compteur
int valeur=cptrThreads;
Les threads d'excution 166
// attente
Thread.Sleep(1000);
// incrmentation compteur
cptrThreads=valeur+1;
Pour excuter ce code, un thread doit tre assur d'tre tout seul. Il peut tre interrompu mais pendant cette interruption, un autre
thread ne doit pas pouvoir excuter ce mme code. La plate-forme .NET offre plusieurs outils pour assurer l'entre unitaire dans les
sections critiques de code. Nous utiliserons la classe Mutex :
Un Mutex M gre l'accs une ressource partage R. Un thread demande la ressource R par M.WaitOne() et la rend par
M.ReleaseMutex(). Une section critique de code qui ne doit tre excute que par un seul thread la fois est une ressource partage.
La synchronisation d'excution de la section critique peut se faire ainsi :
M.WaitOne();
// le thread est seul entrer ici
// section critique
....
M.ReleaseMutex();
o M est un objet Mutex. Il faut bien sr ne jamais oublier de librer un Mutex devenu inutile pour qu'un autre thread puisse entrer
dans la section critique, sinon les threads en attente d'un Mutex jamais libr n'auront jamais accs au processeur. Par ailleurs, il faut
viter la situation d'interblocage (deadlock) dans laquelle deux threads s'attendent mutuellement. Considrons les actions suivantes
qui se suivent dans le temps :
" un thread T1 obtient la proprit d'un Mutex M1 pour avoir accs une ressource partage R1
" un thread T2 obtient la proprit d'un Mutex M2 pour avoir accs une ressource partage R2
" le thread T1 demande le Mutex M2. Il est bloqu.
" le thread T2 demande le Mutex M1. Il est bloqu.
Ici, les threads T1 et T2 s'attendent mutuellement. Ce cas apparat lorsque des threads ont besoin de deux ressources partages, la
ressource R1 contrle par le Mutex M1 et la ressource R2 contrle par le Mutex M2. Une solution possible est de demander les
deux ressources en mme temps l'aide d'un Mutex unique M. Mais ce n'est pas toujours possible si par exemple cela entrane une
mobilisation longue d'une ressource coteuse. Une autre solution est qu'un thread ayant M1 et ne pouvant obtenir M2, relche alors
M1 pour viter l'interblocage.
Les threads d'excution 167
Si nous mettons en pratique ce que nous venons de voir sur l'exemple prcdent, notre application devient la suivante :
// utilisation de threads
using System;
using System.Threading;
public class thread1{
// variables de classe
static int cptrThreads=0; // compteur de threads
static Mutex autorisation; // autorisation d'accs une section critique
//main
public static void Main(String[] args){
// mode d'emploi
const string syntaxe="pg nbThreads";
const int nbMaxThreads=100;
// vrification nbre d'arguments
if(args.Length!=1){
// erreur
Console.Error.WriteLine(syntaxe);
// arrt
Environment.Exit(1);
}//if
// vrification qualit de l'argument
int nbThreads=0;
try{
nbThreads=int.Parse(args[0]);
if(nbThreads<1 || nbThreads>nbMaxThreads)
throw new Exception();
}catch{
// erreur
Console.Error.WriteLine("Nombre de threads incorrect (entre 1 et 100)");
// fin
Environment.Exit(2);
}//catch
// initialisation de l'autorisation d'accs une section critique
autorisation=new Mutex();
// cration et gnration des threads
Thread[] threads=new Thread[nbThreads];
for(int i=0;i<nbThreads;i++){
// cration
threads[i]=new Thread(new ThreadStart(incrmente));
// nommage
threads[i].Name=""+i;
// lancement
threads[i].Start();
}//for
// attente de la fin des threads
for(int i=0;i<nbThreads;i++)
threads[i].Join();
// affichage compteur
Console.Out.WriteLine("Nombre de threads gnrs : " +cptrThreads);
}//Main
public static void incrmente(){
// augmente le compteur de threads
// on demande l'autorisation d'entrer dans la secton critique
autorisation.WaitOne();
// lecture compteur
int valeur=cptrThreads;
// suivi
Console.Out.WriteLine("A "+DateTime.Now.ToString("hh:mm:ss")+ ", le thread
"+Thread.CurrentThread.Name+" a lu la valeur du compteur : " +cptrThreads);
// attente
Thread.Sleep(1000);
// incrmentation compteur
cptrThreads=valeur+1;
// suivi
Console.Out.WriteLine("A "+DateTime.Now.ToString("hh:mm:ss")+ ", le thread
"+Thread.CurrentThread.Name+" a crit la valeur du compteur : " +cptrThreads);
// on rend l'autorisation d'accs
autorisation.ReleaseMutex();
}//incrmente
}//classe
E:\data\serge\MSNET\c#\threads\6>comptage 5
A 10:11:37, le thread 0 a lu la valeur du compteur : 0
A 10:11:38, le thread 0 a crit la valeur du compteur : 1
A 10:11:38, le thread 1 a lu la valeur du compteur : 1
A 10:11:39, le thread 1 a crit la valeur du compteur : 2
A 10:11:39, le thread 2 a lu la valeur du compteur : 2
Les threads d'excution 168
A 10:11:40, le thread 2 a crit la valeur du compteur : 3
A 10:11:40, le thread 3 a lu la valeur du compteur : 3
A 10:11:41, le thread 3 a crit la valeur du compteur : 4
A 10:11:41, le thread 4 a lu la valeur du compteur : 4
A 10:11:42, le thread 4 a crit la valeur du compteur : 5
Nombre de threads gnrs : 5
1. On a un tableau dans lequel des processus viennent dposer des donnes (les producteurs) et d'autres viennent les lire (les
consommateurs).
2. Les producteurs sont gaux entre-eux mais exclusifs : un seul producteur la fois peut dposer ses donnes dans le tableau.
3. Les consommateurs sont gaux entre-eux mais exclusifs : un seul lecteur la fois peut lire les donnes dposes dans le tableau.
4. Un consommateur ne peut lire les donnes du tableau que lorsqu'un producteur en a dpos dedans et un producteur ne peut
dposer de nouvelles donnes dans le tableau que lorsque celles qui y sont ont t consommes.
L'accs ces deux ressources partages peut tre contrle par des Mutex comme vu prcdemment, un pour chaque ressource.
Une fois qu'un consommateur a obtenu le tableau en lecture, il doit vrifier qu'il y a bien des donnes dedans. On utilisera un
vnement pour l'en avertir. De mme un producteur ayant obtenu le tableau en criture devra attendre qu'un consommateur l'ait
vid. On utilisera l encore un vnement.
Ce type d'vnement est analogue un boolen mais vite des attentes actives ou semi-actives. Ainsi le droit d'criture est contrl
par un boolen peutEcrire, un producteur avant d'crire excutera un code du genre :
Dans la premire mthode, le thread mobilise inutilement le processeur. Dans la seconde, il vrifie l'tat du boolen peutEcrire toutes
les 100 ms. La classe AutoResetEvent permet encore d'amliorer les choses : le thread va demander tre rveill lorsque l'vnement
qu'il attend se sera produit :
L'opration
Les threads d'excution 169
AutoEvent peutEcrire=new AutoResetEvent(false); // peutEcrire=false;
excute par un thread fait que celui-ci passe si le boolen peutEcrire est vrai ou sinon est bloqu jusqu' ce qu'il devienne vrai. Un
autre thread le passera vrai par l'opration peutEcrire.Set() ou faux par l'opration peutEcrire.Reset().
//fin de main
Console.Out.WriteLine("fin de Main...");
}//Main
// lire le contenu du tableau
public static void lire(){
// section critique
lecteur.WaitOne(); // un seul lecteur peut passer
peutLire.WaitOne(); // on doit pouvoir lire
// lecture tableau
for(int i=0;i<data.Length;i++){
//attente 1 s
Thread.Sleep(1000);
// affichage
Console.Out.WriteLine(DateTime.Now.ToString("hh:mm:ss") + " : Le lecteur "+
Thread.CurrentThread.Name+ " a lu le nombre " +data[i]);
}//for
// on ne peut plus lire
peutLire.Reset();
// on peut crire
peutEcrire.Set();
// fin de section critique
lecteur.ReleaseMutex();
}//lire
// crire dans le tableau
Les threads d'excution 170
public static void crire(){
// section critique
// un seul crivain peut passer
crivain.WaitOne();
// on doit attendre l'autorisation d'criture
peutEcrire.WaitOne();
// criture tableau
for(int i=0;i<data.Length;i++){
//attente 1 s
Thread.Sleep(1000);
// affichage
data[i]=objRandom.Next(0,1000);
Console.Out.WriteLine(DateTime.Now.ToString("hh:mm:ss") + " : L'crivain "+
Thread.CurrentThread.Name + " a crit le nombre " +data[i]);
}//for
// on ne peut plus crire
peutEcrire.Reset();
// on peut lire
peutLire.Set();
//fin de section critique
crivain.ReleaseMutex();
}//lire
}//classe
E:\data\serge\MSNET\c#\threads\8>readwrite
fin de Main...
11:52:41 : L'crivain 0 a crit le nombre 623
11:52:42 : L'crivain 0 a crit le nombre 554
11:52:43 : L'crivain 0 a crit le nombre 727
11:52:44 : L'crivain 0 a crit le nombre 95
11:52:45 : L'crivain 0 a crit le nombre 265
11:52:46 : Le lecteur 0 a lu le nombre 623
11:52:47 : Le lecteur 0 a lu le nombre 554
11:52:48 : Le lecteur 0 a lu le nombre 727
11:52:49 : Le lecteur 0 a lu le nombre 95
11:52:50 : Le lecteur 0 a lu le nombre 265
11:52:51 : L'crivain 1 a crit le nombre 514
11:52:52 : L'crivain 1 a crit le nombre 828
11:52:53 : L'crivain 1 a crit le nombre 509
11:52:54 : L'crivain 1 a crit le nombre 926
11:52:55 : L'crivain 1 a crit le nombre 23
11:52:56 : Le lecteur 1 a lu le nombre 514
11:52:57 : Le lecteur 1 a lu le nombre 828
11:52:58 : Le lecteur 1 a lu le nombre 509
11:52:59 : Le lecteur 1 a lu le nombre 926
11:53:00 : Le lecteur 1 a lu le nombre 23
11:53:01 : L'crivain 2 a crit le nombre 761
11:53:02 : L'crivain 2 a crit le nombre 695
11:53:03 : L'crivain 2 a crit le nombre 130
11:53:04 : L'crivain 2 a crit le nombre 279
^C
on a bien 1 seul lecteur la fois bien que celui-ci perde le processeur dans la section critique lire
on a bien 1 seul crivain la fois bien que celui-ci perde le processeur dans la section critique crire
un lecteur ne lit que lorsqu'il y a quelque chose lire dans le tableau
un crivain n'crit que lorsque le tableau a t entirement lu
Le texte qui suit est une traduction partielle d'un texte que l'on trouve dans le document "Lan Workplace for Dos - Administrator's
Guide" de NOVELL, document du dbut des annes 90.
-----------------------------------
Le concept gnral de crer un rseau d'ordinateurs htrognes vient de recherches effectues par le DARPA (Defense Advanced
Research Projects Agency) aux Etats-Unis. Le DARPA a dvelopp la suite de protocoles connue sous le nom de TCP/IP qui
permet des machines htrognes de communiquer entre elles. Ces protocoles ont t tests sur un rseau appel ARPAnet,
rseau qui devint ultrieurement le rseau INTERNET. Les protocoles TCP/IP dfinissent des formats et des rgles de
transmission et de rception indpendants de l'organisation des rseaux et des matriels utiliss.
Le rseau conu par le DARPA et gr par les protocoles TCP/IP est un rseau commutation de paquets. Un tel rseau
transmet l'information sur le rseau, en petits morceaux appels paquets. Ainsi, si un ordinateur transmet un gros fichier, ce dernier
sera dcoup en petits morceaux qui seront envoys sur le rseau pour tre recomposs destination. TCP/IP dfinit le format de
ces paquets, savoir :
. origine du paquet
. destination
. longueur
. type
|-------------------------------------|
7 | Application |
|-------------------------------------|
6 | Prsentation |
|-------------------------------------|
5 | Session |
|-------------------------------------|
4 | Transport |
|-------------------------------------|
3 | Rseau |
|-------------------------------------|
2 | Liaison |
|-------------------------------------|
1 | Physique |
|-------------------------------------|
Chaque couche reoit des services de la couche infrieure et offre les siens la couche suprieure. Supposons que deux applications
situes sur des machines A et B diffrentes veulent communiquer : elles le font au niveau de la couche Application. Elles n'ont pas
besoin de connatre tous les dtails du fonctionnement du rseau : chaque application remet l'information qu'elle souhaite
A chaque couche, le processus expditeur charg d'envoyer l'information, l'envoie un processus rcepteur sur l'autre machine
apartenant la mme couche que lui. Il le fait selon certaines rgles que l'on appelle le protocole de la couche. On a donc le
schma de communication final suivant :
Machine A Machine B
+-------------------------------------+ +----------------------------+
7 Application v ^ Application
+------------------------------------ +---------------------------
6 Prsentation v ^ Prsentation
+------------------------------------ +---------------------------
5 Session v ^ Session
+------------------------------------ +---------------------------
4 Transport v ^ Transport
+------------------------------------ +---------------------------
3 Rseau v ^ Rseau
+------------------------------------ +---------------------------
2 Liaison v ^ Liaison
+------------------------------------ +---------------------------
1 Physique v ^ Physique
+------------------------------------+ +---------------------------+
^
+-->------->------>-----+
Physique Assure la transmission de bits sur un support physique. On trouve dans cette couche des quipements
terminaux de traitement des donnes (E.T.T.D.) tels que terminal ou ordinateur, ainsi que des quipements
de terminaison de circuits de donnes (E.T.C.D.) tels que modulateur/dmodulateur, multiplexeur,
concentrateur. Les points d'intrt ce niveau sont :
Couche Physique
En rseau local, on trouve gnralement une technologie Ethernet ou Token-Ring. Nous ne prsentons ici que la technologie
Ethernet.
Ethernet
C'est le nom donn une technologie de rseaux locaux commutation de paquets invente PARC Xerox au dbut des annes
1970 et normalise par Xerox, Intel et Digital Equipment en 1978. Le rseau est physiquement constitu d'un cble coaxial
d'environ 1,27 cm de diamtre et d'une longueur de 500 m au plus. Il peut tre tendu au moyen de rpteurs, deux machines ne
pouvant tre spares par plus de deux rpteurs. Le cble est passif : tous les lments actifs sont sur les machines raccordes au
cble. Chaque machine est relie au cble par une carte d'accs au rseau comprenant :
un transmetteur (transceiver) qui dtecte la prsence de signaux sur le cble et convertit les signaux analogiques en signaux
numrique et inversement.
un coupleur qui reoit les signaux numriques du transmetteur et les transmet l'ordinateur pour traitement ou
inversement.
Capacit de 10 Mgabits/seconde.
Topologie en bus : toutes les machines sont raccordes au mme cble
----------------------------------------------------------
+--------+ +--------+ +-----------+
+--------+ +--------+ +-----------+
Machine A B C
Rseau diffusant - Une machine qui met transfre des informations sur le cble avec l'adresse de la machine destinatrice.
Toutes les machines raccordes reoivent alors ces informations et seule celle qui elles sont destines les conserve.
La mthode d'accs est la suivante : le transmetteur dsirant mettre coute le cble - il dtecte alors la prsence ou non
d'une onde porteuse, prsence qui signifierait qu'une transmission est en cours. C'est la technique CSMA (Carrier Sense
Multiple Access). En l'absence de porteuse, un transmetteur peut dcider de transmettre son tour. Ils peuvent tre
plusieurs prendre cette dcision. Les signaux mis se mlangent : on dit qu'il y a collision. Le transmetteur dtecte cette
situation : en mme temps qu'il met sur le cble, il coute ce qui passe rellement sur celui-ci. S'il dtecte que
l'information transitant sur le cble n'est pas celle qu'il a mise, il en dduit qu'il y a collision et il s'arrtera d'mettre. Les
autres transmetteurs qui mettaient feront de mme. Chacun reprendra son mission aprs un temps alatoire dpendant
de chaque transmetteur. Cette technique est appele CD (Collision Detect). La mthode d'accs est ainsi appele
CSMA/CD.
un adressage sur 48 bits. Chaque machine a une adresse, appele ici adresse physique, qui est inscrite sur la carte qui la relie
au cble. On appelle cet adresse, l'adresse Ethernet de la machine.
Couche Rseau
Nous trouvons au niveau de cette couche, les protocoles IP, ICMP, ARP et RARP.
Couches Transport/Session
TCP (Transmission Control Protocol) Assure une remise fiable d'informations entre deux clients
UDP (User Datagram Protocol) Assure une remise non fiable d'informations entre deux clients
Couches Application/Prsentation/Session
TELNET Emulateur de terminal permettant une machine A de se connecter une machine B en tant
que terminal
SMTP (Simple Mail Transfer permet l'change de messages entre utilisateurs du rseau
protocol)
DNS (Domain Name System) transforme un nom de machine en adresse Internet de la machine
XDR (eXternal Data cr par sun MicroSystems, il spcifie une reprsentation standard des donnes,
Representation) indpendante des machines
RPC(Remote Procedures Call) dfini galement par Sun, c'est un protocole de communication entre applications distantes,
indpendant de la couche transport. Ce protocole est important : il dcharge le
programmeur de la connaissance des dtails de la couche transport et rend les applications
portables. Ce protocole s'appuie sur sur le protocole XDR
NFS (Network File System) toujours dfini par Sun, ce protocole permet une machine, de "voir" le systme de fichiers
d'une autre machine. Il s'appuie sur le protocole RPC prcdent
Prenons un exemple : l'application FTP, dfinie au niveau de la couche Application et qui permet des transferts de fichiers entre
machines.
L'adresse Internet d'un noeud est une adresse logique : elle est indpendante du matriel et du rseau utilis. C'est une adresse sur
4 octets identifiant la fois un rseau local et un noeud de ce rseau. L'adresse Internet est habituellement reprsente sous la
forme de 4 nombres, valeurs des 4 octets, spars par un point. Ainsi l'adresse de la machine Lagaffe de la facult des Sciences
d'Angers est note 193.49.144.1 et celle de la machine Liny 193.49.144.9. On en dduira que l'adresse Internet du rseau local est
193.49.144.0. On pourra avoir jusqu' 254 noeuds sur ce rseau.
Parce que les adresses Internet ou adresses IP sont indpendantes du rseau, une machine d'un rseau A peut communiquer avec
une machine d'un rseau B sans se proccuper du type de rseau sur lequel elle se trouve : il suffit qu'elle connaisse son adresse IP.
Le protocole IP de chaque rseau se charge de faire la conversion adresse IP <--> adresse physique, dans les deux sens.
Les adresses IP doivent tre toutes diffrentes. En France, c'est l'INRIA qui s'occupe d'affecter les adresses IP. En fait, cet
organisme dlivre une adresse pour votre rseau local, par exemple 193.49.144.0 pour le rseau de la facult des sciences d'Angers.
L'administrateur de ce rseau peut ensuite affecter les adresses IP 193.49.144.1 193.49.144.254 comme il l'entend. Cette adresse
est gnralement inscrite dans un fichier particulier de chaque machine relie au rseau.
Programmation TCP-IP 176
8.1.5.1 Les classes d'adresses IP
Une adresse IP est une suite de 4 octets note souvent I1.I2.I3.I4, qui contient en fait deux adresses :
. l'adresse du rseau
. l'adresse d'un noeud de ce rseau
Selon la taille de ces deux champs, les adresses IP sont divises en 3 classes : classes A, B et C.
Classe A
1 octet 3 octets
+-------------------------------------------------------------------------------+
0 adr. rseau adresse noeud
+-------------------------------------------------------------------------------+
L'adresse rseau est sur 7 bits et l'adresse du noeud sur 24 bits. On peut donc avoir 127 rseaux de classe A, chacun comportant
jusqu' 224 noeuds.
Classe B
2 octets 2 octets
+-------------------------------------------------------------------------------+
10 adresse rseau adresse noeud
+-------------------------------------------------------------------------------+
L'adresse du rseau est sur 2 octets (14 bits exactement) ainsi que celle du noeud. On peut donc avoir 214 rseaux de classe B
chacun comportant jusqu' 216 noeuds.
Classe C
3 octets 1 octet
+-------------------------------------------------------------------------------+
110 adresse rseau adr. noeud
+-------------------------------------------------------------------------------+
L'adresse rseau est sur 3 octets (moins 3 bits) et l'adresse du noeud sur 1 octet. On peut donc avoir 221 rseaux de classe C
comportant jusqu' 256 noeuds.
Adresses rserves
. Certaines adresses IP sont des adresses de rseaux plutt que des adresses de noeuds dans le rseau. Ce sont celles, o
l'adresse du noeud est mise 0. Ainsi, l'adresse 193.49.144.0 est l'adresse IP du rseau de la Facult des Sciences d'Angers.
En consquence, aucun noeud d'un rseau ne peut avoir l'adresse zro.
. Lorsque dans une adresse IP, l'adresse du noeud ne comporte que des 1, on a alors une adresse de diffusion : cette adresse
dsigne tous les noeuds du rseau.
. Dans un rseau de classe C, permettant thoriquement 28=256 noeuds, si on enlve les deux adresses interdites, on n'a
plus que 254 adresses autorises.
Le paquet IP contient donc les adresses Internet des machines source et destination. Lorsque ce paquet va tre transmis la couche
charge de l'envoyer sur le rseau physique, d'autres informations lui sont ajoutes pour former la trame physique qui sera
finalement envoye sur le rseau. Par exemple, le format d'une trame sur un rseau Ethernet est le suivant :
. <---- En-tte trame Ethernet -----------------------> . <-Donnes trame Ethernet->.
+----------------------------------------------------------------------------------------------------+
Info Adresse Physique Adresse Physique longueur Paquet IP Ethernet
Source Destination paquet CRC
+----------------------------------------------------------------------------------------------------+
8 oct 6 6 2 46 1500 4
Dans la trame finale, il y a l'adresse physique des machines source et destination. Comment sont-elles obtenues ?
La machine expditrice connaissant l'adresse IP de la machine avec qui elle veut communiquer obtient l'adresse physique de celle-ci
en utilisant un protocole particulier appel ARP (Address Resolution Protocol).
. Elle envoie un paquet d'un type spcial appel paquet ARP contenant l'adresse IP de la machine dont on cherche l'adresse
physique. Elle a pris soin galement d'y placer sa propre adresse IP ainsi que son adresse physique.
. Ce paquet est envoy tous les noeuds du rseau.
. Ceux-ci reconnaissent la nature spciale du paquet. Le noeud qui reconnat son adresse IP dans le paquet, rpond en
envoyant l'expditeur du paquet son adresse physique. Comment le peut-il ? Il a trouv dans le paquet les adresses IP et
physique de l'expditeur.
. L'expditeur reoit donc l'adresse physique qu'il cherchait. Il la stocke en mmoire afin de pouvoir l'utiliser ultrieurement
si d'autres paquets sont envoyer au mme destinataire.
L'adresse IP d'une machine est normalement inscrite dans l'un de ses fichiers qu'elle peut donc consulter pour la connatre. Cette
adresse peut tre change : il suffit d'diter le fichier. L'adresse physique elle, est inscrite dans une mmoire de la carte rseau et ne
peut tre change.
Lorsqu'un administrateur dsire d'organiser son rseau diffremment, il peut tre amen changer les adresses IP de tous les
noeuds et donc diter les diffrents fichiers de configuration des diffrents noeuds. Cela peut tre fastidieux et une occasion
d'erreurs s'il y a beaucoup de machines. Une mthode consiste ne pas affecter d'adresse IP aux machines : on inscrit alors un
code spcial dans le fichier dans lequel la machine devrait trouver son adresse IP. Dcouvrant qu'elle n'a pas d'adresse IP, la
machine la demande selon un protocole appel RARP (Reverse Address Resolution Protocol). Elle envoie alors sur un rseau un paquet
spcial appel paquet RARP, analogue au paquet ARP prcdent, dans lequel elle met son adresse physique. Ce paquet est envoy
tous les noeuds qui reconnaissent alors un paquet RARP. L'un d'entre-eux, appel serveur RARP, possde un fichier donnant la
correspondance adresse physique <--> adresse IP de tous les noeuds. Il rpond alors l'expditeur du paquet RARP, en lui
renvoyant son adresse IP. Un administrateur dsirant reconfigurer son rseau, n'a donc qu' diter le fichier de correspondances du
serveur RARP. Celui-ci doit normalement avoir une adresse IP fixe qu'il doit pouvoir connatre sans avoir utiliser lui-mme le
protocole RARP.
Programmation TCP-IP 178
8.1.6 La couche rseau dite couche IP de l'internet
Le protocole IP (Internet Protocol) dfinit la forme que les paquets doivent prendre et la faon dont ils doivent tre grs lors de leur
mission ou de leur rception. Ce type de paquet particulier est appel un datagramme IP. Nous l'avons dj prsent :
L'important est qu'outre les donnes transmettre, le datagramme IP contient les adresses Internet des machines source et
destination. Ainsi la machine destinatrice sait qui lui envoie un message.
A la diffrence d'une trame de rseau qui a une longueur dtermine par les caractristiques physiques du rseau sur lequel elle
transite, la longueur du datagramme IP est elle fixe par le logiciel et sera donc la mme sur diffrents rseaux physiques. Nous
avons vu qu'en descendant de la couche rseau dans la couche physique le datagramme IP tait encapsul dans une trame physique.
Nous avons donn l'exemple de la trame physique d'un rseau Ethernet :
. <---- En-tte trame Ethernet -------------------------------->. <---Donnes trame Ethernet------>.
+----------------------------------------------------------------------------------------------------+
Info Adresse Physique Adresse Physique Type du Paquet IP Ethernet
Source Destination paquet CRC
+----------------------------------------------------------------------------------------------------+
Les trames physiques circulent de noeud en noeud vers leur destination qui peut ne pas tre sur le mme rseau physique que la
machine expditrice. Le paquet IP peut donc tre encapsul successivement dans des trames physiques diffrentes au niveau des
noeuds qui font la jonction entre deux rseaux de type diffrent. Il se peut aussi que le paquet IP soit trop grand pour tre
encapsul dans une trame physique. Le logiciel IP du noeud o se pose ce problme, dcompose alors le paquet IP en fragments
selon des rgles prcises, chacun d'eux tant ensuite envoy sur le rseau physique. Ils ne seront rassembls qu' leur ultime
destination.
8.1.6.1 Le routage
Le routage est la mthode d'acheminement des paquets IP leur destination. Il y a deux mthodes : le routage direct et le routage
indirect.
Routage direct
Le routage direct dsigne l'acheminement d'un paquet IP directement de l'expditeur au destinataire l'intrieur du mme rseau :
Routage indirect
Le routage indirect dsigne l'acheminement d'un paquet IP une destination se trouvant sur un autre rseau que celui auquel
appartient l'expditeur. Dans ce cas, les parties adresse rseau des adresses IP des machines source et destination sont diffrentes.
La machine source reconnat ce point. Elle envoie alors le paquet un noeud spcial appel routeur (router), noeud qui connecte un
rseau local aux autres rseaux et dont elle trouve l'adresse IP dans ses tables, adresse obtenue initialement soit dans un fichier soit
dans une mmoire permanente ou encore via des informations circulant sur le rseau.
Un routeur est attach deux rseaux et possde une adresse IP l'intrieur de ces deux rseaux.
+------------+
rseau 2 routeur rseau 1
----------------|193.49.144.6|------------
193.49.145.0 193.49.145.3 193.49.144.0
+------------+
Le routeur a pour rle de mettre le paquet IP qu'il reoit et qui est contenu dans une trame physique typique du rseau n 1, dans
une trame physique pouvant circuler sur le rseau n 2. Si l'adresse IP du destinataire du paquet est dans le rseau n 2, le routeur lui
enverra le paquet directement sinon il l'enverra un autre routeur, connectant le rseau n 2 un rseau n 3 et ainsi de suite.
Les paquets grs par le protocole UDP sont appels galement des datagrammes. Ils ont la forme suivante :
Ces datagrammes seront encapsuls dans des paquets IP, puis dans des trames physiques.
. Le processus qui souhaite mettre tablit tout d'abord une connexion avec le processus destinataire des informations qu'il
va mettre. Cette connexion se fait entre un port de la machine mettrice et un port de la machine rceptrice. Il y a entre
les deux ports un chemin virtuel qui est ainsi cr et qui sera rserv aux deux seuls processus ayant ralis la connexion.
. Tous les paquets mis par le processus source suivent ce chemin virtuel et arrivent dans l'ordre o ils
ont t mis ce qui n'tait pas garanti dans le protocole UDP puisque les paquets pouvaient suivre des
chemins diffrents.
. L'information mise a un aspect continu. Le processus metteur envoie des informations son rhythme. Celles-ci ne sont
pas ncessairement envoyes tout de suite : le protocole TCP attend d'en avoir assez pour les envoyer. Elles sont stockes
dans une structure appele segment TCP. Ce segment une fois rempli sera transmis la couche IP o il sera encapsul dans
un paquet IP.
. Chaque segment envoy par le protocole TCP est numrot. Le protocole TCP destinataire vrifie qu'il reoit bien les
segments en squence. Pour chaque segment correctement reu, il envoie un accus de rception l'expditeur.
. Lorsque ce dernier le reoit, il l'indique au processus metteur. Celui-ci peut donc savoir qu'un segment est arriv bon
port, ce qui n'tait pas possible avec le protocole UDP.
Programmation TCP-IP 180
. Si au bout d'un certain temps, le protocole TCP ayant mis un segment ne reoit pas d'accus de rception, il retransmet le
segment en question, garantissant ainsi la qualit du service d'acheminement de l'information.
. Le circuit virtuel tabli entre les deux processus qui communiquent est full-duplex : cela signifie que l'information peut
transiter dans les deux sens. Ainsi le processus destination peut envoyer des accuss de rception alors mme que le
processus source continue d'envoyer des informations. Cela permet par exemple au protocole TCP source d'envoyer
plusieurs segments sans attendre d'accus de rception. S'il ralise au bout d'un certain temps qu'il n'a pas reu l'accus de
rception d'un certain segment n n, il reprendra l'mission des segments ce point.
TELNET
Ce protocole permet un utilisateur d'une machine A du rseau de se connecter sur une machine B (appele souvent machine
hte). TELNET mule sur la machine A un terminal dit universel. L'utilisateur se comporte donc comme s'il disposait d'un
terminal connect la machine B. Telnet s'appuie sur le protocole TCP.
Cela oblige avoir un annuaire faisant la correspondance machine <--> adresse IP. Probablement que dans cet annuaire les
machines seraient dsignes par des noms symboliques tels que :
On voit bien qu'il serait plus agrable de dsigner une machine par un nom plutt que par son adresse IP. Se pose alors le
problme de l'unicit du nom : il y a des millions de machines interconnectes. On pourrait imaginer qu'un organisme
centralis attribue les noms. Ce serait sans doute assez lourd. Le contrle des noms a t en fait distribu dans des domaines.
Chaque domaine est gr par un organisme gnralement trs lger qui a toute libert quant au choix des noms de machines.
Ainsi les machines en France appartiennent au domaine fr, domaine gr par l'Inria de Paris. Pour continuer simplifier les
choses, on distribue encore le contrle : des domaines sont crs l'intrieur du domaine fr. Ainsi l'universit d'Angers
appartient au domaine univ-Angers. Le service grant ce domaine a toute libert pour nommer les machines du rseau de
l'Universit d'Angers. Pour l'instant ce domaine n'a pas t subdivis. Mais dans une grande universit comportant beaucoup
de machines en rseau, il pourrait l'tre.
La machine DPX2/320 de l'universit d'Angers a t nomme Lagaffe alors qu'un PC 486DX50 a t nomm liny. Comment
rfrencer ces machines de l'extrieur ? En prcisant la hirarchie des domaines auxquelles elles appartiennent. Ainsi le nom
complet de la machine Lagaffe sera :
Lagaffe.univ-Angers.fr
A l'intrieur des domaines, on peut utiliser des noms relatifs. Ainsi l'intrieur du domaine fr et en dehors du domaine univ-
Angers, la machine Lagaffe pourra tre rfrence par
Lagaffe.univ-Angers
Enfin, l'intrieur du domaine univ-Angers, elle pourra tre rfrence simplement par
Lagaffe
Une application peut donc rfrencer une machine par son nom. Au bout du compte, il faut quand mme obtenir l'adresse
Internet de cette machine. Comment cela est-il ralis ? Suposons que d'une machine A, on veuille communiquer avec une
machine B.
8.1.9 Conclusion
Nous avons prsent dans cette introduction quelques grandes lignes des protocoles Internet. Pour approfondir ce domaine, on
pourra lire l'excellent livre de Douglas Comer :
La plupart des mthodes offertes sont statiques. Regardons celles qui nous intressent :
GetHostByAddress (string rend une adresse IPHostEntry partir d'une adresse IP sous la forme "I1.I2.I3.I4". Lance une
address)
exception si la machine address ne peut tre trouve.
Programmation TCP-IP 182
GetHostByName(string name) rend une adresse IPHostEntry partir d'un nom de machine. Lance une exception si la
machine name ne peut tre trouve.
string GetHostName() rend le nom de la machine sur laquelle s'excute le programme qui joue cette instruction
IPAddress [] AddressList liste des adresses IP d'une machine. Si une adresse IP dsigne une et une seule machine physique,
une machine physique peut elle avoir plusieurs adresses IP. Ce sera le cas si elle a plusieurs cartes
rseau qui la connectent des rseaux diffrents.
string [] Aliases liste des alias d'une machine, pouvant tre dsigne par un nom principal et des alias
string HostName le nom de la machine si elle en a un
// Constructors
public IPAddress(long newAddress);
// Properties
public long Address { get; set; }
// Methods
public static System.Net.IPAddress Parse(string ipString);
public virtual string ToString();
} // end of System.Net.IPAddress
De faon interne, une adresse IP est code sous la forme d'un entier long dans la proprit :
Elle peut tre transforme en chane I1.I2.I3.I4 avec la mthode ToString(). Inversement, on peut obtenir un objet IPAddress partir
d'une chane I1.I2.I3.I4 avec la mthode statique IPAddress.Parse("I1.I2.I3.I4").
Considrons le programme suivant qui affiche le nom de la machine sur laquelle il s'excute puis de faon interactive donne les
correspondances adresse IP <--> nom Machine :
E:\data\serge\MSNET\c#\sockets\1>address1
Machine Locale=tahe
// espaces de noms
using System;
using System.Net;
using System.Text.RegularExpressions;
Machine A Machine B
Port PA Port PB
Rseau
Lorsque une application AppA d'une machine A veut communiquer avec une application AppB d'une machine B de l'Internet, elle
doit connatre plusieurs choses :
Le processus qui souhaite mettre tablit tout d'abord une connexion avec le processus destinataire des informations qu'il
va mettre. Cette connexion se fait entre un port de la machine mettrice et un port de la machine rceptrice. Il y a entre
les deux ports un chemin virtuel qui est ainsi cr et qui sera rserv aux deux seuls processus ayant ralis la connexion.
Tous les paquets mis par le processus source suivent ce chemin virtuel et arrivent dans l'ordre o ils ont t mis
L'information mise a un aspect continu. Le processus metteur envoie des informations son rythme. Celles-ci ne sont
pas ncessairement envoyes tout de suite : le protocole TCP attend d'en avoir assez pour les envoyer. Elles sont stockes
dans une structure appele segment TCP. Ce segment une fois rempli sera transmis la couche IP o il sera encapsul dans
un paquet IP.
Chaque segment envoy par le protocole TCP est numrot. Le protocole TCP destinataire vrifie qu'il reoit bien les
segments en squence. Pour chaque segment correctement reu, il envoie un accus de rception l'expditeur.
Lorsque ce dernier le reoit, il l'indique au processus metteur. Celui-ci peut donc savoir qu'un segment est arriv bon
port.
Si au bout d'un certain temps, le protocole TCP ayant mis un segment ne reoit pas d'accus de rception, il retransmet le
segment en question, garantissant ainsi la qualit du service d'acheminement de l'information.
Le circuit virtuel tabli entre les deux processus qui communiquent est full-duplex : cela signifie que l'information peut
transiter dans les deux sens. Ainsi le processus destination peut envoyer des accuss de rception alors mme que le
processus source continue d'envoyer des informations. Cela permet par exemple au protocole TCP source d'envoyer
Le programme serveur traite diffremment la demande de connexion initiale d'un client de ses demandes ultrieures visant obtenir
un service. Le programme n'assure pas le service lui-mme. S'il le faisait, pendant la dure du service il ne serait plus l'coute des
demandes de connexion et des clients ne seraient alors pas servis. Il procde donc autrement : ds qu'une demande de connexion
est reue sur le port d'coute puis accepte, le serveur cre une tche charge de rendre le service demand par le client. Ce service
est rendu sur un autre port de la machine serveur appel port de service. On peut ainsi servir plusieurs clients en mme temps.
// Properties
public LingerOption LingerState { get; set; }
public bool NoDelay { get; set; }
Programmation TCP-IP 186
public int ReceiveBufferSize { get; set; }
public int ReceiveTimeout { get; set; }
public int SendBufferSize { get; set; }
public int SendTimeout { get; set; }
// Methods
public void Close();
public void Connect(System.Net.IPAddress address, int port);
public void Connect(string hostname, int port);
public void Connect(System.Net.IPEndPoint remoteEP);
public virtual bool Equals(object obj);
public virtual int GetHashCode();
public System.Net.Sockets.NetworkStream GetStream();
public Type GetType();
public virtual string ToString();
} // end of System.Net.Sockets.TcpClient
Les constructeurs, mthodes et proprits qui nous intressent sont les suivants :
constructeur TcpClient(string cre une liaison tcp avec le serveur oprant sur le port indiqu (port) de la machine
hostname, int port)
indique (hostname). Par exemple new TcpClient("istia.univ-angers.fr",80) pour se connecter
au port 80 de la machine istia.univ-angers.fr
void Close() ferme la connexion au serveur Tcp
GetStream() obtient un flux de lecture et d'criture vers le serveur. C'est ce flux qui permet les
changes client-serveur.
// Properties
public bool CanRead { virtual get; }
public bool CanSeek { virtual get; }
public bool CanWrite { virtual get; }
public bool DataAvailable { virtual get; }
public long Length { virtual get; }
public long Position { virtual get; virtual set; }
// Methods
public virtual IAsyncResult BeginRead(byte[] buffer, int offset, int size, AsyncCallback callback,
object state);
public virtual IAsyncResult BeginWrite(byte[] buffer, int offset, int size, AsyncCallback callback,
object state);
public virtual void Close();
public virtual System.Runtime.Remoting.ObjRef CreateObjRef(Type requestedType);
public virtual int EndRead(IAsyncResult asyncResult);
public virtual void EndWrite(IAsyncResult asyncResult);
public virtual bool Equals(object obj);
public virtual void Flush();
public virtual int GetHashCode();
public virtual object GetLifetimeService();
public Type GetType();
public virtual object InitializeLifetimeService();
public virtual int Read(byte[] buffer, int offset, int size);
public virtual int ReadByte();
public virtual long Seek(long offset, System.IO.SeekOrigin origin);
public virtual void SetLength(long value);
public virtual string ToString();
public virtual void Write(byte[] buffer, int offset, int size);
public virtual void WriteByte(byte value);
} // end of System.Net.Sockets.NetworkStream
La classe NetworkStream est drive de la classe Stream. Beaucoup d'applications client-serveur changent des lignes de texte
termines par les caractres de fin de ligne "\r\n". Aussi il est intressant d'utiliser des objets StreamReader et StreamWriter pour lire
et crire ces lignes dans le flux rseau. Lorsque deux machines communiquent, il y a chaque bout de la liaison un objet TcpClient.
La mthode GetStream de cet objet permet d'avoir accs au flux rseau (NetworkStream) qui lie les deux machines. Ainsi si une
machine M1 a tabli une liaison avec une machine M2 l'aide d'un objet TcpClient client1 qu'elles changent des lignes de texte, elle
pourra crer ses flux de lecture et criture de la faon suivante :
Programmation TCP-IP 187
StreamReader in1=new StreamReader(client1.GetStream());
StreamWriter out1=new StreamWriter(client1.GetStream());
out1.AutoFlush=true;
L'instruction
out1.AutoFlush=true;
signifie que le flux d'criture de client1 ne transitera pas par un buffer intermdiaire mais ira directement sur le rseau. Ce point est
important. En gnral lorsque client1 envoie une ligne de texte son partenaire il en attend une rponse. Celle-ci ne viendra jamais si
la ligne a t en ralit bufferise sur la machine M1 et jamais envoye.
client1.WriteLine("un texte");
string rponse=client1.ReadLine();
TcpClient client=null
null;
null
try{
try
// on se connecte au service officiant sur le port P de la machine M
client=new
new TcpClient(M,P);
// on cre les flux d'entre-sortie du client TCP
StreamReader in=new
new StreamReader(client.GetStream());
StreamWriter out=new
new StreamWriter(client.getStream());
out.AutoFlush=true;
// boucle demande - rponse
bool fini=false
false;
false
String demande;
String rponse;
while (! fini){
// on prpare la demande
demande=
// on l'envoie
out.WriteLine(demande);
// on lit la rponse
rponse=in.ReadLine();
// on traite la rponse
}
// c'est fini
client.Close();
} catch(Exception
catch e){
// on gre l'exception
.
}
// Properties
public EndPoint LocalEndpoint { get; }
// Methods
public System.Net.Sockets.Socket AcceptSocket();
public System.Net.Sockets.TcpClient AcceptTcpClient();
public virtual bool Equals(object obj);
public virtual int GetHashCode();
public Type GetType();
public bool Pending();
public void Start();
public void Stop();
Les constructeurs, mthodes et proprits qui nous intressent sont les suivants :
constructeur TcpListener(int port) cre un service TCP qui va attendre (listen) les demandes des clients sur un port pass
en paramtre (port) appel port d'coute.
TcpClient AcceptTcpClient() accepte la demande d'un client. Rend comme rsultat un objet TcpClient associ un
autre port, appel port de service.
void Start() lance l'coute des demandes clients
void Stop() arrte d'couter les demandes clients
TcpListener serveur=null
null;
null
try{
try
// ouverture du service
int portEcoute=
serveur=new
new TcpListener(portEcoute);
serveur.Start();
// traitement des demandes de connexion
bool fini=false
false;
false
TcpClient client=null
null;
null
while(
while ! fini){
// attente et acceptation d'une demande
client=serveur.AcceptTcpClient();
// le service est rendu par une autre tche laquelle on passe la socket de service
new Thread(new ThreadStart(new Service(client).Run)).Start();
// on se remet en attente des demandes de connexion
}
// c'est fini - on arrte le service
serveur.Stop();
} catch (Exception e){
// on traite l'exception
}
// run
public void Run(){
StreamReader in=null; // flux d'entre de la liaison tcp
StreamWriter out=null; // flux de sortie de la liaison tcp
try{
// on cre les flux d'entre-sortie
in=new StreamReader(liaisonClient.getStream()));
out=new StreamWriter(liaisonClient.getStream());
8.4 Exemples
8.4.1 Serveur d'cho
Nous nous proposons d'crire un serveur d'cho qui sera lanc depuis une fentre DOS par la commande :
serveurEcho port
Le serveur officie sur le port pass en paramtre. Il se contente de renvoyer au client la demande que celui-ci lui a envoye. Le
programme est le suivant :
using System.Net.Sockets;
using System;
using System.IO;
using System.Threading;
public class serveurEcho{
public const string syntaxe="Syntaxe : serveurEcho port";
// programme principal
public static void Main (string[] args){
// y-a-t-il un argument
if(args.Length != 1)
erreur(syntaxe,1);
// cet argument doit tre entier >0
int port=0;
bool erreurPort=false;
Exception E=null;
try{
port=int.Parse(args[0]);
}catch(Exception e){
E=e;
erreurPort=true;
}
erreurPort=erreurPort || port <=0;
if(erreurPort)
erreur(syntaxe+"\n"+"Port incorrect ("+E+")",2);
// on cre le servive d'coute
TcpListener ecoute=null;
int nbClients=0; // nbre de clients traits
try{
// on cre le service
ecoute=new TcpListener(port);
// on le lance
ecoute.Start();
// suivi
Console.Out.WriteLine("Serveur d'cho lanc sur le port " + port);
Console.Out.WriteLine(ecoute.LocalEndpoint);
// boucle de service
TcpClient liaisonClient=null;
while (true){ // boucle infinie - sera arrte par Ctrl-C
// attente d'un client
liaisonClient=ecoute.AcceptTcpClient();
// le service est assur par une autre tche
nbClients++;
new Thread(new ThreadStart(new traiteClientEcho(liaisonClient,nbClients).Run)).Start();
// -------------------------------------------------------
// assure le service un client du serveur d'cho
Il se connecte la machine nomServeur sur le port port puis envoie au serveur des lignes de texte que celui-ci lui renvoie en cho.
// espaces de noms
using System;
using System.Net.Sockets;
using System.IO;
// nombre d'arguments
La structure de ce client est conforme l'architecture gnrale des clients tcp.Voici les rsultats obtenus dans la configuration
suivante :
le serveur est lanc sur le port 100 dans une fentre Dos
sur la mme machine deux clients sont lancs dans deux autres fentres Dos
E:\data\serge\MSNET\c#\sockets\serveurEcho>serveurEcho 100
Serveur d'cho lanc sur le port 100
0.0.0.0:100
Dbut de service au client 1
Client 1 : ligne1
Dbut de service au client 2
Client 2 : ligne2A
Client 2 : ligne2B
Client 1 : ligne1B
Client 1 : ligne1C
Client 2 : fin
Fin de service au client 2
Client 1 : fin
Fin de service au client 1
^C
Ce client TCP se connectera sur le port port du serveur serveur. Ceci fait, il crera deux threads :
1. un thread charg de lire des commandes tapes au clavier et de les envoyer au serveur
2. un thread charg de lire les rponses du serveur et de les afficher l'cran
Pourquoi deux threads alors que dans l'application prcdente ce besoin ne s'tait pas fait ressentir ? Dans cette dernire, le
protocole du dialogue tait connu : le client envoyait une seule ligne et le serveur rpondait par une seule ligne. Chaque service a
son protocole particulier et on trouve galement les situations suivantes :
le client doit envoyer plusieurs lignes de texte avant d'avoir une rponse
la rponse d'un serveur peut comporter plusieurs lignes de texte
Aussi la boucle envoi d'une unique ligne au seveur - rception d'une unique ligne envoye par le serveur ne convient-elle pas
toujours. On va donc crer deux boucles dissocies :
une boucle de lecture des commandes tapes au clavier pour tre envoyes au serveur. L'utilisateur signalera la fin des
commandes avec le mot cl fin.
une boucle de rception et d'affichage des rponses du serveur. Celle-ci sera une boucle infinie qui ne sera interrompue
que par la fermeture du flux rseau par le serveur ou par l'utilisateur au clavier qui tapera la commande fin.
Pour avoir ces deux boucles dissocies, il nous faut deux threads indpendants. Montrons un exemple d'exccution o notre client
tcp gnrique se connecte un service SMTP (SendMail Transfer Protocol). Ce service est responsable de l'acheminement du
courrier lectronique aux destinataires. Il fonctionne sur le port 25 et a un protocole de dialogue de type changes de lignes de
texte.
ligne1
ligne2
<-- 220 istia.univ-angers.fr ESMTP Sendmail 8.11.6/8.9.3; Mon, 13 May 2002 08:37:26 +0200
certains services ont une commande help donnant des indications sur les commandes utilisables avec le service. Ici ce n'est
pas le cas. Les commandes SMTP utilises dans l'exemple sont les suivantes :
o mail from: expditeur, pour indiquer l'adresse lectronique de l'expditeur du message
o rcpt to: destinataire, pour indiquer l'adresse lectronique du destinataire du message. S'il y a plusieurs destinataires,
on r-met autant de fois que ncessaire la commande rcpt to: pour chacun des destinataires.
o data qui signale au serveur SMTP qu'on va envoyer le message. Comme indiqu dans la rponse du serveur,
celui-ci est une suite de lignes termine par une ligne contenant le seul caractre point. Un message peut avoir
des enttes spars du corps du message par une ligne vide. Dans notre exemple, nous avons mis un sujet avec le
mot cl Subject:
une fois le message envoy, on peut indiquer au serveur qu'on a termin avec la commande quit. Le serveur ferme alors la
connexion rseau.Le thread de lecture peut dtecter cet vnement et s'arrter.
l'utilisateur tape alors fin au clavier pour arrter galement le thread de lecture des commandes tapes au clavier.
On remarquera que le service SMTP ne peut dtecter si un expditeur est valide ou non. Aussi ne peut-on jamais faire confiance au
champ from d'un message. Ici l'expditeur machin@univ-angers.fr n'existait pas.
Ce client tcp gnrique peut nous permettre de dcouvrir le protocole de dialogue de services internet et partir de l construire des
classes spcialises pour des clients de ces services. Dcouvrons le protocole de dialogue du service POP (Post Office Protocol) qui
permet de retrouver ses mls stocks sur un serveur. Il travaille sur le port 110.
user login, o on donne son login sur la machine qui dtient nos mls
pass password, o on donne le mot de passe associ au login prcdent
list, pour avoir la liste des messages sous la forme numro, taille en octets
retr i, pour lire le message n i
quit, pour arrter le dialogue.
Dcouvrons maintenant le protocole de dialogue entre un client et un serveur Web qui lui travaille habituellement sur le port 80 :
Ce n'est qu'aprs avoir reu la ligne vide que le serveur Web rpond. Dans l'exemple nous n'avons utilis qu'une commande :
qui demande au serveur l'URL /index.html et indique qu'il travaille avec le protocole HTTP version 1.0. La version la plus rcente
de ce protocole est 1.1. L'exemple montre que le serveur a rpondu en renvoyant le contenu du fichier index.html puis qu'il a ferm
la connexion puisqu'on voit le thread de lecture des rponses se terminer. Avant d'envoyer le contenu du fichier index.html, le
serveur web a envoy une srie d'enttes termine par une ligne vide :
La ligne <html> est la premire ligne du fichier /index.html. Ce qui prcde s'appelle des enttes HTTP (HyperText Transfer
Protocol). Nous n'allons pas dtailler ici ces enttes mais on se rappellera que notre client gnrique y donne accs, ce qui peut tre
utile pour les comprendre. La premire ligne par exemple :
indique que le serveur Web contact comprend le protocole HTTP/1.1 et qu'il a bien trouv le fichier demand (200 OK), 200
tant un code de rponse HTTP. Les lignes
disent au client qu'il va recevoir 11251 octets reprsentant du texte HTML (HyperText Markup Language) et qu' la fin de l'envoi,
la connexion sera ferme.
On a donc l un client tcp trs pratique. En fait, ce client existe dj sur les machines o il s'appelle telnet mais il tait intressant de
l'crire nous-mmes. Le programme du client tcp gnrique est le suivant :
// espaces de noms
using System;
using System.Net.Sockets;
using System.IO;
using System.Threading;
public class clientTcpGnrique{
// reoit en paramtre les caractristiques d'un service sous la forme
// serveur port
// se connecte au service
// cre un thread pour lire des commandes tapes au clavier
// celles-ci seront envoyes au serveur
// cre un thread pour lire les rponses du serveur
// celles-ci seront affiches l'cran
// le tout se termine avec la commande fin tape au clavier
public static void Main(string[] args){
// syntaxe
const string syntaxe="pg serveur port";
// nombre d'arguments
if(args.Length != 2)
erreur(syntaxe,1);
// on note le nom du serveur
string serveur=args[0];
// le port doit tre entier >0
int port=0;
bool erreurPort=false;
Exception E=null;
try{
port=int.Parse(args[1]);
}catch(Exception e){
E=e;
erreurPort=true;
}
erreurPort=erreurPort || port <=0;
if(erreurPort)
erreur(syntaxe+"\n"+"Port incorrect ("+E+")",2);
TcpClient client=null;
// il peut y avoir des problmes
try{
// on se connecte au service
client=new TcpClient(serveur,port);
}catch(Exception ex){
// erreur
Console.Error.WriteLine("Impossible de se connecter au service ("+ serveur
+","+port+"), erreur : "+ex.Message);
// fin
return;
Programmation TCP-IP 196
}//catch
// on cre les threads de lecture/criture
Thread thReceive=new Thread(new ThreadStart(new clientReceive(client).Run));
Thread thSend=new Thread(new ThreadStart(new clientSend(client).Run));
Le programme est lanc par : srvgen portEcoute, o portEcoute est le port sur lequel les clients doivent se connecter. Le service au
client sera assur par deux threads :
un thread se consacrant exclusivement la lecture des lignes de texte envoyes par le client
un thread se consacrant exclusivement la lecture des rponses tapes au clavier par l'utilisateur. Celui-ci signalera par la
commande fin qu'il clt la connexion avec le client.
Le serveur cre deux threads par client. S'il y a n clients, il y aura 2n threads actifs en mme temps. Le serveur lui ne s'arrte jamais
sauf par un Ctrl-C tap au clavier par l'utilisateur. Voyons quelques exemples.
Le serveur est lanc sur le port 100 et on utilise le client gnrique pour lui parler. La fentre du client est la suivante :
Les lignes commenant par <-- sont celles envoyes du serveur au client, les autres celles du client vers le serveur. La fentre du
serveur est la suivante :
Les lignes commenant par <-- sont celles envoyes du client au serveur. Les lignes N : sont les lignes envoyes du serveur au client
n N. Le serveur ci-dessus est encore actif alors que le client 1 est termin. On lance un second client pour le mme serveur :
Simulons maintenant un serveur web en lanant notre serveur gnrique sur le port 88 :
Prenons maintenant un navigateur et demandons l'URL http://localhost:88/exemple.html. Le navigateur va alors se connecter sur le
port 88 de la machine localhost puis demander la page /exemple.html :
On dcouvre ainsi les enttes HTTP envoys par le navigateur. Cela nous permet de dcouvrir peu peu le protocole HTTP. Lors
d'un prcdent exemple, nous avions cr un client Web qui n'envoyait que la seule commande GET. Cela avait t suffisant. On
voit ici que le navigateur envoie d'autres informations au serveur. Elles ont pour but d'indiquer au serveur quel type de client il a en
face de lui. On voit aussi que les enttes HTTP se terminent par une ligne vide.
Elaborons une rponse notre client. L'utilisateur au clavier est ici le vritable serveur et il peut laborer une rponse la main.
Rappelons-nous la rponse faite par un serveur Web dans un prcdent exemple :
...
<-- Host: localhost:88
<-- Connection: Keep-Alive
<--
2 : HTTP/1.1 200 OK
2 : Server: serveur tcp generique
2 : Connection: close
2 : Content-Type: text/html
2 :
2 : <html>
2 : <head><title>Serveur generique</title></head>
2 : <body>
2 : <center>
2 : <h2>Reponse du serveur generique</h2>
2 : </center>
2 : </body>
2 : </html>
2 : fin
L'erreur suivante s'est produite : Impossible de lire les donnes de la connexion de transport.
[fin du Thread de lecture des demandes du client 2]
[fin du Thread de lecture des rponses du serveur au client 2]
Les lignes commenant par 2 : sont envoyes du serveur au client n 2. La commande fin clt la connexion du serveur au client.
Nous nous sommes limits dans notre rponse aux enttes HTTP suivants :
HTTP/1.1 200 OK
2 : Server: serveur tcp generique
2 : Connection: close
2 : Content-Type: text/html
2 :
Nous ne donnons pas la taille du fichier que nous allons envoyer (Content-Length) mais nous contentons de dire que nous allons
fermer la connexion (Connection: close) aprs envoi de celui-ci. Cela est suffisant pour le navigateur. En voyant la connexion ferme, il
saura que la rponse du serveur est termine et affichera la page HTML qui lui a t envoye. Cette dernire est la suivante :
2 : <html>
2 : <head><title>Serveur generique</title></head>
2 : <body>
2 : <center>
2 : <h2>Reponse du serveur generique</h2>
2 : </center>
2 : </body>
2 : </html>
L'utilisateur ferme ensuite la connexion au client en tapant la commande fin. Le navigateur sait alors que la rponse du serveur est
termine et peut alors l'afficher :
Nous allons crire un client Web auquel on passerait en paramtre une URL et qui afficherait l'cran le texte envoy par le
serveur. Nous supposerons que celui-ci supporte le protocole HTTP 1.1. Des enttes prcdents, nous n'utiliserons que les suivants
:
Si ci-dessus, nous remplaons GET par HEAD, le serveur ne nous enverra que les enttes HTTP et pas la page HTML.
Notre client web sera appel de la faon suivante : clientweb URL cmd, o URL est l'URL dsire et cmd l'un des deux mots
cls GET ou HEAD pour indiquer si on souhaite seulement les enttes (HEAD) ou galement le contenu de la page (GET).
Regardons un premier exemple. Nous lanons le serveur IIS puis le client web sur la mme machine :
E:\data\serge\MSNET\c#\rseau\clientweb>
La rponse
signifie que la page demande a chang de place (donc d'URL). La nouvelle URL est donne par l'entte Location:
Location: /IISSamples/Default/welcome.htm
Nous obtenons le mme rsultat qu'avec HEAD avec de plus le corps de la page HTML. Le programme est le suivant :
// espaces de noms
using System;
using System.Net.Sockets;
using System.IO;
public class clientWeb{
// demande une URL
// affiche le contenu de celle-ci l'cran
La seule nouveaut dans ce programme est l'utilisation de la classe Uri. Le programme reoit une URL (Uniform Resource Locator) ou
URI (Uniform Resource Identifier) de la forme http://serveur:port/cheminPageHTML?param1=val1;param2=val2;.... La classe Uri nous
permet de dcomposer la chane de l'URL en ses diffrents lments. Un objet Uri est construit partir de la chane URIstring
reue en paramtre :
Uri uri=null;
try{
uri=new Uri(URIstring);
}catch (Exception ex){
// URI incorrecte
erreur("L'erreur suivante s'est produite : " + ex.Message,2);
}//catch
Si la chane URI reue en paramtre n'est pas une URI valide (absence du protocole, du serveur, ...), une exception est lance. Cela
nous permet de vrifier la validit du paramtre reu. Une fois l'objet Uri construit, on a accs aux diffrents lments de cette Uri.
Ainsi si l'objet uri du code prcdent a t construit partir de la chane
http://serveur:port/cheminPageHTML?param1=val1;param2=val2;... on aura :
1. il lit la premire ligne des enttes HTTP envoys par le serveur pour vrifier si on y trouve la chane 302 Object moved qui
signale une redirection
2. il lit les enttes suivants. S'il y a redirection, il recherche la ligne Location: url qui donne la nouvelle URL de la page
demande et note cette URL.
3. il affiche le reste de la rponse du serveur. S'il y a redirection, les tapes 1 3 sont rptes avec la nouvelle URL. Le
programme n'accepte pas plus d'une redirection. Cette limite fait l'objet d'une constante qui peut tre modifie.
Voici un exemple :
HTTP/1.1 200 OK
Server: Microsoft-IIS/5.0
Connection: close
Date: Mon, 13 May 2002 11:38:55 GMT
Content-Type: text/html
Accept-Ranges: bytes
Last-Modified: Mon, 16 Feb 1998 21:16:22 GMT
ETag: "0174e21203bbd1:978"
Content-Length: 4781
<html>
<head>
<title>Bienvenue dans le Serveur Web personnel</title>
</head>
....
</body>
Programmation TCP-IP 203
</html>
// espaces de noms
using System;
using System.Net.Sockets;
using System.IO;
using System.Text.RegularExpressions;
public class clientWeb{
// demande une URL
// affiche le contenu de celle-ci l'cran
public static void Main(string[] args){
// syntaxe
const string syntaxe="pg URI GET/HEAD";
// nombre d'arguments
if(args.Length != 2)
erreur(syntaxe,1);
Une classe impt a t cre. Ses attributs sont trois tableaux de nombres :
// constructeur 1
public impt(decimal[] LIMITES, decimal[] COEFFR, decimal[] COEFFN){
// initialise les trois tableaux limites, coeffR, coeffN partir
// des paramtres passs au constructeur
// constructeur 2
public impt(string DSNimpots, string Timpots, string colLimites, string colCoeffR, string colCoeffN){
// initialise les trois tableaux limites, coeffR, coeffN partir
// du contenu de la table Timpots de la base ODBC DSNimpots
// colLimites, colCoeffR, colCoeffN sont les trois colonnes de cette table
// peut lancer une exception
Ici le programme de test et l'objet impt taient sur la mme machine. Nous nous proposons de mettre le programme de test et
l'objet impt sur des machines diffrentes. Nous aurons une application client-serveur o l'objet impt distant sera le serveur. La
nouvelle classe s'appelle ServeurImpots et est drive de la classe impt :
using System.Net.Sockets;
using System;
using System.IO;
using System.Threading;
using System.Text.RegularExpressions;
// constructeur
public ServeurImpots(int portEcoute,string DSNimpots, string Timpots, string colLimites, string
colCoeffR, string colCoeffN)
: base(DSNimpots, Timpots, colLimites, colCoeffR, colCoeffN) {
// on note le port d'coute
this.portEcoute=portEcoute;
// pour l'instant inactif
actif=false;
// cre et lance un thread de lecture des commandes tapes au clavier
// le serveur sera gr partir de ces commandes
new Thread(new ThreadStart(admin)).Start();
}//ServeurImpots
Le seul paramtre nouveau dans le constructeur est le port d'coute des demandes des clients. Les autres paramtres sont passs
directement la classe de base impt. Le serveur d'impts est contrl par des commandes tapes au clavier. Aussi cre-t-on un
thread pour lire ces commandes. Il y en aura deux possibles : start pour lancer le service, stop pour l'arrter dfinitivement. La
mthode admin qui gre ces commandes est la suivante :
Si la commande tape au clavier est start, un thread d'coute des demandes clients est lanc. Si la commande tape est stop, tous les
threads sont arrts. Le thread d'coute excute la mthode ecoute :
On retrouve un serveur tcp classique coutant sur le port portEcoute. Les demandes des clients sont traites par la mthode Run d'un
objet auquel on passe deux paramtres :
1. l'objet TcpClient qui va permettre d'atteindre le client
2. l'objet impt this qui va donner accs la mthode this.calculer de calcul de l'impt.
// -------------------------------------------------------
// assure le service un client du serveur d'impts
public class traiteClientImpots{
private TcpClient liaisonClient; // liaison avec le client
private StreamReader IN; // flux d'entre
private StreamWriter OUT; // flux de sortie
private impt objImpt; // objet Impt
// constructeur
public traiteClientImpots(TcpClient liaisonClient,impt objImpt){
this.liaisonClient=liaisonClient;
this.objImpt=objImpt;
}//constructeur
La mthode Run traite les demandes des clients. Celles-ci peuvent avoir deux formes :
1. calcul mari(o/n) nbEnfants salaireAnnuel
2. fincalculs
// mthode Run
public void Run(){
// rend le service au client
try{
// flux d'entre
IN=new StreamReader(liaisonClient.GetStream());
// flux de sortie
OUT=new StreamWriter(liaisonClient.GetStream());
OUT.AutoFlush=true;
// envoi d'un msg de bienvenue au client
OUT.WriteLine("Bienvenue sur le serveur d'impts");
// boucle lecture demande/criture rponse
string demande=null;
string[] champs=null; // les lments de la demande
string commande=null; // la commande du client : calcul ou fincalculs
while ((demande=IN.ReadLine())!=null){
// on dcompose la demande en champs
champs=Regex.Split(demande.Trim().ToLower(),@"\s+");
// deux demandes acceptes : calcul et fincalculs
commande=champs[0];
if(commande!="calcul" && commande!="fincalculs"){
// erreur client
OUT.WriteLine("Commande incorrecte. Utilisez (calcul,fincalculs).");
// commande suivante
continue;
Programmation TCP-IP 207
}//if
if(commande=="calcul") calculerImpt(champs);
if(commande=="fincalculs"){
// msg d'au-revoir au client
OUT.WriteLine("Au revoir...");
// libration des ressources
try{ OUT.Close();IN.Close();liaisonClient.Close();}
catch{}
// fin
return;
}//if
//demande suivante
}//while
}catch (Exception e){
erreur("L'erreur suivante s'est produite ("+e+")",2);
}// fin try
}// fin Run
Le calcul de l'impt est effectu par la mthode calculerImpt qui reoit en paramtre le tableau des champs de la demande faite par le
client. La validit de la demande est vrifie et ventuellement l'impt calcul et renvoy au client.
// calcul d'impts
public void calculerImpt(string[] champs){
// traite la demande : calcul mari nbEnfants salaireAnnuel
// dcompose en champs dans le tableau champs
string mari=null;
int nbEnfants=0;
int salaireAnnuel=0;
// validit des arguments
try{
// il faut au moins 4 champs
if(champs.Length!=4) throw new Exception();
// mari
mari=champs[1];
if (mari!="o" && mari !="n") throw new Exception();
// enfants
nbEnfants=int.Parse(champs[2]);
// salaire
salaireAnnuel=int.Parse(champs[3]);
}catch{
// erreur de format
OUT.WriteLine(" syntaxe : calcul mari(O/N) nbEnfants salaireAnnuel");
// fini
return;
}//if
// on peut calculer l'impt
long impot=objImpt.calculer(mari=="o",nbEnfants,salaireAnnuel);
// on envoie la rponse au client
OUT.WriteLine(""+impot);
}//calculer
o impots.dll contient le code de la classe impt. Un programme de test pourrait tre le suivant :
On passe au programme de test les donnes ncessaires la construction d'un objet ServeurImpots et partir de l il cre cet objet. Ce
programme de test est compil par :
E:\data\serge\MSNET\c#\impots\serveur>
La ligne
cre un objet ServeurImpots qui n'coute pas encore les demandes des clients. C'est la commande start tape au clavier qui lance cette
coute. La commande stop arrte le serveur. Utilisons maintenant un client. Nous utiliserons le client gnrique cr
prcdemment. Le serveur est lanc :
On voit que le client a bien rcupr le message de bienvenue du serveur. On envoie d'autres commandes :
x
<-- Commande incorrecte. Utilisez (calcul,fincalculs).
calcul
<-- syntaxe : calcul mari(O/N) nbEnfants salaireAnnuel
calcul o 2 200000
<-- 22506
calcul n 2 200000
<-- 33388
fincalculs
<-- Au revoir...
[fin du thread de lecture des rponses du serveur]
fin
[fin du thread d'envoi des commandes au serveur]
Elles sont hberges par des serveurs web et le protocole d'changes client-serveur est donc HTTP (HyperText Transport
Protocol), un protocole au-dessus de TCP-IP.
Le service Web a un protocole de dialogue standard quelque soit le service assur. Un service Web offre divers services S1,
S2, .., Sn. Chacun d'eux attend des paramtres fournis par le client et rend celui-ci un rsultat. Pour chaque service, le
client a besoin de savoir :
o le nom exact du service Si
o la liste des paramtres qu'il faut lui fournir et leur type
o le type de rsultat retourn par le service
Une fois, ces lments connus, le dialogue client-serveur suit le mme format quelque soit le service web
interrog. L'criture des clients est ainsi normalise.
Pour des raisons de scurit vis vis des attaques venant de l'internet, beaucoup d'organisations ont des rseaux privs et
n'ouvrent sur Internet que certains ports de leurs serveurs : essentiellement le port 80 du service web. Tous les autres ports
sont verrouills. Aussi les applications client-serveur telles que prsentes dans le chapitre prcdent sont-elles construites
au sein du rseau priv (intranet) et ne sont en gnral pas accessibles de l'extrieur. Loger un service au sein d'un serveur
web le rend accessible toute la communaut internet.
Le service Web peut tre modlis comme un objet distant. Les services offerts deviennent alors des mthodes de cet
objet. Un client peut avoir accs cet objet distant comme s'il tait local. Cela cache toute la partie communication rseau
et permet de construire un client indpendant de cette couche. Si celle-ci vient changer, le client n'a pas tre modifi.
C'est l un norme avantage et probablement le principal atout des services Web.
Comme pour les applications client-serveur tcp-ip prsentes dans le chapitre prcdent, le client et le serveur peuvent tre
crits dans un langage quelconque. Ils changent des lignes de texte. Celles-ci comportent deux parties :
o les enttes ncessaires au protocole HTTP
o le corps du message. Pour une rponse du serveur au client, celui-ci est au format XML (eXtensible Markup
Language). Pour une demande du client au serveur, le corps du message peut avoir plusieurs formes dont XML.
La demande XML du client peut avoir un format particulier appel SOAP (Simple Object Access Protocol).
Dans ce cas, la rponse du serveur suit aussi le format SOAP.
[WebService(Namespace="st.istia.univ-angers.fr")]
public class operations : WebService{
[WebMethod]
public double ajouter(double a, double b){
return a+b;
}//ajouter
Conclusion 210
[WebMethod]
public double soustraire(double a, double b){
return a-b;
}//soustraire
[WebMethod]
public double multiplier(double a, double b){
return a*b;
}//multiplier
[WebMethod]
public double diviser(double a, double b){
return a/b;
}//diviser
[WebMethod]
public double[] toutfaire(double a, double b){
return new double[] {a+b,a-b,a*b,a/b};
}//toutfaire
}//classe
Ce code n'est pas destin tre compil directement par le compilateur C#. Ce qui explique la prsence d'une directive que ne peut
comprendre C# :
Le code-source ci-dessus est en fait destin au serveur Web IIS et non au compilateur C#. La directive indique que le code qui suit :
est un service Web
crit en C#
que la classe l'implmentant s'appelle operations
La classe operations ressemble une classe C# avec cependant quelques points noter :
les mthodes sont prcdes d'un attribut [WebMethod] qui indique au compilateur les mthodes qui doivent tre
"publies" c.a.d. rendues disponibles au client. Une mthode non prcde de cet attribut serait invisible aux clients
distants. Ce pourrait tre une mthode interne utilise par d'autres mthodes mais pas destine tre publie.
la classe drive de la classe WebService dfinie dans l'espace de noms System.Web.Services. Cet hritage n'est pas toujours
obligatoire. Dans cet exemple notamment on pourrait s'en passer.
la classe elle-mme est prcde d'un attribut [WebService(Namespace="st.istia.univ-angers.fr")] destin donner
un espace de noms au service web. Un vendeur de classes donne un espace de noms ses classes afin de leur donner un
nom unique et viter ainsi des conflits avec des classes d'autres vendeurs qui pourraient porter le mme nom. Pour les
services Web, c'est pareil. Chaque service web doit pouvoir tre identifi par un nom unique, ici par st.istia.univ-
angers.fr.
nous n'avons pas dfini de constructeur. Il est possible d'en dfinir mais la documentation consulte ne dit pas comment
utiliser un tel constructeur.
Le code source prcdent n'est pas destin directement au compilateur C# mais au serveur Web IIS. Il doit porter le suffixe .asmx
et sauvegard dans l'arborescence du serveur Web. Ici nous le sauvegardons sous le nom operations.asmx dans le dossier
c:\inetpub\wwwroot\st\operations :
E:\data\serge\MSNET\c#\webservices\clientSOAP>dir c:\inetpub\wwwroot\st\operations
14/05/2002 17:14 549 operations.asmx
On rappelle que c:\inetpub\wwwroot est la racine des documents web dlivrs par le serveur IIS. Demandons le document prcdent
avec un navigateur. L'URl demander est http://localhost/st/operations/operations.asmx.
Conclusion 211
Nous obtenons un document Web avec un lien pour chacune des mthodes dfinies dans le service web operations. Suivons le lien
ajouter :
La page obtenue nous propose de tester la mthode ajouter en lui fournissant les deux arguments a et b dont elle a besoin. Rappelons
la dfinition de la mthode ajouter :
[WebMethod]
public double ajouter(double a, double b){
return a+b;
}//ajouter
On notera que la page a repris les noms des arguments a et b utiliss dans la dfinition de la mthode. On utilise le bouton Appeler
et on obtient la rponse suivante dans une fentre spare du navigateur :
Conclusion 212
Si ci-dessus, on fait View/Source on obtient le code suivant :
On peut remarquer que le navigateur (ici IE) n'a pas reu du code HTML mais du code XML. Par ailleurs on voit que la rponse a
t demande l'URL : http://localhost/st/operations/operations.asmx/ajouter?a=15&b=30. Si nous modifions directement les valeurs
de a et b dans l'URL pour qu'elle devienne http://localhost/st/operations/operations.asmx/ajouter?a=-15&b=17, nous obtenons le
rsultat suivant :
Nous commenons discerner une mthode pour avoir accs une fonction F d'un service web S : on demande l'URL
http://urlServiceWeb/fonction?param1=val1¶m2=val2.... Essayons dans l'URL ci-dessus de remplacer ajouter par soustraire qui est
l'une des fonctions dfinies dans le service Web operations. Nous obtenons le rsultat suivant :
Conclusion 213
Dans tous les cas, la rponse du serveur a la forme :
Nous savons maintenant comment interroger un service web et obtenir sa rponse. En fait il existe plusieurs mthodes pour faire
cela. Revenons l'URL du service :
Conclusion 214
Dans page ci-dessus, sont exposes (mais non reprsentes dans la copie d'cran ci-dessus) trois mthodes pour interroger la
fonction ajouter du service web :
Conclusion 215
Ces trois mthodes d'accs aux fonctions d'un service web sont appeles respectivement : HTTP-GET, HTTP-POST et SOAP.
Nous les examinons maintenant l'une aprs l'autre.
Le client HTTP doit mettre au minimum les deux commandes HTTP suivantes :
o [a] et [b] doivent tre remplaces par les valeurs de a et b. Le serveur web enverra la rponse suivante :
HTTP/1.1 200 OK
Content-Type: text/xml; charset=utf-8
Content-Length: [longueur]
o [longueur] est le nombre de caractres envoys par le serveur aprs la ligne vide qui suit les enttes HTTP et [rsultat] est le
rsultat de la fonction ajouter. Vrifions cela avec notre client gnrique dfini dans le chapitre prcdent :
E:\data\serge\MSNET\c#\webservices\clientGET>cltgen localhost 80
Conclusion 216
Commandes :
GET http://localhost/st/operations/operations.asmx/ajouter?a=10&b=20 HTTP/1.1
Connection: close
Host: localhost:80
le client s'est connect au port 80 de la machine localhost c'est dire au serveur Web IIS.
il a envoy les enttes HTTP ncessaires pour demander d'ajouter 10 20. On a rajout l'entte Connection: close pour
demander au serveur de fermer la connexion aprs avoir envoy la rponse. Cela est ncessaire ici. Si on ne le dit pas, par
dfaut le serveur va garder la connexion ouverte. Or sa rponse est une suite de lignes de texte dont la dernire n'est pas
termine par une marque de fin de ligne. Or notre client TCP gnrique lit des lignes de texte termines par la marque de
fin de ligne avec la mthode ReadLine. Si le serveur ne ferme pas la connexion aprs envoi de la dernire ligne, le client est
bloqu parce qu'il attend une marque de fin de ligne qui n'existe pas. Si le serveur ferme la connexion, la mthode ReadLine
du client se termine et le client ne reste pas bloqu.
le serveur a envoy davantage d'enttes qu'attendus mais le format de la rponse XML est bien celui qui tait prvu.
E:\data\serge\MSNET\c#\webservices\clientGET>clientget.exe http://localhost/st/operations/operations.asmx
Tapez vos commandes au format : [ajouter|soustraire|multiplier|diviser] a b
ajouter 3 4
--> GET /st/operations/operations.asmx/ajouter?a=3&b=4 HTTP/1.1
--> Host: localhost:80
--> Connection: Keep-Alive
-->
<-- HTTP/1.1 200 OK
<-- Server: Microsoft-IIS/5.0
<-- Date: Wed, 15 May 2002 13:18:24 GMT
<-- Cache-Control: private, max-age=0
<-- Content-Type: text/xml; charset=utf-8
<-- Content-Length: 90
<--
<-- <?xml version="1.0" encoding="utf-8"?>
<-- <double xmlns="st.istia.univ-angers.fr">7</double>
[rsultat=7]
soustraire 10 15
--> GET /st/operations/operations.asmx/soustraire?a=10&b=15 HTTP/1.1
--> Host: localhost:80
--> Connection: Keep-Alive
-->
<-- HTTP/1.1 200 OK
<-- Server: Microsoft-IIS/5.0
<-- Date: Wed, 15 May 2002 13:18:30 GMT
<-- Cache-Control: private, max-age=0
<-- Content-Type: text/xml; charset=utf-8
<-- Content-Length: 91
<--
<-- <?xml version="1.0" encoding="utf-8"?>
<-- <double xmlns="st.istia.univ-angers.fr">-5</double>
[rsultat=-5]
diviser 8 4
--> GET /st/operations/operations.asmx/diviser?a=8&b=4 HTTP/1.1
--> Host: localhost:80
--> Connection: Keep-Alive
-->
<-- HTTP/1.1 200 OK
<-- Server: Microsoft-IIS/5.0
<-- Date: Wed, 15 May 2002 13:18:38 GMT
<-- Cache-Control: private, max-age=0
Conclusion 217
<-- Content-Type: text/xml; charset=utf-8
<-- Content-Length: 90
<--
<-- <?xml version="1.0" encoding="utf-8"?>
<-- <double xmlns="st.istia.univ-angers.fr">2</double>
[rsultat=2]
multiplier 10 0,2
--> GET /st/operations/operations.asmx/multiplier?a=10&b=0,2 HTTP/1.1
--> Host: localhost:80
--> Connection: Keep-Alive
-->
<-- HTTP/1.1 200 OK
<-- Server: Microsoft-IIS/5.0
<-- Date: Wed, 15 May 2002 13:18:46 GMT
<-- Cache-Control: private, max-age=0
<-- Content-Type: text/xml; charset=utf-8
<-- Content-Length: 90
<--
<-- <?xml version="1.0" encoding="utf-8"?>
<-- <double xmlns="st.istia.univ-angers.fr">2</double>
[rsultat=2]
fin
E:\data\serge\MSNET\c#\webservices\clientGET>clientget.exe http://localhost/st/operations/operations.asmx
Ensuite, le client lit les commandes tapes au clavier et les excute. Celles-ci sont au format :
fonction a b
o fonction est la fonction du service web appele (ajouter, soustraire, multiplier, diviser) et a et b les valeurs sur lesquelles va
oprer cette fonction. Par exemple :
ajouter 3 4
A partir de l, le client va faire la requte HTTP ncessaire au serveur Web et obtenir une rponse. Les changes client-serveur sont
dupliqus l'cran pour une meilleure comprhension du processus :
On retrouve ci-dessus l'change dj rencontr avec le client tcp gnrique une diffrence prs : l'entte HTTP Connection:
Keep-Alive demande au serveur de ne pas fermer la connexion. Celle-ci reste donc ouverte pour l'opration suivante du client qui
n'a donc pas besoin de se reconnecter de nouveau au serveur. Cela l'oblige cependant utiliser une autre mthode que ReadLine()
pour lire la rponse du serveur puisqu'on sait que celle-ci est une suite de lignes dont la dernire n'est pas termine par une marque
de fin de ligne. Une fois toute la rponse du serveur obtenue, le client l'analyse pour y trouver le rsultat de l'opration demande et
l'afficher :
[rsultat=7]
// espaces de noms
using System;
using System.Net.Sockets;
using System.IO;
using System.Text.RegularExpressions;
using System.Collections;
public class clientGet{
Conclusion 218
// syntaxe
const string syntaxe="pg URI";
string[] fonctions={"ajouter","soustraire","multiplier","diviser"};
// nombre d'arguments
if(args.Length != 1)
erreur(syntaxe,1);
// on note l'URI demande
string URIstring=args[0];
// on se connecte au serveur
Uri uri=null; // l'URI du service web
TcpClient client=null; // la liaison tcp du client avec le serveur
StreamReader IN=null; // le flux de lecture du client
StreamWriter OUT=null; // le flux d'criture du client
try{
// connexion au serveur
uri=new Uri(URIstring);
client=new TcpClient(uri.Host,uri.Port);
// on cre les flux d'entre-sortie du client TCP
IN=new StreamReader(client.GetStream());
OUT=new StreamWriter(client.GetStream());
OUT.AutoFlush=true;
}catch (Exception ex){
// URI incorrecte ou autre problme
erreur("L'erreur suivante s'est produite : " + ex.Message,2);
}//catch
// cration d'un dictionnaire des fonctions du service web
Hashtable dicoFonctions=new Hashtable();
for (int i=0;i<fonctions.Length;i++){
dicoFonctions.Add(fonctions[i],true);
}//for
// les demandes de l'utilisateur sont tapes au clavier
// sous la forme fonction a b
// elles se terminent avec la commande fin
string commande=null; // commande tape au clavier
string[] champs=null; // champs d'une ligne de commande
string fonction=null; // nom d'une fonction du service web
string a,b; // les arguments des fonctions du service web
// invite l'utilisateur
Console.Out.WriteLine("Tapez vos commandes au format : [ajouter|soustraire|multiplier|diviser] a b");
// gestion des erreurs
try{
// boucle de saisie des commandes tapes au clavier
while(true){
// lecture commande
commande=Console.In.ReadLine().Trim().ToLower();
// fini ?
if(commande==null || commande=="fin") break;
// dcomposition de la commande en champs
champs=Regex.Split(commande,@"\s+");
try{
// il faut trois champs
if(champs.Length!=3)throw new Exception();
// le champ 0 doit tre une fonction reconnue
fonction=champs[0];
if(! dicoFonctions.ContainsKey(fonction)) throw new Exception();
// le champ 1 doit tre un nombre valide
a=champs[1];
double.Parse(a);
// le champ 2 doit tre un nombre valide
b=champs[2];
double.Parse(b);
}catch {
// commande invalide
Console.Out.WriteLine("syntaxe : [ajouter|soustraire|multiplier|diviser] a b");
// on recommence
continue;
}//catch
// on fait la demande au service web
executeFonction(IN,OUT,uri,fonction,a,b);
// demande suivante
}//while
// fin des demandes
}catch(Exception e){
Console.Out.WriteLine("L'erreur suivante s'est produite : " + e.Message);
}//catch
// fin liaison client-serveur
try{
IN.Close();OUT.Close();client.Close();
}catch{}
}//Main
Conclusion 219
....
// affichage des erreurs
public static void erreur(string msg, int exitCode){
// affichage erreur
System.Console.Error.WriteLine(msg);
// arrt avec erreur
Environment.Exit(exitCode);
}//erreur
}//classe
On a l des choses dj rencontres plusieurs fois et qui ne ncessitent pas de commentaires particuliers. Examinons maintenant le
code de la mthode executeFonction o rsident les nouveauts :
// executeFonction
public static void executeFonction(StreamReader IN, StreamWriter OUT, Uri uri, string fonction, string
a, string b){
// excute fonction(a,b) sur le service web d'URI uri
// les changes client-serveur se font via les flux IN et OUT
// le rsultat de la fonction est dans la ligne
// <double xmlns="st.istia.univ-angers.fr">double</double>
// envoye par le serveur
Conclusion 220
Le client commence par envoyer les enttes HTTP de sa demande au serveur Web :
Le serveur ayant reu cette demande calcule sa rponse et l'envoie. Celle-ci est compose de deux parties :
1. des enttes HTTP termins par une ligne vide
2. la rponse au format XML
Dans un premier temps, le client lit les enttes HTTP pour y trouver la ligne Content-Length et rcuprer la taille de la rponse XML
(ici 90). Celle-ci est rcupre au moyen d'une expression rgulire. On aurait pu faire autrement et sans doute de faon plus
efficace.
Une fois qu'on a la longueur N de la rponse XML, on n'a plus qu' lire N caractres dans le flux IN de la rponse du serveur. Cette
chane de N caractres est redcompose en lignes de texte pour les besoins du suivi cran. Parmi ces lignes on cherche la ligne du
rsultat :
au moyen l encore d'une expression rgulire. Une fois le rsultat trouv, il est affich.
[rsultat=7]
On voit que la demande du client change de forme mais que la rponse du client reste la mme. Utilisons de nouveau notre client
tcp gnrique pour vrifier tout cela :
E:\data\serge\MSNET\c#\webservices\clientPOST>cltgen localhost 80
Commandes :
POST /st/operations/operations.asmx/ajouter HTTP/1.1
Host: localhost
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 7
Nous avons ajout l'entte Connection: close pour des raisons dj expliques prcdemment. On peut constater que la rponse du
serveur IIS n'a pas le format attendu. Aussitt aprs avoir reu la ligne vide signalant la fin des enttes HTTP, il envoie une
premire rponse :
Cette rponse forme uniquement d'enttes HTTP indique au client qu'il peut envoyer les 7 caractres qu'il a dit vouloir envoyer.
Ce que nous faisons :
a=2&b=3
Il faut voir ici que notre client tcp envoie plus de 7 caractres puisqu'il les envoie avec une marque de fin de ligne (WriteLine). Ca ne
gne pas le serveur qui des caractres reus ne prendra que les 7 premiers et parce qu'ensuite la connexion est ferme (Connection:
close). Ces caractres en trop auraient t gnants si la connexion tait reste ouverte car alors ils auraient t pris comme venant de
la commande suivante du client. Une fois les paramtres reus, le serveur envoie sa rponse, identique cette fois celle qu'il faisait
au client HTTP-GET :
E:\data\serge\MSNET\c#\webservices\clientPOST>clientpost1 http://localhost/st/operations/operations.asmx
Tapez vos commandes au format : [ajouter|soustraire|multiplier|diviser] a b
ajouter 6 7
--> POST /st/operations/operations.asmx/ajouter HTTP/1.1
--> Host: localhost:80
--> Content-Type: application/x-www-form-urlencoded
--> Content-Length: 7
--> Connection: Keep-Alive
-->
<-- HTTP/1.1 100 Continue
<-- Server: Microsoft-IIS/5.0
<-- Date: Wed, 15 May 2002 14:11:47 GMT
<--
--> a=6&b=7
<-- HTTP/1.1 200 OK
<-- Server: Microsoft-IIS/5.0
<-- Date: Wed, 15 May 2002 14:11:47 GMT
<-- Cache-Control: private, max-age=0
<-- Content-Type: text/xml; charset=utf-8
<-- Content-Length: 91
<--
<-- <?xml version="1.0" encoding="utf-8"?>
<-- <double xmlns="st.istia.univ-angers.fr">13</double>
[rsultat=13]
soustraire 8 9
--> POST /st/operations/operations.asmx/soustraire HTTP/1.1
--> Host: localhost:80
--> Content-Type: application/x-www-form-urlencoded
--> Content-Length: 7
--> Connection: Keep-Alive
-->
<-- HTTP/1.1 100 Continue
<-- Server: Microsoft-IIS/5.0
<-- Date: Wed, 15 May 2002 14:11:58 GMT
<--
--> a=8&b=9
<-- HTTP/1.1 200 OK
<-- Server: Microsoft-IIS/5.0
Conclusion 223
<-- Date: Wed, 15 May 2002 14:11:58 GMT
<-- Cache-Control: private, max-age=0
<-- Content-Type: text/xml; charset=utf-8
<-- Content-Length: 91
<--
<-- <?xml version="1.0" encoding="utf-8"?>
<-- <double xmlns="st.istia.univ-angers.fr">-1</double>
[rsultat=-1]
fin
E:\data\serge\MSNET\c#\webservices\clientPOST>
La premire partie du client HTTP-POST est identique celle correspondante du cient HTTP-GET. Seul change le code de la
fonction executeFonction :
// executeFonction
public static void executeFonction(StreamReader IN, StreamWriter OUT, Uri uri, string fonction, string
a, string b){
// excute fonction(a,b) sur le service web d'URI uri
// les changes client-serveur se font via les flux IN et OUT
// le rsultat de la fonction est dans la ligne
// <double xmlns="st.istia.univ-angers.fr">double</double>
// envoye par le serveur
// construction de la chane de requte
string requte="a="+HttpUtility.UrlEncode(a)+"&b="+HttpUtility.UrlEncode(b);
int nbChars=requte.Length;
// construction du tableau des enttes HTTP envoyer
string[] entetes=new string[6];
entetes[0]="POST " + uri.AbsolutePath+ "/"+fonction+" HTTP/1.1";
entetes[1]="Host: " + uri.Host+":"+uri.Port;
entetes[2]="Content-Type: application/x-www-form-urlencoded";
entetes[3]="Content-Length: "+nbChars;
entetes[4]="Connection: Keep-Alive";
entetes[5]="";
// on envoie les enttes HTTP au serveur
for(int i=0;i<entetes.Length;i++){
// envoi au serveur
OUT.WriteLine(entetes[i]);
// cho cran
Console.Out.WriteLine("--> "+entetes[i]);
}//for
// on lit la 1ere rponse du serveur Web HTTP/1.1 100
string ligne=null; // une ligne du flux de lecture
while((ligne=IN.ReadLine())!=""){
//cho
Console.Out.WriteLine("<-- "+ligne);
}//while
//cho dernire ligne
Console.Out.WriteLine("<-- "+ligne);
// envoi paramtres de la requte
OUT.Write(requte);
// echo
Console.Out.WriteLine("--> "+requte);
// construction de l'expression rgulire permettant de retrouver la taille de la rponse XML
// dans le flux de la rponse du serveur web
string modleLength=@"^Content-Length: (.+?)\s*$";
Regex RegexLength=new Regex(modleLength);
Match MatchLength=null;
int longueur=0;
// lecture seconde rponse du serveur web aprs envoi de la requte
// on mmorise la valeur de la ligne Content-Length
ligne=null; // une ligne du flux de lecture
while((ligne=IN.ReadLine())!=""){
// cho cran
Console.Out.WriteLine("<-- " + ligne);
// Content-Length ?
MatchLength=RegexLength.Match(ligne);
if(MatchLength.Success){
longueur=int.Parse(MatchLength.Groups[1].Value);
}//if
}//while
// cho dernire ligne
Console.Out.WriteLine("<--");
// construction de l'expression rgulire permettant de retrouver le rsultat
// dans le flux de la rponse du serveur web
string modle=@"<double xmlns="+"\""+@"st\.istia\.univ-angers\.fr"+"\""+@">(.+?)</double>";
Regex ModleRsultat=new Regex(modle);
Match MatchRsultat=null;
// on lit le reste de la rponse du serveur web
Conclusion 224
char[] chrRponse=new char[longueur];
IN.Read(chrRponse,0,longueur);
string strRponse=new String(chrRponse);
// on dcompose la rponse en lignes de texte
string[] lignes=Regex.Split(strRponse,"\n");
// on parcourt les lignes de texte la recherche du rsultat
string strRsultat="?"; // rsultat de la fonction
for(int i=0;i<lignes.Length;i++){
// suivi
Console.Out.WriteLine("<-- "+lignes[i]);
// comparaison ligne courante au modle
MatchRsultat=ModleRsultat.Match(lignes[i]);
// a-t-on trouv ?
if(MatchRsultat.Success){
// on note le rsultat
strRsultat=MatchRsultat.Groups[1].Value;
}
}//ligne suivante
// on affiche le rsultat
Console.Out.WriteLine("[rsultat="+strRsultat+"]\n");
}//executeFonction
Dans l'entte
--> Content-Length: 7
on doit indiquer la taille des paramtres qui seront envoys par le client derrire les enttes HTTP :
--> a=8&b=9
La mthode HttpUtility.UrlEncode(string chaine) transforme certains des caractres de chane en %n1n2 o n1n2 est le code ASCII du
caractre transform. Les caractres viss par cette transformation sont tous les caractres ayant un sens particulier dans une
requte POST (l'espace, le signe =, le signe &, ...). Ici la mthode HttpUtility.UrlEncode est normalement inutile puisque a et b sont
des nombres qui ne contiennent aucun de ces caractres particuliers. Elle est ici employe titre d'exemple. Elle a besoin de l'espace
de noms System.Web.
ajouter 6 7
--> POST /st/operations/operations.asmx/ajouter HTTP/1.1
--> Host: localhost:80
--> Content-Type: application/x-www-form-urlencoded
--> Content-Length: 7
--> Connection: Keep-Alive
-->
Une fois cette premire rponse lue, le client doit envoyer ses paramtres :
--> a=8&b=9
Cette rponse tant identique celle faite au client HTTP-GET, le code du client HTTP-POST pour traiter cette rponse est
identique au code correspondant du client HTTP-GET.
Conclusion 226
La demande du client est une demande POST. On va donc retrouver certains des mcanismes du client prcdent. La principale
diffrence est qu'alors que le client HTTP-POST envoyait les paramtres a et b sous la forme
a=A&b=B
Il reoit en retour une rponse XML galement plus complexe que les rponses vues prcdemment :
HTTP/1.1 200 OK
Content-Type: text/xml; charset=utf-8
Content-Length: length
Mme si la demande et la rponse sont plus complexes, il s'agit bien du mme mcanisme HTTP que pour le client HTTP-POST.
L'criture du client SOAP peut tre ainsi calqu sur celle du client HTTP-POST. Voici un exemple d'excution :
E:\data\serge\MSNET\c#\webservices\clientSOAP>clientsoap1 http://localhost/st/operations/operations.
asmx
Tapez vos commandes au format : [ajouter|soustraire|multiplier|diviser] a b
ajouter 3 4
--> POST /st/operations/operations.asmx HTTP/1.1
--> Host: localhost:80
--> Content-Type: text/xml; charset=utf-8
--> Content-Length: 321
--> Connection: Keep-Alive
--> SOAPAction: "st.istia.univ-angers.fr/ajouter"
-->
<-- HTTP/1.1 100 Continue
<-- Server: Microsoft-IIS/5.0
<-- Date: Wed, 15 May 2002 14:39:17 GMT
<--
--> <?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/20
01/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<ajouter xmlns="st.istia.univ-angers.fr">
<a>3</a>
<b>4</b>
</ajouter>
</soap:Body>
</soap:Envelope>
<-- HTTP/1.1 200 OK
<-- Server: Microsoft-IIS/5.0
<-- Date: Wed, 15 May 2002 14:39:17 GMT
<-- Cache-Control: private, max-age=0
<-- Content-Type: text/xml; charset=utf-8
Conclusion 227
<-- Content-Length: 345
<--
<-- <?xml version="1.0" encoding="utf-8"?><soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap
/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/
XMLSchema"><soap:Body><ajouterResponse xmlns="st.istia.univ-angers.fr"><ajouterResult>7</ajouterResu
lt></ajouterResponse></soap:Body></soap:Envelope>
[rsultat=7]
L encore, seule la mthode executeFonction change. Le client SOAP envoie les enttes HTTP de sa demande. Ils sont simplement un
peu plus complexes que ceux de HTTP-POST :
ajouter 3 4
--> POST /st/operations/operations.asmx HTTP/1.1
--> Host: localhost:80
--> Content-Type: text/xml; charset=utf-8
--> Content-Length: 321
--> Connection: Keep-Alive
--> SOAPAction: "st.istia.univ-angers.fr/ajouter"
-->
// executeFonction
public static void executeFonction(StreamReader IN, StreamWriter OUT, Uri uri, string fonction, string
a, string b){
// excute fonction(a,b) sur le service web d'URI uri
// les changes client-serveur se font via les flux IN et OUT
// le rsultat de la fonction est dans la ligne
// <double xmlns="st.istia.univ-angers.fr">double</double>
// envoye par le serveur
En recevant cette demande, le serveur envoie sa premire rponse que le client affiche :
Le code :
Le client va maintenant envoyer ses paramtres au format XML dans quelque chose qu'on appelle une enveloppe SOAP :
Conclusion 228
--> <?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/20
01/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<ajouter xmlns="st.istia.univ-angers.fr">
<a>3</a>
<b>4</b>
</ajouter>
</soap:Body>
</soap:Envelope>
Le code :
Le client affiche l'cran les enttes HTTP reus tout en y cherchant la ligne Content-Length :
Une fois la taille N de la rponse XML connue, le client lit N caractres dans le flux de la rponse du serveur, dcompose la chane
rcupre en lignes de texte pour les afficher l'cran et y chercher la balise XML du rsultat : <ajouterResult>7</ajouterResult> et
afficher ce dernier :
Conclusion 229
MatchRsultat=ModleRsultat.Match(lignes[i]);
// a-t-on trouv ?
if(MatchRsultat.Success){
// on note le rsultat
strRsultat=MatchRsultat.Groups[1].Value;
}
}//ligne suivante
// on affiche le rsultat
Console.Out.WriteLine("[rsultat="+strRsultat+"]\n");
}//executeFonction
Application Interface
cliente client-serveur Service Web
internet
L'application cliente s'adresserait l'interface client-serveur pour faire ses demandes au service web. Celle-ci ferait tous les changes
rseau ncessaires avec le serveur et rendrait le rsultat obtenu l'application cliente. Celle-ci n'aurait plus s'occuper des changes
avec le serveur ce qui faciliterait grandement son criture.
// espaces de noms
using System;
using System.Net.Sockets;
using System.IO;
using System.Text.RegularExpressions;
using System.Collections;
using System.Web;
// clientSOAP du service Web operations
public class clientSOAP{
// variables d'instance
Uri uri=null; // l'URI du service web
TcpClient client=null; // la liaison tcp du client avec le serveur
StreamReader IN=null; // le flux de lecture du client
StreamWriter OUT=null; // le flux d'criture du client
// dictionnaire des fonctions
Hashtable dicoFonctions=new Hashtable();
// liste des fonctions
string[] fonctions={"ajouter","soustraire","multiplier","diviser"};
// verbose
bool verbose=false; // vrai, affiche l'cran les changes client-serveur
// constructeur
public clientSOAP(string uriString, bool verbose){
// on note verbose
this.verbose=verbose;
// connexion au serveur
uri=new Uri(uriString);
client=new TcpClient(uri.Host,uri.Port);
// fonction valide ?
fonction=fonction.Trim().ToLower();
if (! dicoFonctions.ContainsKey(fonction))
return "[fonction ["+fonction+"] indisponible : (ajouter, soustraire,multiplier,diviser)]";
// arguments a et b valides ?
double doubleA=0;
try{
doubleA=double.Parse(a);
}catch{
return "[argument ["+a+"] incorrect (double)]";
}//catch
double doubleB=0;
try{
doubleB=double.Parse(b);
}catch{
return "[argument ["+b+"] incorrect (double)]";
}//catch
// division par zro ?
if(fonction=="diviser" && doubleB==0)
return "[division par zro]";
// construction de la chane de requte SOAP
string requteSOAP="<?xml version="+"\"1.0\" encoding=\"utf-8\"?>\n";
requteSOAP+="<soap:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"
xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n";
requteSOAP+="<soap:Body>\n";
requteSOAP+="<"+fonction+" xmlns=\"st.istia.univ-angers.fr\">\n";
requteSOAP+="<a>"+a+"</a>\n";
requteSOAP+="<b>"+b+"</b>\n";
requteSOAP+="</"+fonction+">\n";
requteSOAP+="</soap:Body>\n";
requteSOAP+="</soap:Envelope>";
int nbCharsSOAP=requteSOAP.Length;
// construction du tableau des enttes HTTP envoyer
string[] entetes=new string[7];
entetes[0]="POST " + uri.AbsolutePath+" HTTP/1.1";
entetes[1]="Host: " + uri.Host+":"+uri.Port;
entetes[2]="Content-Type: text/xml; charset=utf-8";
entetes[3]="Content-Length: "+nbCharsSOAP;
entetes[4]="Connection: Keep-Alive";
entetes[5]="SOAPAction: \"st.istia.univ-angers.fr/"+fonction+"\"";
entetes[6]="";
Nous ne retrouvons rien de neuf par raport ce qui a t dj vu. Nous avons simplement repris le code du client SOAP tudi et
l'avons ramnag quelque peu pour en faire une classe. Celle-ci a un constructeur et deux mthodes :
// constructeur
public clientSOAP(string uriString, bool verbose){
// executeFonction
public string executeFonction(string fonction, string a, string b){
// variables d'instance
Uri uri=null; // l'URI du service web
TcpClient client=null; // la liaison tcp du client avec le serveur
StreamReader IN=null; // le flux de lecture du client
StreamWriter OUT=null; // le flux d'criture du client
// dictionnaire des fonctions
Hashtable dicoFonctions=new Hashtable();
// liste des fonctions
string[] fonctions={"ajouter","soustraire","multiplier","diviser"};
// verbose
bool verbose=false; // vrai, affiche l'cran les changes client-serveur
Au cours de la construction, on construit les flux IN de lecture rseau, OUT d'criture rseau, ainsi que le dictionnaire des fonctions
gres par le service. Une fois l'objet construit, la connexion client-serveur est ouverte et ses flux IN et OUT utilisables.
La mthode ExecuteFonction est celle qu'on a crite pour le client SOAP tudi, quelques dtails prs :
1. Les paramtres uri, IN et OUT qui taient auparavant passs en paramtres la mthode n'ont plus besoin de l'tre
puisque ce sont maintenant des attributs d'instance accessibles toutes les mthodes de l'instance
Conclusion 232
2. La mthode ExecuteFonction qui rendait auparavant un type void et affichait le rsultat de la fonction l'cran, rend
maintenant ce rsultat et donc un type string.
1. cration d'un objet clientSOAP qui va crer la liaison avec le service web
2. utilisation rpte de la mthode executeFonction
3. fermeture de la liaison avec le service Web par la mthode Close.
// espaces de noms
using System;
using System.IO;
using System.Text.RegularExpressions;
public class testClientSoap{
// demande l'URI du service web operations
// excute de faon interactive les commandes tapes au clavier
public static void Main(string[] args){
// syntaxe
const string syntaxe="pg URI [verbose]";
// nombre d'arguments
if(args.Length != 1 && args.Length!=2)
erreur(syntaxe,1);
// verbose ?
bool verbose=false;
if(args.Length==2) verbose=args[1].ToLower()=="verbose";
// on se connecte au service web
clientSOAP client=null;
try{
client=new clientSOAP(args[0],verbose);
}catch(Exception ex){
// erreur de connexion
erreur("L'erreur suivante s'est produite lors de la connexion au service web : "
+ ex.Message,2);
}//catch
// les demandes de l'utilisateur sont tapes au clavier
// sous la forme fonction a b
// elles se terminent avec la commande fin
string commande=null; // commande tape au clavier
string[] champs=null; // champs d'une ligne de commande
// invite l'utilisateur
Console.Out.WriteLine("Tapez vos commandes au format : [ajouter|soustraire|multiplier|diviser] a
b\n");
// gestion des erreurs
try{
// boucle de saisie des commandes tapes au clavier
while(true){
// lecture commande
commande=Console.In.ReadLine().Trim().ToLower();
// fini ?
if(commande==null || commande=="fin") break;
// dcomposition de la commande en champs
champs=Regex.Split(commande,@"\s+");
// il faut trois champs
if(champs.Length!=3){
// commande invalide
Console.Out.WriteLine("syntaxe : [ajouter|soustraire|multiplier|diviser] a b");
// on recommence
continue;
}//if
// on fait la demande au service web
Console.Out.WriteLine("rsultat="+client.executeFonction(champs[0].Trim().ToLower(),champs[1].Trim(),cha
mps[2].Trim()));
// demande suivante
}//while
// fin des demandes
}catch(Exception e){
Console.Out.WriteLine("L'erreur suivante s'est produite : " + e.Message);
Conclusion 233
}//catch
// fin liaison client-serveur
try{
client.Close();
}catch{}
}//Main
// affichage des erreurs
public static void erreur(string msg, int exitCode){
// affichage erreur
System.Console.Error.WriteLine(msg);
// arrt avec erreur
Environment.Exit(exitCode);
}//erreur
}//classe
La client est maintenant considrablement plus simple et on n'y retrouve aucune communication rseau. Le client admet deux
paramtres :
1. l'URI du service web operations
2. le mot cl facultatif verbose. S'il est prsent, les changes rseau seront affichs l'cran.
Ces deux paramtres sont utiliss pour construire un objet clientSOAP qui va assurer les changes avec le service web.
Une fois ouverte la connexion avec le service web, le client peut envoyer ses demandes. Celles-ci sont tapes au clavier, analyses
puis envoyes au serveur par appel la mthode executeFonction de l'objet clientSOAP.
dos>dir
16/05/2002 09:08 6 065 ClientSOAP.cs
16/05/2002 09:08 7 168 ClientSOAP.dll
E:\data\serge\>testclientsoap http://localhost/st/operations/operations.asmx
Tapez vos commandes au format : [ajouter|soustraire|multiplier|diviser] a b
ajouter 1 3
rsultat=4
soustraire 6 7
rsultat=-1
multiplier 4 5
rsultat=20
diviser 1 2
rsultat=0.5
x
syntaxe : [ajouter|soustraire|multiplier|diviser] a b
x 1 2
rsultat=[fonction [x] indisponible : (ajouter, soustraire,multiplier,diviser)]
ajouter a b
rsultat=[argument [a] incorrect (double)]
ajouter 1 b
Conclusion 234
rsultat=[argument [b] incorrect (double)]
diviser 1 0
rsultat=[division par zro]
fin
ajouter 4 8
--> POST /st/operations/operations.asmx HTTP/1.1
--> Host: localhost:80
--> Content-Type: text/xml; charset=utf-8
--> Content-Length: 321
--> Connection: Keep-Alive
--> SOAPAction: "st.istia.univ-angers.fr/ajouter"
-->
<-- HTTP/1.1 100 Continue
<-- Server: Microsoft-IIS/5.0
<-- Date: Thu, 16 May 2002 08:15:15 GMT
<--
--> <?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/20
01/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<ajouter xmlns="st.istia.univ-angers.fr">
<a>4</a>
<b>8</b>
</ajouter>
</soap:Body>
</soap:Envelope>
<-- HTTP/1.1 200 OK
<-- Server: Microsoft-IIS/5.0
<-- Date: Thu, 16 May 2002 08:15:15 GMT
<-- Cache-Control: private, max-age=0
<-- Content-Type: text/xml; charset=utf-8
<-- Content-Length: 346
<--
<-- <?xml version="1.0" encoding="utf-8"?><soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap
/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/
XMLSchema"><soap:Body><ajouterResponse xmlns="st.istia.univ-angers.fr"><ajouterResult>12</ajouterRes
ult></ajouterResponse></soap:Body></soap:Envelope>
rsultat=12
fin
Conclusion 235
1
2 3
6
4 5
8
9
Conclusion 236
Le code de l'application suit. Nous avons omis le code du formulaire qui ne prsente pas d'intrt ici.
// variables globales
clientSOAP client=null;
public Form1()
{
// Required for Windows Form Designer support
InitializeComponent();
// init formulaire
btnOuvrir.Enabled=false;
btnFermer.Enabled=false;
btnCalculer.Enabled=false;
cmbFonctions.SelectedIndex=0;
// client SOAP
}
private void InitializeComponent()
{
...
}
static void Main()
{
Application.Run(new Form1());
}
Conclusion 237
private void txtURI_TextChanged(object sender, System.EventArgs e) {
// contrle le bouton ouvrir
btnOuvrir.Enabled=txtURI.Text.Trim()!="";
}
private void btnOuvrir_Click(object sender, System.EventArgs e) {
try{
// connexion au service Web
client=new clientSOAP(txtURI.Text,false);
// pas d'erreur
txtErreur.Text="Liaison ouverte";
// boutons
btnOuvrir.Enabled=false;
btnFermer.Enabled=true;
// URI
txtURI.ReadOnly=true;
}catch(Exception ex){
// erreur
txtErreur.Text=ex.Message;
}//catch
}
private void btnFermer_Click(object sender, System.EventArgs e) {
// on ferme la connexion au service web
client.Close();
// boutons
btnFermer.Enabled=false;
btnOuvrir.Enabled=true;
btnCalculer.Enabled=false;
// URI
txtURI.ReadOnly=false;
// tat
txtErreur.Text="Liaison ferme";
}
private void Form1_Closing(object sender, System.ComponentModel.CancelEventArgs e) {
// on ferme la liaison avant de quitter l'application
if(btnFermer.Enabled) btnFermer_Click(null,null);
}
private void btnCalculer_Click(object sender, System.EventArgs e) {
// calcul d'une fonction(a,b)
try{
txtRsultat.Text=""; // efface le rsultat prcdent
txtRsultat.Text=client.executeFonction(cmbFonctions.Text,txtA.Text.Trim(),txtB.Text.Trim());
}catch(Exception ex){
// erreur
txtErreur.Text=ex.Message;
// on ferme la liaison
btnFermer_Click(null,null);
}//catch
}
private void txtA_TextChanged(object sender, System.EventArgs e) {
// contrle l'tat du bouton calculer
btnCalculer.Enabled=txtA.Text.Trim()!="" && txtB.Text.Trim()!="" && btnFermer.Enabled;
}
private void txtB_TextChanged(object sender, System.EventArgs e) {
// idem txtA
txtA_TextChanged(null,null);
}
}
L encore la classe clientSOAP cache tout l'aspect rseau de l'application.
Application Intermdiaire
cliente client-serveur Service Web
internet
La plate-forme .NET pousse cette logique plus loin. Une fois connu le service Web atteindre, nous pouvons gnrer
automatiquement la classe qui va nous servir d'intermdiaire pour atteindre les fonctions du service Web et qui cachera toute la
partie rseau. On appelle cette classe un proxy pour le service web pour lequel elle a t gnre.
Conclusion 238
Comment gnrer la classe proxy d'un service web ? Un service web est toujours accompagn d'un fichier de description au format
XML. Si l'URI de notre service web operations est http://localhost/st/operations/operations.asmx, son fichier de description est
disponible l'URL http://localhost/st/operations/operations.asmx?wsdl comme le montre la copie d'cran suivante :
On a l un fichier XML dcrivant prcisment toutes les fonctions du service web avec pour chacune d'elles le type et le nombre de
paramtres, le type du rsultat. On appelle ce fichier le fichier WSDL du service parce qu'il utilise le langage WSDL (Web Services
Description Language). A partir de ce fichier, une classe proxy peut tre gnre l'aide de l'outil wsdl :
E:\data\serge\MSNET\c#\webservices\clientproxy>wsdl http://localhost/st/operations/operations.asmx?wsdl
Microsoft (R) Web Services Description Language Utility
[Microsoft (R) .NET Framework, Version 1.0.3705.0]
Copyright (C) Microsoft Corporation 1998-2001. All rights reserved.
E:\data\serge\MSNET\c#\webservices\clientproxy>dir
16/05/2002 13:00 6 642 operations.cs
L'outil wsdl gnre un fichier source C# portant le nom de la classe implmentant le service web, ici operations. Examinons une partie
du code gnr :
//------------------------------------------------------------------------------
// <autogenerated>
// This code was generated by a tool.
// Runtime Version: 1.0.3705.0
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------
//
// Ce code source a t automatiquement gnr par wsdl, Version=1.0.3705.0.
//
using System.Diagnostics;
using System.Xml.Serialization;
using System;
using System.Web.Services.Protocols;
using System.ComponentModel;
using System.Web.Services;
/// <remarks/>
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Web.Services.WebServiceBindingAttribute(Name="operationsSoap", Namespace="st.istia.univ-
angers.fr")]
public class operations : System.Web.Services.Protocols.SoapHttpClientProtocol {
/// <remarks/>
public operations() {
this.Url = "http://localhost/st/operations/operations.asmx";
}
/// <remarks/>
Conclusion 239
[System.Web.Services.Protocols.SoapDocumentMethodAttribute("st.istia.univ-angers.fr/ajouter",
RequestNamespace="st.istia.univ-angers.fr", ResponseNamespace="st.istia.univ-angers.fr",
Use=System.Web.Services.Description.SoapBindingUse.Literal,
ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
public System.Double ajouter(System.Double a, System.Double b) {
object[] results = this.Invoke("ajouter", new object[] {
a,
b});
return ((System.Double)(results[0]));
}
/// <remarks/>
public System.IAsyncResult Beginajouter(System.Double a, System.Double b, System.AsyncCallback
callback, object asyncState) {
return this.BeginInvoke("ajouter", new object[] {
a,
b}, callback, asyncState);
}
/// <remarks/>
public System.Double Endajouter(System.IAsyncResult asyncResult) {
object[] results = this.EndInvoke(asyncResult);
return ((System.Double)(results[0]));
}
....
Ce code est un peu complexe au premier abord. Nous n'avons pas besoin d'en comprendre les dtails pour pouvoir l'utiliser.
Examinons tout d'abord la dclaration de la classe :
La classe porte le nom operations du service web pour lequel elle a t construite. Elle drive de la classe SoapHttpClientProtocol :
// from module
'c:\winnt\assembly\gac\system.web.services\1.0.3300.0__b03f5f7f11d50a3a\system.web.services.dll'
public class System.Web.Services.Protocols.SoapHttpClientProtocol :
System.Web.Services.Protocols.HttpWebClientProtocol,
System.ComponentModel.IComponent,
IDisposable
{
// Fields
// Constructors
public SoapHttpClientProtocol();
// Properties
public bool AllowAutoRedirect { get; set; }
public X509CertificateCollection ClientCertificates { get; }
public string ConnectionGroupName { get; set; }
public IContainer Container { get; }
public CookieContainer CookieContainer { get; set; }
public ICredentials Credentials { get; set; }
public bool PreAuthenticate { get; set; }
public IWebProxy Proxy { get; set; }
public Encoding RequestEncoding { get; set; }
public ISite Site { virtual get; virtual set; }
public int Timeout { get; set; }
public string Url { get; set; }
public string UserAgent { get; set; }
// Events
public event EventHandler Disposed;
// Methods
public virtual void Abort();
public virtual System.Runtime.Remoting.ObjRef CreateObjRef(Type requestedType);
public void Discover();
public virtual void Dispose();
public virtual bool Equals(object obj);
public virtual int GetHashCode();
public virtual object GetLifetimeService();
public Type GetType();
public virtual object InitializeLifetimeService();
public virtual string ToString();
} // end of System.Web.Services.Protocols.SoapHttpClientProtocol
public operations() {
this.Url = "http://localhost/st/operations/operations.asmx";
}
Conclusion 240
Le constructeur affecte l'attibut url l'URL du service web associ au proxy. La classe operations ci-dessus ne dfinit pas elle-mme
l'attribut url. Celui-ci est hrit de la classe dont drive le proxy : System.Web.Services.Protocols.SoapHttpClientProtocol. Examinons
maintenant ce qui se rapporte la mthode ajouter :
On peut constater qu'elle a la mme signature que dans le service Web operations o elle tait dfinie comme suit :
[WebMethod]
public double ajouter(double a, double b){
return a+b;
}//ajouter
La faon dont cette classe dialogue avec le service Web n'apparat pas ici. Ce dialogue est entirement pris en charge par la classe
parent System.Web.Services.Protocols.SoapHttpClientProtocol. On ne trouve dans le proxy que ce qui le diffrencie des autres proxy :
Pour utiliser les mthodes du service web operations, un client n'a besoin que de la classe proxy operations gnre prcdemment.
Compilons cette classe dans un fichier assembly :
E:\data\serge\MSNET\c#\webservices\clientproxy>dir
16/05/2002 13:00 6 642 operations.cs
16/05/2002 13:33 7 680 operations.dll
Maintenant crivons un client. Nous reprenons un client console dj utilis plusieurs fois. Il est appel sans paramtres et excute
les demandes tapes au clavier :
E:\data\serge\MSNET\c#\webservices\clientproxy>testclientproxy
Tapez vos commandes au format : [ajouter|soustraire|multiplier|diviser|toutfaire] a b
ajouter 4 5
rsultat=9
soustraire 9 8
rsultat=1
multiplier 10 4
rsultat=40
diviser 6 7
rsultat=0,857142857142857
toutfaire 10 20
rsultats=[30,-10,200,0,5]
diviser 5 0
rsultat=+Infini
fin
// espaces de noms
using System;
using System.IO;
using System.Text.RegularExpressions;
using System.Collections;
public class testClientProxy{
// excute de faon interactive les commandes tapes au clavier
// et les envoie au service web operations
public static void Main(){
// il n'y a plus d'arguments
// l'URL du service web tant code en dur dans le proxy
// cration d'un dictionnaire des fonctions du service web
string[] fonctions={"ajouter","soustraire","multiplier","diviser","toutfaire"};
Hashtable dicoFonctions=new Hashtable();
for (int i=0;i<fonctions.Length;i++){
dicoFonctions.Add(fonctions[i],true);
}//for
// on cre un objet proxy operations
operations myOperations=null;
Conclusion 241
try{
myOperations=new operations();
}catch(Exception ex){
// erreur de connexion
erreur("L'erreur suivante s'est produite lors de la connexion au proxy dy service web : "
+ ex.Message,2);
}//catch
// les demandes de l'utilisateur sont tapes au clavier
// sous la forme fonction a b
// elles se terminent avec la commande fin
// invite l'utilisateur
Console.Out.WriteLine("Tapez vos commandes au format :
[ajouter|soustraire|multiplier|diviser|toutfaire] a b\n");
// gestion des erreurs
// boucle de saisie des commandes tapes au clavier
while(true){
// lecture commande
commande=Console.In.ReadLine().Trim().ToLower();
// fini ?
if(commande==null || commande=="fin") break;
// dcomposition de la commande en champs
champs=Regex.Split(commande,@"\s+");
// commande valide ?
string fonction;
double a,b;
try{
// il faut trois champs
if(champs.Length!=3)throw new Exception();
// le champ 0 doit tre une fonction reconnue
fonction=champs[0];
if(! dicoFonctions.ContainsKey(fonction)) throw new Exception();
// le champ 1 doit tre un nombre valide
a=double.Parse(champs[1]);
// le champ 2 doit tre un nombre valide
b=double.Parse(champs[2]);
}catch {
// commande invalide
Console.Out.WriteLine("syntaxe : [ajouter|soustraire|multiplier|diviser] a b");
// on recommence
continue;
}//catch
// on fait la demande au service web
try{
double rsultat;
double[] rsultats;
if(fonction=="ajouter"){
rsultat=myOperations.ajouter(a,b);
Console.Out.WriteLine("rsultat="+rsultat);
}//ajouter
if(fonction=="soustraire"){
rsultat=myOperations.soustraire(a,b);
Console.Out.WriteLine("rsultat="+rsultat);
}//soustraire
if(fonction=="multiplier"){
rsultat=myOperations.multiplier(a,b);
Console.Out.WriteLine("rsultat="+rsultat);
}//multiplier
if(fonction=="diviser"){
rsultat=myOperations.diviser(a,b);
Console.Out.WriteLine("rsultat="+rsultat);
}//diviser
if(fonction=="toutfaire"){
rsultats=myOperations.toutfaire(a,b);
Console.Out.WriteLine("rsultats=["+rsultats[0]+","+rsultats[1]+","+rsultats[2]+","+rsultats[3]+"]")
;
}//toutfaire
}catch(Exception e){
Console.Out.WriteLine("L'erreur suivante s'est produite : " + e.Message);
}//catch
// demande suivante
}//while
}//Main
// affichage des erreurs
public static void erreur(string msg, int exitCode){
// affichage erreur
System.Console.Error.WriteLine(msg);
// arrt avec erreur
Environment.Exit(exitCode);
}//erreur
}//classe
Nous n'examinons que le code propre l'utilisation de la classe proxy. Tout d'abord un objet proxy operations est cr :
Conclusion 242
// on cre un objet proxy operations
operations myOperations=null;
try{
myOperations=new operations();
}catch(Exception ex){
// erreur de connexion
erreur("L'erreur suivante s'est produite lors de la connexion au proxy du service web : "
+ ex.Message,2);
}//catch
Des lignes fonction a b sont tapes au clavier. A partir de ces informations, on appelle les mthodes appropries du proxy :
On traite ici pour la premire fois, l'opration toutfaire qui fait les quatre oprations. Elle avait t ignore pour l'instant car elle
envoie un tableau de nombres encapsul dans une enveloppe XML plus complique grer que les rponses XML simples des
autres fonctions ne dlivrant qu'un rsultat. On voit qu'ici avec la classe proxy, utiliser la mthode toutfaire n'est pas plus compliqu
qu'utiliser les autres mthodes.
<configuration>
<appSettings>
<add key="nom" value="tintin"/>
<add key="age" value="27"/>
</appSettings>
</configuration>
<configuration>
<appSettings>
...
</appSettings>
</configuration>
Comment le service Web rcupre-t-il ces informations ? Lorsque IIS charge un service web, il regarde s'il y a dans le mme dossier
un fichier web.config. Si oui, il le lit. La valeur V d'un paramtre P est obtenue par l'instruction :
string P=ConfigurationSettings.AppSettings["V"];
Le service web personne a deux attributs nom et age qui sont initialiss dans son constructeur sans paramtres partir des valeurs lues
dans le fichier de configuration web.config du service personne. Ce fichier est le suivant :
<configuration>
<appSettings>
<add key="nom" value="tintin"/>
<add key="age" value="27"/>
</appSettings>
</configuration>
Le service web a par ailleurs une [WebMethod] id sans paramtres et qui se contente de rendre les attributs nom et age. Le service
est enregistr dans le fichier source personne.asmx qui est plac avec son fichier de configuration dans le dossier
c:\inetpub\wwwroot\st\personne :
E:\data\serge\MSNET\c#\webservices\clientproxy>dir c:\inetpub\wwwroot\st\personne
16/05/2002 14:38 133 web.config
16/05/2002 14:46 521 personne.asmx
Conclusion 244
La mthode id n'a pas de paramtres. Utilisons le bouton Appeler :
Nous avons bien rcupr les informations places dans le fichier web.config du service.
using System;
using System.Data;
using Microsoft.Data.Odbc;
using System.Collections;
public class impt{
// les donnes ncessaires au calcul de l'impt
// proviennent d'une source extrieure
private decimal[] limites, coeffR, coeffN;
// constructeur
public impt(string DSNimpots, string Timpots, string colLimites, string colCoeffR, string colCoeffN){
// initialise les trois tableaux limites, coeffR, coeffN partir
// du contenu de la table Timpots de la base ODBC DSNimpots
// colLimites, colCoeffR, colCoeffN sont les trois colonnes de cette table
// peut lancer une exception
string connectString="DSN="+DSNimpots+";"; // chane de connexion la base
OdbcConnection impotsConn=null; // la connexion
OdbcCommand sqlCommand=null; // la commande SQL
// la requte SELECT
string selectCommand="select "+colLimites+","+colCoeffR+","+colCoeffN+" from "+Timpots;
// tableaux pour rcuprer les donnes
ArrayList tLimites=new ArrayList();
ArrayList tCoeffR=new ArrayList();
ArrayList tCoeffN=new ArrayList();
// on tente d'accder la base de donnes
impotsConn = new OdbcConnection(connectString);
impotsConn.Open();
// on cre un objet command
sqlCommand=new OdbcCommand(selectCommand,impotsConn);
// on excute la requte
OdbcDataReader myReader=sqlCommand.ExecuteReader();
Conclusion 245
// Exploitation de la table rcupre
while (myReader.Read()) {
// les donnes de la ligne courante sont mis dans les tableaux
tLimites.Add(myReader[colLimites]);
tCoeffR.Add(myReader[colCoeffR]);
tCoeffN.Add(myReader[colCoeffN]);
}//while
// libration des ressources
myReader.Close();
impotsConn.Close();
// les tableaux dynamiques sont mis dans des tableaux statiques
this.limites=new decimal[tLimites.Count];
this.coeffR=new decimal[tLimites.Count];
this.coeffN=new decimal[tLimites.Count];
for(int i=0;i<tLimites.Count;i++){
limites[i]=decimal.Parse(tLimites[i].ToString());
coeffR[i]=decimal.Parse(tCoeffR[i].ToString());
coeffN[i]=decimal.Parse(tCoeffN[i].ToString());
}//for
}//constructeur 2
// calcul de l'impt
public long calculer(bool mari, int nbEnfants, int salaire){
// calcul du nombre de parts
decimal nbParts;
if (mari) nbParts=(decimal)nbEnfants/2+2;
else nbParts=(decimal)nbEnfants/2+1;
if (nbEnfants>=3) nbParts+=0.5M;
// calcul revenu imposable & Quotient familial
decimal revenu=0.72M*salaire;
decimal QF=revenu/nbParts;
// calcul de l'impt
limites[limites.Length-1]=QF+1;
int i=0;
while(QF>limites[i]) i++;
// retour rsultat
return (long)(revenu*coeffR[i]-nbParts*coeffN[i]);
}//calculer
}//classe
Dans le service web, on ne peut utiliser qu'un constructeur sans paramtres. Aussi le constructeur de la classe va-t-il devenir le
suivant :
using System.Configuration;
// constructeur
public impt(){
// initialise les trois tableaux limites, coeffR, coeffN partir
// du contenu de la table Timpots de la base ODBC DSNimpots
// colLimites, colCoeffR, colCoeffN sont les trois colonnes de cette table
// peut lancer une exception
// on rcupre les paramtres de configuration du service
string DSNimpots=ConfigurationSettings.AppSettings["DSN"];
string Timpots=ConfigurationSettings.AppSettings["TABLE"];
string colLimites=ConfigurationSettings.AppSettings["COL_LIMITES"];
string colCoeffR=ConfigurationSettings.AppSettings["COL_COEFFR"];
string colCoeffN=ConfigurationSettings.AppSettings["COL_COEFFN"];
Les cinq paramtres du constructeur de la classe prcdente sont maintenant lus dans le fichier web.config du service. Le code du
fichier source impots.asmx est le suivant. Il reprend la majeure partie du code prcdent. Nous nous sommes contents d'encadrer les
portions de code propres au service web :
// c'est bon
OK=true;
errMessage="";
}catch(Exception ex){
// erreur
OK=false;
errMessage+="["+ex.Message+"]";
}//catch
}//constructeur
// calcul de l'impt
[WebMethod]
public long calculer(bool mari, int nbEnfants, int salaire){
// calcul du nombre de parts
...
}//calculer
// id
[WebMethod]
public string id(){
// pour voir si tout est OK
return "["+OK+","+errMessage+"]";
}//id
}//classe
Expliquons les quelques modifications faites la classe impt en-dehors de celles ncessaires pour en faire un service web :
la lecture de la base de donnes dans le constructeur peut chouer. Aussi avons-nous ajout deux attributs notre classe et
une mthode :
o le boolen OK est vrai si la base a pu tre lue, faux sinon
o la chane errMessage contient un message d'erreur si la base de donnes n'a pu tre lue.
o la mthode id sans paramtres permet d'obtenir la valeur ces deux attributs.
pour grer l'erreur ventuelle d'accs la base de donnes, la partie du code du constructeur concerne par cet accs a t
entoure d'un try-catch.
<configuration>
<appSettings>
<add key="DSN" value="mysql-impots" />
<add key="TABLE" value="timpots" />
<add key="COL_LIMITES" value="limites" />
<add key="COL_COEFFR" value="coeffr" />
<add key="COL_COEFFN" value="coeffn" />
</appSettings>
</configuration>
Lors d'un premier essai de chargement du service impots, le compilateur a dclar qu'il ne trouvait pas l'espace de noms
Microsoft.Data.Odbc utilis dans la directive :
using Microsoft.Data.Odbc;
Conclusion 247
o une copie du fichier microsoft.data.odbc.dll a t place dans le dossier c:\inetpub\wwwroot\bin qui est systmatiquement
explor par le compilateur d'un service web lorsqu'il recherche un "assembly".
D'autres solutions semblent possibles mais n'ont pas t cruses ici. Le fichier de configuration est donc devenu :
<configuration>
<appSettings>
<add key="DSN" value="mysql-impots" />
<add key="TABLE" value="timpots" />
<add key="COL_LIMITES" value="limites" />
<add key="COL_COEFFR" value="coeffr" />
<add key="COL_COEFFN" value="coeffn" />
</appSettings>
<system.web>
<compilation>
<assemblies>
<add assembly="Microsoft.Data.Odbc" />
</assemblies>
</compilation>
</system.web>
</configuration>
E:\data\serge\MSNET\c#\adonet\7>dir c:\inetpub\wwwroot\bin
30/01/2002 02:02 327 680 Microsoft.Data.Odbc.dll
E:\data\serge\MSNET\c#\adonet\7>dir c:\inetpub\wwwroot\st\impots
16/05/2002 16:43 3 678 impots.asmx
16/05/2002 16:35 425 web.config
Si on suit le lien id :
Le rsultat prcdent affiche les valeurs des attributs OK (true) et errMessage (""). Dans cet exemple, la base a t charge
correctement. Ca n'a pas toujours t le cas et c'est pourquoi nous avons ajout la mthode id pour avoir accs au message d'erreur.
Conclusion 248
L'erreur tait que le nom DSN de la base avait t dfinie comme DSN utilisateur alors qu'il fallait le dfinir comme DSN
systme. Cette distinction se fait dans le gestionnaire de sources ODBC 32 bits :
1
2
Conclusion 249
Le rsultat est correct.
E:\data\serge\MSNET\c#\impots\webservice>wsdl http://localhost/st/impots/impots.asmx
E:\data\serge\MSNET\c#\impots\webservice>dir
16/05/2002 17:19 3 138 impt.cs
E:\data\serge\MSNET\c#\impots\webservice>dir
16/05/2002 17:19 3 138 impt.cs
16/05/2002 17:20 5 120 impt.dll
E:\data\serge\MSNET\c#\impots\6>dir
07/05/2002 18:01 3 235 impots.cs
07/05/2002 18:01 5 120 impots.dll
07/05/2002 17:50 2 854 test.cs
07/05/2002 18:01 5 632 test.exe
E:\data\serge\MSNET\c#\impots\6>test
pg DSNimpots tabImpots colLimites colCoeffR colCoeffN
Le programme test utilisait alors la classe impt classique celle contenue dans le fichier impots.dll. Le code du programme test.cs tait le
suivant :
using System;
class test
{
public static void Main(string[] arguments)
{
// programme interactif de calcul d'impt
// l'utilisateur tape trois donnes au clavier : mari nbEnfants salaire
// le programme affiche alors l'impt payer
Conclusion 250
// msg d'erreur
Console.Error.WriteLine(syntaxe1);
// fin
Environment.Exit(1);
}//if
// on rcupre les arguments
string DSNimpots=arguments[0];
string tabImpots=arguments[1];
string colLimites=arguments[2];
string colCoeffR=arguments[3];
string colCoeffN=arguments[4];
// boucle infinie
while(true){
// on demande les paramtres du calcul de l'impt
Console.Out.Write("Paramtres du calcul de l'impt au format mari nbEnfants salaire ou rien pour
arrter :");
string paramtres=Console.In.ReadLine().Trim();
// qq chose faire ?
if(paramtres==null || paramtres=="") break;
// vrification du nombre d'arguments dans la ligne saisie
string[] args=paramtres.Split(null);
int nbParamtres=args.Length;
if (nbParamtres!=3){
Console.Error.WriteLine(syntaxe2);
continue;
}//if
// vrification de la validit des paramtres
// mari
string mari=args[0].ToLower();
if (mari!="o" && mari !="n"){
Console.Error.WriteLine(syntaxe2+"\nArgument mari incorrect : tapez o ou n");
continue;
}//if
// nbEnfants
int nbEnfants=0;
try{
nbEnfants=int.Parse(args[1]);
if(nbEnfants<0) throw new Exception();
}catch (Exception){
Console.Error.WriteLine(syntaxe2+"\nArgument nbEnfants incorrect : tapez un entier positif ou
nul");
continue;
}//if
// salaire
int salaire=0;
try{
salaire=int.Parse(args[2]);
if(salaire<0) throw new Exception();
}catch (Exception){
Console.Error.WriteLine(syntaxe2+"\nArgument salaire incorrect : tapez un entier positif ou
nul");
continue;
}//if
// les paramtres sont corrects - on calcule l'impt
Console.Out.WriteLine("impt="+objImpt.calculer(mari=="o",nbEnfants,salaire)+" F");
// contribuable suivant
}//while
}//Main
}//classe
Nous reprenons le mme programme pour lui faire utiliser maintenant le service web impots au travers de la classe proxy impt cre
prcdemment. Nous sommes obligs de modifier quelque peu le code :
o alors que la classe impt d'origine avait un constructeur cinq arguments, la classe proxy impt a un constructeur sans
paramtres. Les cinq paramtres, nous l'avons vu, sont maintenant fixs dans le fichier de configuration du service web.
o il n'y a donc plus besoin de passer ces cinq paramtres en arguments au programme test
using System;
class test
{
public static void Main()
{
// programme interactif de calcul d'impt
// l'utilisateur tape trois donnes au clavier : mari nbEnfants salaire
// le programme affiche alors l'impt payer
const string syntaxe2="syntaxe : mari nbEnfants salaire\n"
Conclusion 251
+"mari : o pour mari, n pour non mari\n"
+"nbEnfants : nombre d'enfants\n"
+"salaire : salaire annuel en F";
// boucle infinie
while(true){
// on demande les paramtres du calcul de l'impt
...
}//while
}//Main
}//classe
E:\data\serge\MSNET\c#\impots\webservice>dir
E:\data\serge\MSNET\c#\impots\webservice>dir
16/05/2002 17:20 5 120 impt.dll
16/05/2002 17:53 2 324 test.cs
16/05/2002 18:11 5 632 test.exe
puis l'excutons :
E:\data\serge\MSNET\c#\impots\webservice>test
Paramtres du calcul de l'impt au format mari nbEnfants salaire ou rien pour arrter :o 2 200000
impt=22506 F
Conclusion 252
10. A suivre
Il resterait des thmes importants couvrir. En voici trois :
1. les objets DataSet qui permettent de grer une base de donnes en mmoire, de l'exporter ou l'importer au format XML
2. une tude de XML avec les classes .NET permettant de grer les documents XML
3. la programmation Web avec les pages et contrles ASP.NET
A lui seul, le point 3 mrite un polycopi. Les points 1 et 2 devraient tre ajouts progressivement ce prsent document.
Conclusion 253