Programmation C sharp/Les fonctions
Une fonction étant toujours déclarée dans une classe, elles sont plutôt appelées « méthodes ».
Déclarer une méthode.
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"
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). 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é codice_1. L'instruction codice_1 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 codice_1 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 appellera 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.
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 codice_4 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 ( codice_5 ).
Par défaut, il s'agit de l'objet codice_6 (objet courant).
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 :
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.
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.
Un paramètre codice_7 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é codice_7 à 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.
Un paramètre codice_9 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é codice_9 à 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
Méthode COM : ref optionnel.
L'appel à une méthode d'interface COM utilisant un paramètre codice_9 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é codice_9 :
Increment(0);
Ce qui est équivalent à :
int x = 0;
Increment(ref x);
Un paramètre codice_9 est en général modifié par la méthode appelée. Ne pas utilier le mot clé codice_9 lors de l'appel signifie que la nouvelle valeur retournée par la méthode est ignorée.
Nombre variable de paramètres.
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é codice_15 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é codice_15, 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 } );
Paramètres optionnels.
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.
Paramètres nommés.
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 codice_17 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 deux-points afin de spécifier la valeur d’un argument, nomduparametre: valeur.
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 ));
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 :
 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;