Support de formation d’Introduction à Visual C# et Visual Studio 2008

Sections

 [masquer]

1  Déclarer une méthode

2  Appeler une méthode

3  Passage de paramètres à une méthode_o        3.1Passage par valeur_o       3.2Paramètre out_o           3.3Paramètre ref

§             3.3.1C# 4.0Méthode COM: ref optionnel_o        3.4Nombre variable de paramètres

4  Surcharge de méthode

La syntaxe de déclaration est la suivante :

Où accès est optionnel et définit le mode d'accès (public, privé ou protégé), le type de méthode (statique ou d'instance). Voirle chapitre sur les classes.

type_retour spécifie le type de la valeur retournée par la fonction. Ce type peut être void (vide) pour indiquer que la fonction ne retourne aucune valeur.

La fonction retourne une valeur en utilisant le mot clé return. L'instruction return interrompt l'exécution de la fonction, retourne la valeur de l'expression qui suit, et l'exécution du code ayant appelé la fonction se poursuit.

La syntaxe est :

Si la fonction ne retourne rien, l'instruction return n'est pas obligatoire, mais si elle est utilisée, aucune expression ne doit être spécifiée. Si la fonction ne retourne rien on appelera cette fonction une procédure

Exemple :

// Fonction qui retourne la concaténation

// de la chaîne de caractères a à la chaîne de caractères b string Concatener(string a, string b)

{

return a+b;

}

[modifier]Appeler une méthode

L'appel à une méthode se fait en spécifiant son nom, suivi des arguments entre parenthèses :

Si la fonction retourne une valeur, l'appel à celle-ci peut être utilisé dans une expression.

Exemple :

string c = Concatener ( "abc" , "def" ); // c vaut "abcdef"

Dans cet exemple, la méthode appelée est nommée Concatener car située dans la même classe que l'appel. Cependant, toute méthode s'applique à un objet. Celui-ci doit être spécifié avant le nom de la fonction, et séparé par le caractère point ( . ). Par défaut, il s'agit de l'objet this (objet courant).

[modifier]Passage de paramètres à une méthode

Les paramètres passés à une méthode peuvent être passés de trois manière différentes :

§  un paramètre référençant une variable pour y mettre une valeur de retour : paramètre out,

§  un paramètre référençant une variable pour transmettre une information et y mettre une valeur de retour : paramètre ref.

[modifier]Passage par valeur

Il s'agit d'un paramètre servant à transmettre une information à la méthode appelée, comme dans les exemples précédents. Si la méthode modifie sa valeur, la modification est locale à la fonction uniquement. Un paramètre normal n'est précédé d'aucun mot-clé particulier.

Exemple :

private void methodeTest(int nombre)

{

Console.WriteLine("fonctionTest : le nombre vaut " + nombre);     nombre = 100;

Console.WriteLine("fonctionTest : le nombre vaut " + nombre);

} private void testAppel()

