Les paramètres des fonctions

Dans le chapitre précédent, nous avons eu un aperçu des fonctions. Nous avons également vu brièvement les paramètres. Les paramètres sont très simple et évident à utiliser. Néanmoins il existe des astuces qui peuvent les rendre beaucoup plus puissant.

Les deux premières choses que nous allons voir sont les modificateurs "ref" et "out". C# fais partis des langages distinguant la manière dont les paramètres sont passés à une fonction : par valeur et par référence. La manière par défaut utilisé en C# est le passage par valeur. Ce qui veut dire que lorsque l'on utilise une variable lors de l'appel d'une fonction, une copie de cette variable est envoyé. Cela veut également dire que si cette variable est modifiée dans la fonction même, l'original qui a été utilisé en paramètre sera quant à elle inchangée.

Les modificateurs "ref" et "out" permettent de changer ce comportement, ils permettent de donner la référence de l'objet à la place de sa valeur.

Le modificateur "ref"

Considérons l'exemple suivant :

static void Main(string[] args)
{
    int number = 20;
    AddFive(number);
    Console.WriteLine(number);
    Console.ReadKey();
}

static void AddFive(int number)
{
    number = number + 5;
}

On définit un entier initialisé à 20, puis on utilise la fonction AddFive supposé ajouter 5 à notre variable. Cette fonction le fait-elle pour autant? Non. La valeur attribué à notre variable dans la fonction n'est jamais transmise en dehors car nous avons utilisé une copie de la variable à la place de sa référence. C'est simplement le fonctionnement de C# et dans de nombreux cas c'est le comportement souhaité. Or dans notre situation nous voulons modifier cette variable. Cela est fait en utilisant le mot-clé "ref" :

static void Main(string[] args)
{
    int number = 20;
    AddFive(ref number);
    Console.WriteLine(number);
    Console.ReadKey();
}

static void AddFive(ref int number)
{
    number = number + 5;
}

Comme vous pouvez le constater, tout ce que l'on a à faire est d'ajouter le modificateur "ref" lors de la déclaration de la fonction ainsi qu'à l'appel. Désormais si vous exécutez le programme, vous constaterez que la valeur de la variable change dans la fonction mais aussi lorsque l'on en sort.

Le modificateur "out"

Le modificateur "out" est très similaire au modificateur "ref". Ils assurent tous les deux que le paramètre est passé par référence (et non par valeur), mais il y a tout de même deux différences importantes. Une variable passée avec une modificateur "ref" doit être initialisée au préalable, ce n'est pas le cas pour le modificateur "out" avec lequel on peut utiliser des variables non-initialisées. La deuxième différence est que l'on est obligé d'attribuer une valeur à une variable modifié avec "out" avant de sortir de la fonction. On ne peut pas utiliser une variable "out" dans une fonction car elles peuvent être non-initialisées, il est seulement possible de leur attribuer une nouvelle valeur.

L'utilisation des modificateurs "ref" et "out" dépend vraiment de la situation, vous le réaliserez quand vous commencerez à les utiliser. Le premier usage de ces modificateur est de contourner une limite des fonction qui est de ne pouvoir retourner qu'une seule valeur (en C#).

L'utilisation de du modificateur "out" est comme celui de "ref". Changez simplement le mot-clé "ref" par "out". Dans l'exemple précédent, rappelez vous de ne pas initialiser la variable dans le Main, mais de le faire dans la fonction directement.

Le modificateur "params"

Jusqu'à présent, toutes les fonctions acceptaient un nombre fixe de paramètres. Cependant, dans certain cas, vous pouvez avoir besoin d'une fonction avec un nombre de paramètre arbitraire. Cela peut être fait en utilisant un tableau comme paramètre comme ceci :

static void GreetPersons(string[] names) { }

Cependant, l'appel à cette fonction est une peu lourde, la manière la plus courte serait :

GreetPersons(new string[] { "John", "Jane", "Tarzan" });

C'est acceptable mais cela peut être fait plus intelligemment avec le mot-clé "params" :

static void GreetPersons(params string[] names) { }

L'appel serait alors :

GreetPersons("John", "Jane", "Tarzan");

Un autre avantage d'utiliser le modificateur "params" est de pouvoir ne pas passer d'argument. Une fonction utilisant le mot-clé "param" peut également prendre d'autres arguments, dès lors que ce modificateur est utilisé pour le dernier argument uniquement. Un seul modificateur "params" ne peut être utilisé par fonction. Voici un un dernier exemple un peu plus complexe :

static void Main(string[] args)
{
    GreetPersons(0);
    GreetPersons(25, "John", "Jane", "Tarzan");
    Console.ReadKey();
}

static void GreetPersons(int someUnusedParameter, params string[] names)
{
    foreach(string name in names)
    Console.WriteLine("Hello, " + name);
}