Programmation C sharp/Les fonctions

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche
Programmation C#
Programmation C#
Sommaire
Le langage
Programmation avancée
API .Net
Ressources
Modifier ce modèle

Une fonction étant toujours déclarée dans une classe, elles sont plutôt appelées « méthodes ».

Déclarer une méthode[modifier | modifier le wikicode]

Une méthode possède un nom, une liste de paramètres, et un type de retour.

La syntaxe de déclaration est la suivante :

[accès] type_retour nom_méthode ( type argument, ... )
{
    instructions
}

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). Voir le 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 :

return expression;

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;
}

Appeler une méthode[modifier | modifier le wikicode]

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

nom_methode ( expression, ... )

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).

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

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

  • un paramètre en lecture seule (transmission d'information) : passage par valeur,
  • 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.

Le choix dépend grandement de la taille et de la portée de la variable à transmettre, car le passage par valeur ou par référence n'a pas le même impact en performances.

Passage par valeur[modifier | modifier le wikicode]

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);   // la valeur de 'n' n'a été modifiée que dans la fonction (n vaut toujours 5)

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

Ce programme affiche :

testAppel : le nombre vaut 5
fonctionTest : le nombre vaut 5
fonctionTest : le nombre vaut 100
testAppel : le nombre vaut 5
fonctionTest : le nombre vaut 30
fonctionTest : le nombre vaut 100

Paramètre out[modifier | modifier le wikicode]

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()
{
    int n;              // Il n'est pas utile d'initialiser la variable qui le sera par la fonction, n aura une valeur aléatoire.
    methodeTest(out 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 :

testAppel : le nombre vaut 100

Paramètre ref[modifier | modifier le wikicode]

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 :

testAppel : le nombre vaut 5
fonctionTest : le nombre vaut 5
fonctionTest : le nombre vaut 100
testAppel : le nombre vaut 100

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

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.

Nombre variable de paramètres[modifier | modifier le wikicode]

Une méthode peut posséder un nombre variable de paramètres, comme, par exemple, la méthode statique Format de la classe String :

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'un tableau .

Une telle méthode utilise le mot clé params pour le dernier paramètre qui doit être un tableau (à une seule dimension). Les arguments transmis ainsi, peuvent être variables en nombres mais aussi en type.

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 } );

C# 4.0 Paramètres optionnels[modifier | modifier le wikicode]

Les paramètres peuvent être optionnels lors de l'appel à la méthode lorsque ceux-ci sont définis avec une valeur par défaut.

Exemple :

public void afficher(string texte, int largeur = 80, bool afficher_sommaire = false)
{ /* ... */ }

Cette méthode peut être appelée de différentes façons :

afficher("Ceci est un exemple", 70, true);
afficher("Ceci est un exemple", 70);  // 70,false
afficher("Ceci est un exemple");      // 80,false

Cependant, l'appel suivant ne compile pas :

afficher("Ceci est un exemple", true); // largeur = true  incorrect

La solution est d'utiliser les paramètres nommés.

C# 4.0 Paramètres nommés[modifier | modifier le wikicode]

Lors de l'appel à une méthode, les paramètres peuvent être nommés afin de pouvoir les passer dans un ordre quelconque et permettre également de ne pas fournir certains paramètres optionnels.

La méthode afficher de l'exemple de la section précédente peut donc être appelée de cette façon :

afficher("Ceci est un exemple", afficher_sommaire: true);
afficher(afficher_sommaire: true, texte: "Ceci est un exemple");

Notez la syntaxe (avec :) afin de spécifier la valeur d’un argument, nomduparametre: valeur.

Surcharge de méthode[modifier | modifier le wikicode]

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 ));

Le type de retour ne fait pas partie de la signature, car la valeur retournée par une méthode appelée peut être ignorée. Si deux méthodes portent le même nom et ont la même signature, le compilateur génère une erreur.

Exemple :

Avertissement 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;
}