{ int n = 5;

Console.WriteLine("testAppel : le nombre vaut " + n);

methodeTest(n); // Appel à la méthode

Console.WriteLine("testAppel : le nombre vaut " + n);

// On peut passer une expression ou une constante methodeTest( 25 + 5 ); // Appel à la méthode }

Ce programme affiche :

[modifier]Paramètre out

Un paramètre out ne sert à la fonction qu'à retourner une valeur. L'argument transmis doit référencer une variable ou un élément de tableau. Ce paramètre est précédé du mot-clé out à la fois lors de sa déclaration, et lors de l'appel à la méthode.

La variable référencée n'a pas besoin d'être initialisée auparavant. La fonction doit obligatoirement affecter une valeur à la variable référencée.

Exemple :

private void methodeTest(out int resultat)

{

//Console.WriteLine("fonctionTest : le nombre vaut " + resultat); resultat = 100;

//Console.WriteLine("fonctionTest : le nombre vaut " + resultat);

} private void testAppel()

Console.WriteLine("testAppel : le nombre vaut " + n);

// On ne peut pas passer une expression ou une constante

//methodeTest( 25 + 5 ); // <- erreur de compilation }

Ce programme affiche :

[modifier]Paramètre ref

Un paramètre ref est une combinaison des deux types de paramètres précédents. L'argument transmis doit référencer une variable ou un élément de tableau qui doit être initialisé auparavant. Ce paramètre est précédé du mot-clé ref à la fois lors de sa déclaration, et lors de l'appel à la méthode.

La méthode n'est pas obligée de modifier la valeur contenue dans la variable référencée.

Exemple :

private void methodeTest(ref int resultat)

{

Console.WriteLine("fonctionTest : le nombre vaut " + resultat);     resultat = 100;

Console.WriteLine("fonctionTest : le nombre vaut " + resultat);

}

private void testAppel()

{

int n = 5;

Console.WriteLine("testAppel : le nombre vaut " + n);

methodeTest(ref n); // Appel à la méthode

Console.WriteLine("testAppel : le nombre vaut " + n);

// On ne peut pas passer une expression ou une constante

//methodeTest( 25 + 5 ); // <- erreur de compilation }

Ce programme affiche :

[modifier]C# 4.0 Méthode COM : ref optionnel

L'appel à une méthode d'interface COM utilisant un paramètre ref peut ne pas utiliser explicitement de variable.

Exemple :

La méthode COM suivante : void Increment(ref int x);

Peut être appelée sans le mot clé ref :

Increment(0);

Ce qui est équivalent à :

int x = 0; Increment(ref x);

Un paramètre ref est en général modifié par la méthode appelée. Ne pas utilier le mot clé ref lors de l'appel signifie que la nouvelle valeur retournée par la méthode est ignorée.

string message = String.Format("A={0} et B={1}", a, b);

Ce genre de méthode possède un nombre de paramètres obligatoires, comme une méthode normale, suivis d'un nombre variable de paramètres (voire aucun). Ces paramètres en nombre variable sont en fait transmis sous la forme d'untableau.

Une telle méthode utilise le mot clé params pour le dernier paramètre qui doit être un tableau.

Exemples de méthodes :

public string MessageDeLog(string format, params object[] parametres)

{ return "LOG: "+String.Format(format, parametres);

} public double Moyenne(params double[] nombres)

{ double sum=0;     if (nombres.Length==0) return 0;

foreach(double d in nombres)         sum += d;

return sum / nombres.Length; }

Pour le paramètre marqué params, il est possible de transmettre soit une liste d'argument, soit un tableau contenant ces arguments.

Exemples d'appels :

double a = Moyenne(3.0, 2.0, 5.14, 8.22, 6.37); // Equivaut à : double b = Moyenne( new double[]{ 3.0, 2.0, 5.14, 8.22, 6.37 } ); [modifier]Surcharge de méthode

Une méthode peut être surchargée (overload en anglais), c'est à dire qu'il peut exister au sein de la même classe plusieurs méthodes portant le même nom, à condition qu'elles soient différenciables par leur signature. La signature d'une méthode correspond aux types et nombre de paramètres acceptés par celle-ci.

Exemple :

public int Ajouter ( int valeur1, int valeur2 )

{ return valeur1 + valeur2;

}

public double Ajouter ( double valeur1, double valeur2 )

{

return valeur1 + valeur2; }

Le compilateur détermine la méthode à appeler en fonction du type des arguments passés à la méthode.

Exemple :

Console.WriteLine("(entiers)  2 + 5 = " + Ajouter( 2, 5 ));

Console.WriteLine("(réels)  2.0 + 5.0 = " + Ajouter( 2.0, 5.0 ));

Exemple :

Ce code contient une erreur volontaire !

Les deux méthodes ont la même signature.

public double Longueur ( string chaine )

{ return (double) chaine.Length;

} public int Longueur ( string chaine )

{  return (int) chaine.Length;

}

Propriétés et indexeurs

[modifier]Les propriétés

Une propriété est une valeur qui peut être lue ou modifiée, comme une variable. Ces deux opérations sont en fait réalisées par les accesseurs get et set. Si l'un de ces deux accesseurs est manquant, la propriété sera alors soit en lecture seule, soit en écriture seule.

[modifier]Syntaxe

Le code contenu dans chaque bloc est le même que celui que l'on placerait pour implémenter les méthodes suivantes :

[modifier]Exemple

private string _message; public string Message

{ get     {         return _message;

}     set

{

_message = value;

}

}

Utilisation :

Message = "Test de la propriété" ; // <- accesseur set

Console.WriteLine( Message ); // <- accesseur get

Message += " et message ajouté"; // <- accesseurs get et set

§  type get_Nom_propriété()

§  void set_Nom_propriété(type value)

La classe ne peut donc avoir de méthodes portant l'une de ces deux signatures.

[modifier]Les indexeurs

Un indexeur est une propriété spéciale qui permet d'utiliser une instance de la classe comme untableau, en utilisant les crochets.

[modifier]Syntaxe

Type_élément

Type de chaque élément du tableau virtuel.

Type_index

Type de l'indice spécifié entre crochets. index

Variable contenant la valeur de l'indice de l'élément lu ou modifié.

L'index peut avoir un autre type que int. C'est le cas des tables de hashage de l'espace de nom System.Collections.

[modifier]Exemple

public class TableauVirtuel

{

public string this[int index] 

{

// lecture seule car pas d'accesseur set get         {

return "Elément"+index.ToString();

}

}

}

TableauVirtuel tab=new TableauVirtuel();

Console.WriteLine("tab[15] = " + tab[15] );

// affiche Elément15

Héritage de classes

Uneclassepeut hériter d'une autre, c'est à dire posséder les mêmes méthodes et attributs que celle-ci et en avoir des supplémentaires. Cette nouvelle classe est appelée « classe fille » ou « sous-classe ».

Elle hérite d'une « classe mère » ou « classe de base » ou « super-classe ».

Ces spécificités de la sous-classe sont les seules qui ont besoin d'être définies dans celle-ci. Les autres fonctionnalités sont héritées de la super-classe.

[modifier]Syntaxe

La relation d'héritage est définie à la déclaration de la classe par le symbole deux-points suivi du nom de la super-classe.

Exemple de super-classe :

public class Vehicule

{ int roues, places, kilometrage;     public Vehicule()

{

}

}

Exemple de sous-classe :

public class Automobile : Vehicule

{

string couleur;     public Automobile()

{

} }

[modifier]Constructeurs

Le constructeur de la sous-classe appelle toujours celui de la classe de base, implicitement ou explicitement. Si rien n'est spécifié, le compilateur génère un appel implicite au constructeur de la classe de base ne comportant aucun paramètre. C'est pourquoi ce constructeur est nommé « constructeur par défaut ».

Si la classe de base ne possède aucun constructeur par défaut, ou si un autre serait plus approprié, il est possible de spécifier explicitement le constructeur à appeler. Le mot-clé base désigne la classe de base.

Exemple :

public class Vehicule

{ int roues, places, kilometrage;

// Constructeur "protégé" : l'accès est limité// à cette classe et aux sous-classes     protected Vehicule(int roues,int places)

{         this.roues = roues;         this.places = places;

}

}

public class Automobile : Vehicule

{

string couleur;     public Automobile(string couleur)

: base( 4, 5 ) // appel au constructeur de Vehicule

// 4 roues et 5 places

{

this.couleur = couleur;

}

// mais permet d'illustrer qu'il est possible d'appeler un

// autre constructeur de la même classe public Automobile()

: this( "indéfinie" ) // couleur indéfinie par défaut

{

}

}

[modifier]Référence d'instance

Une référence à une instance de la sous-classe peut être stockée par une référence du même type :

Automobile voiture = new Automobile();

Il est également possible d'utiliser une référence du type de la classe de base :

Vehicule voiture = new Automobile();

[modifier]Surcharge de méthodes et de propriétés

Dans cette section, la surcharge de propriétés est similaire à la surcharge de méthodes. Ce paragraphe discutera de la surcharge de méthodes, mais tout ceci s'applique également aux propriétés.

[modifier]Surcharge sans polymorphisme

La surcharge d'une méthode consiste à créer une méthode dans une sous-classe ayant le même nom et les mêmes types d'arguments (la même signature) qu'une méthode de la classe de base, afin de modifier son comportement.

Exemple :

public class Vehicule

{ private int poids;

public Vehicule(int poids)     { this.poids = poids; }

public string Description()

{         return "Véhicule de "+poids+" tonnes";

} } public class Automobile : Vehicule

{ private string couleur;

public Automobile(int poids,string couleur)

: base(poids)

{ this.couleur = couleur; }

// méthode surchargée     public string Description()

{         return base.Description()+" de couleur "+couleur;

}

}

Cependant, le compilateur génère un avertissement (warning CS0108) dans la classe dérivée. Il faut spécifier que l'on surcharge une méthode, en utilisant le mot clé new :

public class Automobile : Vehicule

{ private string couleur;

public Automobile(int poids,string couleur)

: base(poids)

{ this.couleur = couleur; }

// méthode surchargée     public new string Description()

}

}

