Notions avances du langage C#

Version 1.0
Z

David Assany Sacha Durand Saint-Omer

[Notions avances de C#]

[Date : 14/09/09]

Sommaire

1 2

Introduction ........................................................................................................................ 4 Les notions savoir ......................................................................................................... 5

2.1 2.2 Le type var ............................................................................................................................... 5 Conversions de donnes ......................................................................................................... 5 Le cast .............................................................................................................................. 5 Conversion dune chaine en nombre .............................................................................. 7 Conversion dun nombre en chaine ................................................................................ 8 Conversion en objet ........................................................................................................ 8

2.2.1 2.2.2 2.2.3 2.2.4 2.3

Le type valeur et le type rfrence ......................................................................................... 9

Les structures de donnes ......................................................................................... 11

3.1 Les tableaux ........................................................................................................................... 11 Dclaration et initialisation ........................................................................................... 11 Parcourir un tableau une dimension .......................................................................... 11 Dimension multiples ...................................................................................................... 12 Parcourir un tableau dimensions multiples................................................................ 12 3.1.1 3.1.2 3.1.3 3.1.4 3.2

Les Listes ................................................................................................................................ 13 Dclaration dune liste .................................................................................................. 13 Ajouter des lments la liste ...................................................................................... 13 Parcourir la liste ............................................................................................................ 14 Action sur la liste ........................................................................................................... 14

3.2.1 3.2.2 3.2.3 3.2.4 3.3

Les numrations .................................................................................................................. 15 Dclaration et initialisation ........................................................................................... 15 Utiliser une numration .............................................................................................. 15

3.3.1 3.3.2 3.4

Les structures ........................................................................................................................ 17 Dclaration et initialisation ........................................................................................... 17 Utiliser une structure..................................................................................................... 18

3.4.1 3.4.2

Les mthodes et gestion des erreurs..................................................................... 19

4.1 Cration dune mthode ....................................................................................................... 19 Exemple ......................................................................................................................... 19 Passage de paramtres ................................................................................................. 20 Utilisation des mthodes............................................................................................... 22 Dotnet France Association 4.1.1 4.1.2 4.1.3

[Notions avances de C#] 4.2

[Date : 14/09/09]

Gestion des erreurs ............................................................................................................... 22 Importance de la gestion dexception ........................................................................... 22 try .................................................................................................................................. 23 catch .............................................................................................................................. 24 Finally............................................................................................................................. 25 Exception multiples ....................................................................................................... 26

4.2.1 4.2.2 4.2.3 4.2.4 4.2.5

Conclusion ........................................................................................................................ 28

Dotnet France Association

[Notions avances de C#]

[Date : 14/09/09]

1 Introduction
Ce chapitre des notions avances vient complter les connaissances acquises dans le prcdent chapitre concernant les notions fondamentales du langage c#. Nous allons prsenter les notions importantes savoir, les diffrentes structures de donnes et introduire ce que sont les mthodes et la gestion des exceptions.

Dotnet France Association

[Notions avances de C#]

[Date : 14/09/09]

2 Les notions savoir

2.1 Le type var
Dans le Chapitre prcdent, nous avons pass en revu les diffrents types de variables du langage C#. Et nous allons maintenant introduire un nouveau type de variable, le type var . Tout dabord, il faut savoir que le C# est un langage dit typage fort .En effet le C# a un systme de type trs complet qui nous permet dcrire avec prcision le type de notre variable. Dautre part, il y a une scurit et une vrification du typage au moment de la compilation. Cette notion de typage fort fait du C# un langage sr . Le type var est un type gnrique qui va nous permettre de stocker tout type de variable, il va donc pouvoir nous permettre de stocker une variable sans prciser son type. Le type var introduit la notion d infrence de type c'est--dire que le compilateur va rechercher le meilleur type pour stocker notre variable ! Au moment de la compilation, le compilateur va analyser notre variable et va la stocker dans le type le plus adapt. Attention toutefois car cela ne marche que pour le cas dune variable locale c'est--dire des variables qui sont dclares dans une fonction et la variable doit tre initialise au moment de la dclaration. Exemple :
//C# static void Main(string[] args) { //Dclaration sans typage var age1 = 17; var age2 = "Quarante ans"; var age3 = 32.5; //Affichage du type des variables Console.WriteLine(age1.GetType()); Console.WriteLine(age2.GetType()); Console.WriteLine(age3.GetType()); Console.ReadLine(); }

Et la console nous renvoie ceci : System.Int32 System.String System.Double

Ce qui nous prouve bien que le compilateur slectionn le type appropri chaque variable.

2.2 Conversions de donnes

2.2.1 Le cast Le cast est une action qui permet de convertir une donne dun type vers un autre type. Nous allons voir les diffrents types de conversion : Dotnet France Association

[Notions avances de C#]

2.2.1.1

[Date : 14/09/09]

Le cast implicite Le cast implicite est un cast qui ne pose aucun problme, car il nentraine pas de perte de donnes. Par exemple si on veut convertir un type int en un type long, la conversion ne posera jamais problme car le type long englobe le type int.
//C# static void Main(string[] args) { int age = 42; long longAge = age; //Ici on convertit notre int en long Console.WriteLine("Mon ge est : {0}",longAge); Console.ReadLine(); }

Le code compile et la console nous renvoie : Mon ge est 42

2.2.1.2

Le cast explicite Tout dabord nous allons essayer le code suivant et observer ce quil se passe.

//C# static void Main(string[] args) { float resultatPrecis = 17.83f; int resultat = resultatPrecis; Console.WriteLine("Le rsultat est : {0}", resultat); Console.ReadLine(); }

Dans le code ci-dessus, on essaie de stocker un rsultat deux chiffres aprs la virgule dans un entier. Comme vous pouvez limaginer, Visual Studio ne va pas compiler et nous renvoie un joli message derreur :

Dotnet France Association

[Notions avances de C#]

[Date : 14/09/09]

Pour viter ce message derreur et russir la compilation, il va nous falloir dfinir notre conversion de manire explicite. Pour cela, rien de plus simple, on va mettre devant notre variable, le type dsir entre parenthses, en loccurrence int . Ce qui nous donne :
//C# static void Main(string[] args) { float resultatPrecis = 17.83f; int resultat = (int)resultatPrecis; //Conversion explicite. Console.WriteLine("Le rsultat est : {0}", resultat); Console.ReadLine(); }

Le rsultat est : 17

On observe que notre conversion vers les entiers a bien supprim les chiffres aprs la virgule, sans effectuer aucun arrondi mais avec un effet de troncature. Il est noter quune conversion explicite peut galement se passer sans perte de donnes.

long
int Cast implicite short Cast explicite

Le schma ci-contre nous montre limbrication de quelques types de donns : Sbyte 2.2.2 Conversion dune chaine en nombre Ce type de conversion savre trs utile pour effectuer des oprations sur une chaine da caractres entre par lutilisateur.

Pour convertir une chane en nombre on va utiliser la fonction Parse prcde du type voulu. Par exemple si lon veut convertir x en entier on va faire int.Parse(x) si on le veut en dcimal on crira float.Parse(x) ou en long long.Parse(x) etc. Exemple :

Dotnet France Association

[Notions avances de C#]

[Date : 14/09/09]

//C# static void Main(string[] args) { //Deux chaines de caractres : string maChaineA = "42"; string maChaineB = "23"; //Conversion en entiers puis additon : int addition = int.Parse(maChaineA) + int.Parse(maChaineB); //Affichage et pause. Console.WriteLine(addition); Console.ReadLine(); }

65 La console nous renvoie 65 nous indiquant que la conversion et laddition sest bien droule. 2.2.3 Conversion dun nombre en chaine La conversion dun nombre vers une chaine de caractre seffectue grce la fonction ToString() que lon va placer la suite de notre variable convertir. Pour convertir notre nombre x on crira donc x.ToString() . Exemple :
//C# static void Main(string[] args) { int nombre = 256; //Conversion de nombre en chane: string ChaineNombre = nombre.ToString(); //Affichage et Pause: Console.WriteLine(ChaineNombre); Console.ReadLine(); }

La conversion se droule sans soucis et notre chaine saffiche : 256

2.2.4

Conversion en objet La conversion dune variable en objet est communment appele Boxing . Cette conversion nous permet de pouvoir prendre nimporte quel type de variable et la convertir pour pouvoir la manipuler comme un objet. Laction qui permet de retransformer lobjet en variable sappelle l Unboxing , littralement le sortir de la boite. Dotnet France Association

[Notions avances de C#] Exemple :

//C#

[Date : 14/09/09]

static void Main(string[] args) { int nombre = 12; //Boxing object MonObjet = nombre; //Unboxing int j = (int)MonObjet; }

2.3 Le type valeur et le type rfrence

En langage C#, il y a deux grands type de donnes : les donnes de types valeur et les donnes de type rfrence. Type valeur Tous les types Numriques Les caractres Les boolens Les structures Les numrations Type rfrence Les String Les tableaux Les classes Les dlgus

Exemple de type valeur :

//C# int monEntier = 42;

Exemple de type rfrence :

//C# int[] monTableau = { 2, 4, 6, 8, 10, 11, 12};

Les donnes de type valeur sont stocks dans la pile. Les donnes de type rfrence sont stock dans une partie de la mmoire appele le tas tandis quune rfrence pointant vers celle-ci se trouve dans la pile.

Dotnet France Association

10

[Notions avances de C#]

[Date : 14/09/09]

Le schma ci-dessous reprsente la mmoire de la pile et du tas :

LA PILE

LE TAS

Int monEntier = 42

Rfrence vers monTableau

Int*+ monTableau = ,-

...

Lgende

Type Valeur

Type Rfrence

Dotnet France Association

11

[Notions avances de C#]

[Date : 14/09/09]

3 Les structures de donnes

3.1 Les tableaux
3.1.1 Dclaration et initialisation Un tableau permet de stocker plusieurs variables de mme type la suite dans des cases contiges de la mmoire. Par exemple si nous dclarons un tableau dentiers de 7 cases, voici comment ils seront rangs dans la mmoire : Adresse de la case mmoire 1704 1705 1706 1707 1708 1709 1710 Valeur stocke 345 0 -25 7 42 23 1337

En langage C#, un tableau dentiers une seule dimension de 7 cases se dclare comme ceci :
//C# int[] monTableau = new int[7];

Linitialisation se droule comme ceci :

//C# int[] monTableau = new int[] { 345, 0, -25, 7, 42, 23, 1337 };

On peut simplifier la syntaxe :

//C# int[] monTableau = { 345, 0, -25, 7, 42, 23, 1337 };

On remarque que cette syntaxe ressemble la syntaxe dinitialisation de variable quelconque, la seule diffrence tant les crochets devant int indiquant que cest un tableau.

3.1.2

Parcourir un tableau une dimension On peut parcourir un tableau une dimension grce une boucle for. Cette boucle va afficher la valeur de la case pour chaque rang du tableau. Il ne faut pas oublier quun tableau commence au rang 0. Notre indice i va donc tre initialis zro et va tre incrmente chaque tour jusquau rang maximum. Afin dtre adaptable toutes les tailles de tableaux, nous utilisons la mthode GetLenght(indice) qui renvoie la taille du tableau pour la dimension entre parenthse.

Dotnet France Association

12

[Notions avances de C#]

[Date : 14/09/09]

//C# int i; for (i = 0; i < monTableau.GetLength(0); i++) { Console.WriteLine(monTableau[i,j]); }

On peut galement parcourir un tableau grce une boucle foreach comme ceci :
//C# foreach (int a in monTableau) { Console.WriteLine(a); }

3.1.3

Dimension multiples Ici nous allons dclarer un tableau 2 dimensions. Pour cela il faut rajouter une virgule entre les crochets indiquant que cest un tableau 2 dimensions (2 virgules pour un tableau 3 dimensions, 3 virgules pour un tableau 4 dimension etc.). Les dimensions sont entre accolades et celles-ci sont spares entre elles par une virgule, le tout tant lui aussi compris entre accolades.
//C# int[,] monTableau = { { 11, 12, 22, 33, 34, 44,45 } , { 21, 22, 23, 24, 25, 26,27 } };

3.1.4

Parcourir un tableau dimensions multiples Ici nous allons appliquer la mme mthode que pour un tableau une seule dimension, sauf que nous allons imbriquer les boucles for afin de balayer toutes les dimensions, ici en loccurrence 2.
//C# int j; //indice de la dimension verticale. int i; //indice de la dimension horizontale for (j = 0; j < monTableau.GetLength(0); j++) { for (i = 0; i < monTableau.GetLength(1); i++) { Console.Write("j={0} i={1} : ",j, i); Console.WriteLine(monTableau[j, i]); } }

Encore une fois nous pouvons faire la mme chose avec une boucle foreach assez simple en lui disant dafficher tout les lments prsents dans notre tableau : Dotnet France Association

13

[Notions avances de C#]

[Date : 14/09/09]

//C# foreach (int a in monTableau) { Console.WriteLine(a); }

3.2 Les Listes

Une liste peut tre une alternative intressante au tableau lorsque lon ne connait pas le nombre dlments stocker lavance. 3.2.1 Dclaration dune liste Pour crer une liste rien de plus simple : on cre un objet de type liste grce au mot cl List suivi du type dlments que lon souhaite stocker entre crochets :
//C# //Cration d'une liste d'entiers : List<int> MaListe1 = new List<int>(); //Cration d'une liste de chaines : List<string> MaListe2 = new List<string>(); //...

3.2.2

Ajouter des lments la liste A prsent notre liste est cr, on va lui ajouter des valeurs, un vrai jeu denfant puisque les objets de type liste possde une mthode Add() qui nous permet dajouter des lments entre parenthses. Dans lexemple suivant, on va rajouter notre liste les dix premiers nombres de la suite de Fibonacci :
//C# static void Main(string[] args) { List<int> Fibonacci = new List<int>(); Fibonacci.Add(0); Fibonacci.Add(1); Fibonacci.Add(1); Fibonacci.Add(2); Fibonacci.Add(3); Fibonacci.Add(5); Fibonacci.Add(8); Fibonacci.Add(13); Fibonacci.Add(21); Fibonacci.Add(34); }

Dotnet France Association

14

[Notions avances de C#] 3.2.3

[Date : 14/09/09]

Parcourir la liste A prsent nous allons parcourir notre liste et faire afficher chaque lment. Nous allons voir deux mthodes, une traditionnelle utilisant la boucle for et une seconde utilisant une boucle foreach.
3.2.3.1 //C# //Boucle "for" traditionelle : int i; for (i = 0; i < Fibonacci.Count(); i++) { Console.WriteLine(Fibonacci[i]); }

Avec une boucle for

3.2.3.2 //C#

Avec une boucle foreach

foreach (int element in Fibonacci) { Console.WriteLine(element); }

Cette boucle signifie Pour chaque lment dans la liste Fibonacci afficher notre lment. Le mot element a t choisi ici par dfaut, mais vous pouvez le remplacer par nimporte quel mot de votre choix, a condition dutiliser le mme dans la partie de code de la boucle.

3.2.4

Action sur la liste Les objets de type List possdent de nombreuses mthodes qui nous permettent de modifier notre liste ou bien dobtenir des informations sur les donnes stockes dans celles ci. Nous allons prsenter ici quelques exemples de mthodes utiles :
//C# //Mthodes modifiant notre liste : Fibonacci.Clear();//Supprime toute les valeures Fibonacci.Insert(place,nb);//Insre notre nombre la place desire Fibonacci.Reverse();//Range la liste dans le sens inverse. //Mthode descriptives : Fibonacci.Count();//Count retourne le nombre d'elements Fibonacci.Max();//Renvoie la valeur maximum de la liste Fibonacci.Min();//Renvoie la valeur maximum de la liste Fibonacci.Sum();//Renvoie la somme des lments Fibonacci.BinarySearch(nombre);//Renvoie l'indice de l'objet a trouver Fibonacci.Contains(nombre);//Renvoie vrai si le nobre est trouv

Dotnet France Association

15

[Notions avances de C#]

[Date : 14/09/09]

3.3 Les numrations

Une numration va nous permettre de crer notre propre type de variable afin den restreindre les valeurs possibles. Dans lexemple suivant, nous allons prendre lexemple des jours de la semaine. 3.3.1 Dclaration et initialisation Premirement, nous allons crer lnumration Jours grce au mot cl enum (Par convention, le nom dune numration est souvent crit en PascalCase).
//C# enum Jours { lun, mar, mer, jeu, ven, sam, dim };

3.3.2

Utiliser une numration Ici nous allons poursuivre lexemple en utilisant lnumration prcdemment dclare. Dans notre main nous allons crer la variable jourDeStage qui sera du type Jours :
//C# class Program { enum Jours { lun, mar, mer, jeu, ven, sam, dim }; static void Main(string[] args) { Jours jourDeStage; //variable de type "Jours" jourDeStage = Jours.jeu; Console.WriteLine(jourDeStage); Console.ReadLine(); } }

Vous avez surement remarqu le fait que la dclaration de Jours se faisait hors de la mthode main. Ce dtail est trs important puisque la dclaration dune numration ne peut seffectuer lintrieur dune fonction. Grce notre numration, nous voyons ci-dessous que lIntelliSense de Visual Studio nous propose les diffrents choix possibles pour notre variable jourDeStage .

Dotnet France Association

16

[Notions avances de C#]

[Date : 14/09/09]

Autre remarque importante, les membres dune numration peuvent galement tre appels avec leur numro:
//C# class Program { enum Jours { lun, mar, mer, jeu, ven, sam, dim }; static void Main(string[] args) { Jours jourDeStage; jourDeStage = (Jours)0; Console.WriteLine(jourDeStage); Console.ReadLine(); } }

Ici, (Jours)0 quivaut lundi, (Jours)1 quivaut mardi etc. Dernire remarque concernant les numrations, on peut forcer lattribution dun numro un membre.

Dotnet France Association

17

[Notions avances de C#]

[Date : 14/09/09]

Dans lexemple suivant nous allons attribuer la valeur 1 lundi, au lieu de 0, sa valeur par dfaut :
//C# class Program { enum Jours { lun=1, mar, mer, jeu, ven, sam, dim }; static void Main(string[] args) { Jours jourDeStage; jourDeStage = (Jours)3; //quivaut donc mercredi. Console.WriteLine(jourDeStage); Console.ReadLine(); } }

3.4 Les structures

Une structure va nous permettre de rassembler plusieurs types de donne dans un groupe plus grand. Une structure ressemble un peu une classe mais une structure est du type valeur la diffrence des classes qui sont de type rfrence.

3.4.1

Dclaration et initialisation Nous allons prendre lexemple dun coureur, un coureur a un nom, un prnom ainsi quun numro de dossard. Nous allons dons crer la structure Coureur qui va contenir ses champs. Nous dclarons la structure en dehors du main mais nous dclarons les diffrents champs en public afin que ceux-ci soient accessibles dans le main.
//C# struct Coureur { public string nom; public string prnom; public int Dossard; }

Dotnet France Association

18

[Notions avances de C#] 3.4.2

//C# class Program {

[Date : 14/09/09]

Utiliser une structure

struct Coureur { public string nom; public string prnom; public int Dossard; } static void Main(string[] args) { //Dclaration dune variable de type coureur : Coureur lucas; //On remplit les champs : lucas.nom = "Dupont"; lucas.prnom = "Lucas"; lucas.Dossard = 3; Console.WriteLine("Nom : " + lucas.nom); Console.WriteLine("Prnom : " + lucas.prnom); Console.WriteLine("Dossard : " + lucas.Dossard); Console.ReadLine(); } }

Ici aussi, lIntelliSense de Visual studio nous proposera les diffrents champs de la structure lors le la saisie du point devant Lucas .

Dotnet France Association

19

[Notions avances de C#]

[Date : 14/09/09]

4 Les mthodes et gestion des erreurs

4.1 Cration dune mthode
Une mthode peut tre assimile ce que lon appelle dans dautres langages une fonction . Une mthode cest une boite dans lequel on va mettre du code. Et pour appeler ce code, on appellera le nom de la boite ! Notre mthode va se placer lextrieur du main (notez que le main est en fait la mthode main , c'est--dire la mthode principale du programme, lance au dmarrage de celui-ci). Une mthode se prsente comme ceci :
//C#

TypeDeRetour NomDeMaMethode (type parametre) {

//Ici on met le code de la mthode return variableRetournee;

Nous allons expliquer un par un les termes ci-dessus : Le nom de la mthode : On va mettre ici le nom choisi pour notre mthode, nom qui nous servira par la suite appeler la fonction depuis le main. On choisit ci nimporte quel nom (de prfrence explicite) et on lcrira, par exemple, en PascalCase. Paramtres : La liste des paramtres est la liste des objets que notre mthode va prendre en entre. Entre les parenthses nous allons indiquer le nom de notre paramtre prcd de son type. Prenons lexemple dune mthode qui lve un nombre une puissance donnes. Cette mthode aura par exemple pour paramtre (int nombre, int puissance). Le type de retour : cest le type de la variable que lon veut renvoyer. Par exemple si on veut une mthode qui notre calcule le carr dun nombre quon lui envoie. Notre mthode se devra de retourner une variable de type int contenant le rsultat. Notre type de retour sera donc int . Le type de retour peut tre nimporte quel type tel que int long float string ou il peut tre void indiquant que la mthode ne renvoie aucune valeur. Attention une mthode void ne renvoie pas rien ! Elle renvoi quelque chose puisquelle renvoie void , ce qui signifie vide . Le retour : Lorsquon dfinit une mthode qui renvoie autre chose que void, linstruction return est essentielle au renvoi de la donne indique lors de la cration de la mthode. Si on cre une mthode qui renvoie un int , il y aura un return suivi dune variable de type int .

4.1.1

Exemple Nous allons crer une mthode qui calcule laire dun rectangle. Notre mthode doit prendre en paramtre une longueur et une largeur, et elle doit nous renvoyer laire en valeur entire. Dotnet France Association

20

[Notions avances de C#]

[Date : 14/09/09]

//C# static int calculAire (int longueur, int largeur) { int aire = longueur * largeur; return aire; }

Pour appeler notre fonction dans le main, rien de plus simple :

//C# //Notre mthode principale "Main" static void Main(string[] args) { int coteA = 3; int coteB = 7; //Appel de la mthode : Console.WriteLine(CalculAire(coteA, coteB)); Console.ReadLine(); }

4.1.2

Passage de paramtres Comme vu ci-dessus, les paramtres de la mthode se trouvent entre parenthses, juste aprs le nom de celle-ci. Nous allons voir quil existe deux moyens de passer des paramtres une mthode : par valeur et par rfrence. Par valeur Lorsque lon passe des paramtres par valeur, la variable aura toujours sa valeur initiale, il est impossible de la changer la racine. C'est--dire que mme si on change cette valeur lintrieur dune mthode, on ne modifiera pas la valeur attribue lors de linitialisation du paramtre, mais seulement une copie de cette valeur.
4.1.2.1

Pour expliquer cette notion assez complexe nous allons nous servir dun exemple.
//C#
//Notre mthode static int notre_methode(int x) { x = 7; return x; } //La mthode principale "Main" static void Main() { int a = 2; Console.WriteLine("Avant le passage de la mthode a = " + a); Console.WriteLine("Au passage de la mthode\ta = " + notre_methode(a)); Console.WriteLine("Aprs le passage de la mthode a = " + a); Console.ReadLine(); }

Dotnet France Association

21

[Notions avances de C#]

[Date : 14/09/09]

La console nous renvoie laffichage suivant : Avant le passage de la mthode a = 2 Au passage de la mthode a=7 Aprs le passage de la mthode a = 2

Au dbut du programme, notre entier a est initialis 2 et on le fait afficher par la console qui indique a=2 ce qui est tout fait normal. Puis on fait afficher le retour de notre mthode, celle-ci pris une copie de a et a remplac sa valeur par 7, la deuxime ligne est donc logique. Apres le passage de la mthode, on voit que la valeur de a dans le main na pas t modifi. Par rfrence Contrairement au type valeur, les paramtres passs en rfrence sont passs grce leur adresse mmoire ce qui permet aux mthodes de modifier directement la valeur la source. Pour passer un paramtre pas rfrence, il suffit dajouter le mot cl ref devant le paramtre, dans la fonction et dans lappel.
4.1.2.2

Nous allons reprendre exactement lexemple prcdent, mais cette fois ci avec un passage par rfrence pour permettre notre mthode de modifier la valeur de a .
//C#
//Notre mthode static int notre_methode(ref int x) { x = 7; return x; } //La mthode principale "Main" static void Main() { int a = 2; Console.WriteLine("Avant le passage de la mthode a = " + a); Console.WriteLine("Au passage de la mthode\ta = " + notre_methode(ref a)); Console.WriteLine("Aprs le passage de la mthode a = " + a); Console.ReadLine(); }

A prsent, lorsquon excute on obtient ceci : Avant le passage de la mthode a = 2 Au passage de la mthode a=7 Aprs le passage de la mthode a = 7

Et on remarque ici que notre mthode bien modifi la valeur de a .

Dotnet France Association

22

[Notions avances de C#] 4.1.3

[Date : 14/09/09]

Utilisation des mthodes Comme on a pu le voir dans lexemple prcdent, les mthodes sont vraiment utiles, elles nous permettent un important gain de temps et surtout elles sont dune grande efficacit. Dune part le fait quon puisse mettre du code part lintrieur de mthodes et de pouvoir le rutiliser nimporte quel moment n importe o dans le programme nous permet aussi une meilleure gestion du programme.

4.2 Gestion des erreurs

4.2.1 Importance de la gestion dexception Dans un programme sans gestion des exceptions, certaines actions imprvues peuvent compromettre la fiabilit de notre programme. En effet une simple tentative de division par zro, lcriture sur un fichier en lecture seule ou inexistant peut faire tout planter. Prenons un exemple de programme sans gestion dexception, dans lequel on demande lutilisateur dentrer son ge pour ensuite lafficher la console :
//C# static void Main(string[] args) { int age = 0; Console.WriteLine("Quel ge avez-vous?"); age = int.Parse(Console.ReadLine()); Console.WriteLine("Vous avez " + age + " ans !"); Console.ReadLine(); }

Dans ce programme aucune exception na t tablie. Cela veut donc dire que aucune erreur nest prise en charge. Si lutilisateur entre un nombre entier, le programme ne pose aucun problme et tout se passe comme prvu : Quel ge avez-vous ? 20 Vous avez donc 20 ans

Cependant si lutilisateur entre une chaine de caractres, quelque chose dinattendu se produit. Quel ge avez vous ? Vingt Le programme sarrte ici et Visual Studio nous affiche un message derreur :

Dotnet France Association

23

[Notions avances de C#]

[Date : 14/09/09]

On nous dit que "Lexception FormatException na pas t gre", ce qui nous indique quil ny a aucun contrle sur lentre effectue par lutilisateur. Afin de grer cette exception, nous allons utiliser les mots cls try et catch qui formeront deux bloc indispensables. Nous allons maintenant voir de plus prs ces mots cls, quoi servent-ils et comment les utiliser. 4.2.2 try Le mot try veut dire essayer , et cest dans ce bloc try que nous allons placer notre code risque. Le code plac dans ce bloc va sexcuter tant quaucune erreur ne vient perturber le droulement du programme.
//C# static void Main(string[] args) { int age = 0; Console.WriteLine("Quel ge avez-vous?"); try { age = int.Parse(Console.ReadLine()); Console.WriteLine("Vous avez donc " + age + " ans"); } Console.ReadLine(); }

Dotnet France Association

24

[Notions avances de C#]

[Date : 14/09/09]

Si on essaye de compiler cette tape l, Visual Studio nous indique ceci :

En effet il attend de nous un mot cl catch ou finally . Nous allons maintenant voir le mot cl catch. 4.2.3 catch Nous avons vu try et nous savons quil sert essayer du code. Si ce code ne marche pas, par exemple cause dune mauvaise entr de la part de linterlocuteur, que se passe-t- il? Cest ici quentre en jeu le mot cl catch. Si il y a une erreur, comme dans notre tout premier exemple, au lieu de faire planter le programme le catch va permettre de faire faire au programme une action, par exemple un message derreur, qui va indiquer linterlocuteur la nature de son erreur. Le catch suit obligatoirement un try . Plaons maintenant un message derreur si linterlocuteur nentre pas un nombre entier :
//C# static void Main(string[] args) { int age = 0; Console.WriteLine("Quel ge avez-vous?"); //code risque try { age = int.Parse(Console.ReadLine()); Console.WriteLine("Vous avez donc " + age + " ans"); } //Le code plac ici s'execute si une exception est leve catch { Console.WriteLine("Dsol vous devez crire un nombre!"); } Console.ReadLine(); }

Si on essaie prsent dcrire une chaine de caractre voici le message qui sera renvoy : Quel ge avez-vous ? Vingt Dsol vous devez crire un nombre ! Et bien sur le programme ne plante pas. Nous venons de faire une gestion dexception. Bien que tout cela marche, il reste un mot cl voir : finally. Dotnet France Association

25

[Notions avances de C#] 4.2.4

[Date : 14/09/09]

Finally Le bloc finally contient du code qui sera toujours excut, quil y est une exception leve ou non. Ce bloc est facultatif, il sutilise comme ceci :
//C# static void Main(string[] args) { int age = 0; Console.WriteLine("Quel ge avez-vous?"); //code risque try { age = int.Parse(Console.ReadLine()); Console.WriteLine("Vous avez donc " + age + " ans"); } //Le code plac ici s'execute si une exception est leve catch { Console.WriteLine("Dsol vous devez crire un nombre!"); } finally { Console.WriteLine("\n*** Merci de votre visite ***"); } Console.ReadLine(); }

Maintenant si non essayons les deux cas de figure, le finally sera toujours excut. Sans exception : Quel ge avez-vous ? 20 Vous avez donc 20 ans *** Merci de votre visite *** Avec exception : Quel ge avez-vous ? Vingt Dsol vous devez crire un nombre ! *** Merci de votre visite ***

Dotnet France Association

26

[Notions avances de C#] 4.2.5

[Date : 14/09/09]

Exception multiples Dans le programme prcdant, le mme bloc catch attrapait toutes les exceptions. Donc notre programme renvoyait le mme message derreur quel que soit la nature de lerreur. Il existe un moyen en C# de faire des exceptions multiples, pour cela il suffit de placer plusieurs blocs catch en leur associant lexception approprie :
//C# static void Main(string[] args) { try { } catch (Exception) { } catch (Exception) { } }

On peut bien entendu mettre autant de catch que lon souhaite. Une diffrence avec les exceptions multiples cest que logiquement chaque catch a maintenant une fonction. Cette fonction va tre dfinie entre parenthses juste aprs sa dclaration (ici dans lexemple Exception). Visual Studio nous aidera bien trouver lexception que nous cherchons en nous proposant la totalit des exception dj prdfinies :

Dotnet France Association

27

[Notions avances de C#]

[Date : 14/09/09]

Maintenant quon a vu son fonctionnement, on va faire un exemple comprenant trois catch grant trois exceptions. Nous allons prendre pour exemple une division, avec trois restrictions : que les nombres soient positifs, pas de divisions par zro et pas de chaine de caractres. A chaque bloc catch, nous associerons lexception associe comme ceci :
//C# static void Main(string[] args) { Console.WriteLine("Nous allons faire une division avec des nombres positifs :"); Console.Write("\nEntrez un premier nombre : "); try { uint a = uint.Parse(Console.ReadLine()); Console.Write("Entrez un deuxieme nombre : "); uint b = uint.Parse(Console.ReadLine()); uint c = a / b; Console.WriteLine("Le rsultat de la division est " + c); } catch (OverflowException) //type uint ne peut tre ngatif { Console.WriteLine("Entrez un nombre positif s'il vous plait"); } catch (DivideByZeroException) //on ne peut diviser par zro { Console.WriteLine("Dsol vous ne pouvez pas diviser par zero"); } catch (FormatException) //chaine de caractres non autorises car uint { Console.WriteLine("Les chaine de caractres ne sont pas autorises"); } finally { Console.WriteLine("\n*** Au revoir! ***"); } Console.ReadLine(); }

Dotnet France Association

28

[Notions avances de C#]

[Date : 14/09/09]

5 Conclusion
Ce chapitre complte le chapitre prcdant concernant les notions fondamentales du langage C#. Nous avons abord des concepts avancs en passant en revue les notions savoir tel que le type var , les types valeur, type rfrence les conversions de donnes. Nous avons vu diffrentes structures de donnes telles que les tableaux, les listes, les structures et les numrations. Nous avons termin ce chapitre en introduisant la notion de mthode puis nous nous sommes intresss la gestion des exceptions. Le prochain chapitre sera un chapitre entirement ddi aux diffrents concepts de la programmation objet.

Dotnet France Association