Utilisation :

Automobile voiture = new Automobile(3, "rouge");

Console.WriteLine( voiture.Description() );

// affiche : Véhicule de 3 tonnes de couleur rouge

Par contre, si on utilise une référence à la classe de base Vehicule, la méthode appelée sera celle de la classe de base :

Vehicule vehicule = new Automobile(3, "rouge");

Console.WriteLine( vehicule.Description() );

// affiche : Véhicule de 3 tonnes

Une conversion de la référence vers la classe réelle de l'objet permet d'appeler la méthode surchargée :

Console.WriteLine( ((Automobile)vehicule).Description() );

// affiche : Véhicule de 3 tonnes de couleur rouge

Cet exemple n'utilise donc pas le polymorphisme, c'est à dire que pour appeler la méthode Description, le compilateur se base sur le type de la référence plutôt que sur le type réel de l'objet référencé.

[modifier]Surcharge avec polymorphisme

Le polymorphisme permet d'utiliser le type réel de l'objet référencé plutôt que le type de la référence pour déterminer la méthode, la propriété ou l'indexeur à utiliser. Pour cela, il faut utiliser le mot clévirtual dans la déclaration de la méthode de la classe de base.

Exemple :

public class Vehicule

{ private int poids;       public Vehicule(int poids)     { this.poids = poids; }

public virtual string Description()

{         return "Véhicule de "+poids+" tonnes";

}

}

Et il faut utiliser le mot clé override dans la classe dérivée :

public class Automobile : Vehicule

{ private string couleur;

public Automobile(int poids,string couleur)

: base(poids)

{ this.couleur = couleur; }

// méthode surchargée     public override string Description()

{         return base.Description()+" de couleur "+couleur;

}

}

Utilisation :

Vehicule vehicule = new Automobile(3, "rouge");

Console.WriteLine( vehicule.Description() );

// affiche : Véhicule de 3 tonnes de couleur rouge

[modifier]Classe sans héritière

Le mot-clé sealed empêche la création de classes dérivées. Cette fonctionnalité est également utile pour les classes ne déclarant que des membres statiques.

Syntaxe:

Exemple:

public sealed class Ferrari : Automobile

{ private int consommation;     public Ferrari(int litre_par_km)         : base(5100, "Rouge")     { consommation = litre_par_km; }

}

Ce type de classe ne peut avoir de méthodes abstraites (abstract) ou de membres protégés

(protected) car aucune classe dérivée ne pourra être créée pour les implémenter / y accéder.

Classe abstraite

Une classe abstraite possède au moins uneméthodeabstraite ou unepropriétéabstraite, c'est à dire ne comportant aucune implémentation (pas de code). Une telle classe ne peut être instanciée avec l'opérateur new. Il faut utiliser une sous-classe implémentant les méthodes abstraites de la classe de base.

[modifier]Syntaxe

Le mot clé abstract doit précéder la classe abstraite et toutes les méthodes abstraites.

Exemple :

// Classe abstraite gérant un ensemble d'objets public abstract class Ensemble

{ public bool AjouterSiNeContientPas(object o)     {

if ( ! Contient(o) )             Ajouter(o);

}       public bool RetirerSiContient(object o)

{

    if ( Contient(o) )             Retirer(o);

}

[modifier]Implémenter les méthodes abstraites

La classe implémentant les méthodes abstraites de la classe de base doit utiliser le mot clé override, car les méthodes abstraites sont implicitement virtuelles également :

public class EnsembleTableau : Ensemble

{ private object[] elements = new object[0];

public override bool Contient(object o)

{

// recherche de l'objet         for(int i = 0  ; i < elements.Length ; i++)             if (elements[i] == o) return true; // objet trouvé

// fin de la boucle sans avoir trouvé l'objet return false;

}       protected override void Ajouter(object o)

{

//

}       protected override void Retirer(object o)

{

//

}

}

La classe peut ne pas implémenter toutes les méthodes abstraites de la classe de base. Dans ce cas elle est également abstraite, et laisse le soin à ses sous-classes d'implémenter les méthodes abstraites restantes.

[modifier]Propriétés abstraites

Il est également possible de déclarer des propriétés abstraites.

Exemple :

public abstract class Ensemble

{ public abstract int nombre { get; }     public abstract string nom { get; set; }

} public class EnsembleTableau : Ensemble

{ private string nom_ensemble = null;     private object[] elements = new object[0];

public override int nombre

{         get { return elements.Count; }

}       public override string nom

{         get { return nom_ensemble ; }         set { nom_ensemble = value ; }

} }

[modifier]Mode d'accès

Puisque les méthodes et propriétés abstraites doivent être implémentées par les sous-classes, il n'est pas possible de les déclarer avec le mot clé private, ou d'utiliser le mot clé sealed avec la classe.

De plus les méthodes et propriétés abstraites ne peuvent être statiques.

[modifier]Attraper une exception

Un gestionnaire d'exception attrape uneclassed'exception particulière et gère le cas d'erreur correspondant. Ce gestionnaire encadre les instructions à gérer pouvant lancer une exception.

La syntaxe est la suivante :

Le bloc try est suivi d'un nombre quelconque de bloc catch (éventuellement aucun) attrapant différents types d'exception, et éventuellement d'un bloc finally qui sera toujours exécuté quoi qu'il se passe.

Exemple :

try

{

Console.Write("Entrez un nombre : ");     int n = int.Parse( Console.ReadLine() );     Console.WriteLine("  100/nombre = "+( 100/n ));

} catch ( DivideByZeroException dbzex )

{

Console.Error.WriteLine("  Division par zéro");

} catch ( Exception ex )

{

Console.Error.WriteLine(

"  Une autre exception a eu lieu : "+ex.Message);

} finally

{

Console.WriteLine(

"  Quel que soit le résultat, ceci est affiché");

}

[modifier]Libérer des ressources

Un bloc finally est utile pour libérer des ressources à la fin d'un traitement, qu'une erreur ait eu lieu ou non.

Exemple :

Bitmap bm; try {     bm=new Bitmap(100,100);     } finally {

bm.Dispose(); // libérer les ressources }

Cependant, les classes implémentant l'interfaceIDisposable ont une méthode Dispose(), et peuvent être utilisées avec le mot clé using :

using( Bitmap bm = new Bitmap(100,100) )  // <- objet IDisposable

{

[modifier]Lancer une exception

En cas d'erreur dans une méthode d'un programme (arguments invalides, ), il est possible de lancer une exception en utilisant le mot clé throw.

La syntaxe est la suivante :

Où objet_exception est une instance de la classe Exception ou de l'une de ses sous-classes.

En général, l'objet exception est alloué en même temps qu'il est lancé :

La pile d'appel est enregistrée dans l'objet exception au moment où il est créé.

Dans un gestionnaire d'exceptions, il est possible de relancer l'exception attrapée en utilisant l'instruction throw sans argument. Ce qui est utile quand le gestionnaire ne gère que partiellement l'erreur qui devra être totalement traitée par un autre gestionnaire d'exceptions.

Exemple :

try

{

Console.Write("Entrez un nombre : ");     int n = int.Parse( Console.ReadLine() );

Console.WriteLine("  100/nombre = "+( 100/nombre ));

} catch ( DivideByZeroException dbzex )

{

Console.Error.WriteLine("  Division par zéro");     throw; // relance la même exception }

[modifier]Créer une classe d'exception

Lancer une exception signale une erreur particulière. Si aucuneclassed'exception ne convient ou n'est suffisamment précise, ou si l'exception doit comporter des informations supplémentaires, il est possible de créer une nouvelle classe d'exception.

Pour cela, il fautdériver la classeException ou l'une de ses sous-classes. Par convention, toutes ces sous-classes ont un nom se terminant par Exception.

Exemple :

public class ErreurDeScriptException : Exception

{

// Attributs private int ligne,colonne;     private string fichier;

: base(message) // appel au constructeur de la classe Exception

{         this.fichier = fichier;         this.ligne = ligne;         this.colonne = colonne;

}

}

Ensuite, cette classe peut être utilisée comme n'importe quelle autre classe d'exception :

if ( arg==null )     throw new ErreurDeScriptException(

"Un argument est nécessaire", fichier_script, 10 , 5);

Surcharge des opérateurs

La surcharge des opérateurs permet d'utiliser les opérateurs sur d'autres types (des classes) que les types simples.

Certains opérateurs ne sont pas surchargeables. Il s'agit des opérateurs en rouge dansle tableau duchapitre.

[modifier]Syntaxe

L'opérateur surdéfini doit toujours être statique et public, sinon le compilateur génère une erreur.

L'opérateur est déclaré en utilisant le mot clé operator suivi de l'opérateur surdéfini.

Exemple :

public class NombreComplexe

{ private double n_reel, n_imag;       public NombreComplexe() {}

public NombreComplexe(double r,double i)

{ this.n_reel = r; this.n_imag = i; }

public static NombreComplexe operator + (NombreComplexe a,NombreComplexe b)

{         return new NombreComplexe

( a.n_reel + b.n_reel , a.n_imag + b.n_imag );

} }

[modifier]Implémentation par paire

La surdéfinition de certains opérateurs exige également la surdéfinition d'un autre. Ces opérateurs doivent donc être surdéfinis par paire.

Il s'agit des paires d'opérateurs suivantes :

§  operator < et operator >

§  operator <= et operator >=

§  operator == et operator !=

En général, l'un des deux peut être défini en fonction de l'autre :

§  operator < en fonction de operator >     public static bool operator < (NombreComplexe a,NombreComplexe b)

{

§  operator > en fonction de operator <     public static bool operator > (NombreComplexe a,NombreComplexe b)

{

return b < a;     }

§  operator <= en fonction de operator >=     public static bool operator <= (NombreComplexe a,NombreComplexe b)

{

return b >= a;     }

§  operator >= en fonction de operator <=

public static bool operator >= (NombreComplexe a,NombreComplexe b)

{         return b <= a;     }

§  operator == en fonction de operator !=     public static bool operator == (NombreComplexe a,NombreComplexe b)

{         return !( a != b );     }

§  operator != en fonction de operator ==     public static bool operator != (NombreComplexe a,NombreComplexe b)

{         return !( a == b );

}

[modifier]Opérateurs de conversions

Les opérateurs de conversions sont déclarés dans une classe C en ajoutant une méthode utilisant la syntaxe suivante :

où l'un des deux types est la classe C : convertir un objet de classe C vers type_cible ou un objet de type type_source vers classe C.

Exemple:

public class Fraction

{

private int numerateur, denominateur;

public Fraction(int n, int d)

{ this.numerateur = n; this.denominateur = d; }

public double GetValue()

{ return this.numerateur / this.denominateur; }

public static implicit operator double(Fraction f)

{         return f.GetValue();

}  

public static implicit operator Fraction(int entier)

{         return new Fraction(entier, 1);

}

}

Fraction f=new Fraction(1,3); double d = f; // -> 0.33333

Fraction f; f = 5; // -> 5 / 1

[modifier]Explicite/Implicite

L'opérateur de conversion doit être déclaré avec l'un des mots-clés implicit ou explicit pour qu'il soit utilisé respectivement implicitement ou explicitement.

Exemple:

public class Fraction

public Fraction(int n, int d)

{ this.numerateur = n; this.denominateur = d; }

public double GetValue()

{ return this.numerateur / this.denominateur; }

public static explicit operator Fraction(int entier)

{         return new Fraction(entier, 1);

}

}

Fraction f;

f = (Fraction)5; // conversion explicite -> 5 / 1