Passage de paramètres de type référence (Guide de programmation C#)

Article
06/10/2015

Une variable de type référence ne contient pas directement les données, mais contient une référence aux données. Lorsque vous passez un paramètre de type référence par valeur, il est possible de modifier les données sur lesquelles pointe la référence, comme par exemple la valeur d'un membre de classe. Toutefois, vous ne pouvez pas modifier la valeur de la référence elle-même. Cela signifie que vous ne pouvez pas utiliser la même référence pour allouer de la mémoire pour une nouvelle classe et la faire persister en dehors du bloc. Pour cela, passez le paramètre en utilisant le mot clé ref ou out. Par souci de simplicité, les exemples qui suivent utilisent ref.

Passage de types référence par valeur

Cet exemple illustre le passage d'un paramètre de type référence, arr, par valeur à une méthode, Change. Comme le paramètre est une référence de arr, il est possible de modifier les valeurs des éléments du tableau. Toutefois, la tentative de réassignation du paramètre à un emplacement de mémoire différent s'effectue uniquement au sein de la méthode et n'affecte pas la variable d'origine, arr.

class PassingRefByVal 
{
    static void Change(int[] pArray)
    {
        pArray[0] = 888;  // This change affects the original element.
        pArray = new int[5] {-3, -1, -2, -3, -4};   // This change is local.
        System.Console.WriteLine("Inside the method, the first element is: {0}", pArray[0]);
    }

    static void Main() 
    {
        int[] arr = {1, 4, 5};
        System.Console.WriteLine("Inside Main, before calling the method, the first element is: {0}", arr [0]);

        Change(arr);
        System.Console.WriteLine("Inside Main, after calling the method, the first element is: {0}", arr [0]);
    }
}
/* Output:
    Inside Main, before calling the method, the first element is: 1
    Inside the method, the first element is: -3
    Inside Main, after calling the method, the first element is: 888
*/

Dans l'exemple précédent, le tableau, arr, de type référence, est passé à la méthode sans le paramètre ref. Dans ce cas, une copie de la référence, qui pointe sur arr, est passée à la méthode. La sortie montre qu'il est possible que la méthode modifie le contenu d'un élément du tableau (dans ce cas, de 1 à 888). Toutefois, l'allocation d'une nouvelle partie de la mémoire à l'aide de l'opérateur new au sein de la méthode Change fait de la référence pArray de la variable un nouveau tableau. De cette manière, aucune modification ultérieure n'affectera le tableau d'origine, arr, qui est créé au sein de Main. En fait, deux tableaux sont créés dans cet exemple, l'un au sein de Main et l'autre au sein de la méthode Change.

Passage de types référence par référence

L'exemple suivant est identique à l'exemple précédent, mais que le mot clé d' ref est ajouté à l'en-tête et à l'appel de méthode. Toutes les modifications qui interviennent dans l'impact de méthode la variable d'origine dans le programme appelant.

class PassingRefByRef 
{
    static void Change(ref int[] pArray)
    {
        // Both of the following changes will affect the original variables:
        pArray[0] = 888;
        pArray = new int[5] {-3, -1, -2, -3, -4};
        System.Console.WriteLine("Inside the method, the first element is: {0}", pArray[0]);
    }

    static void Main() 
    {
        int[] arr = {1, 4, 5};
        System.Console.WriteLine("Inside Main, before calling the method, the first element is: {0}", arr[0]);

        Change(ref arr);
        System.Console.WriteLine("Inside Main, after calling the method, the first element is: {0}", arr[0]);
    }
}
/* Output:
    Inside Main, before calling the method, the first element is: 1
    Inside the method, the first element is: -3
    Inside Main, after calling the method, the first element is: -3
*/

Toutes les modifications qui interviennent au sein de la méthode affectent le tableau d'origine dans Main. En fait, le tableau d'origine est réalloué à l'aide de l'opérateur new. En conséquence, après l'appel de la méthode Change, toute référence à arr pointe sur le tableau à cinq éléments, créé dans la méthode Change.

Permutation de deux chaînes

La permutation de chaînes est un bon exemple de passage de paramètres de type référence par référence. Dans cet exemple, deux chaînes, str1 et str2, sont initialisées dans Main et passées à la méthode SwapStrings en tant que paramètres modifiés par le mot clé ref. Les deux chaînes sont permutées au sein de la méthode, ainsi que dans Main.

 class SwappingStrings
 {
     static void SwapStrings(ref string s1, ref string s2)
     // The string parameter is passed by reference. 
     // Any changes on parameters will affect the original variables.
     {
         string temp = s1;
         s1 = s2;
         s2 = temp;
         System.Console.WriteLine("Inside the method: {0} {1}", s1, s2);
     }

     static void Main()
     {
         string str1 = "John";
         string str2 = "Smith";
         System.Console.WriteLine("Inside Main, before swapping: {0} {1}", str1, str2);

         SwapStrings(ref str1, ref str2);   // Passing strings by reference
         System.Console.WriteLine("Inside Main, after swapping: {0} {1}", str1, str2);
     }
 }
 /* Output:
     Inside Main, before swapping: John Smith
     Inside the method: Smith John
     Inside Main, after swapping: Smith John
*/

Dans cet exemple, les paramètres doivent être passés par référence pour affecter les variables dans le programme appelant. Si vous supprimez le mot clé ref à la fois dans l'en-tête et dans l'appel de la méthode, aucune modification n'intervient dans le programme appelant.

Pour plus d'informations sur les chaînes, consultez chaîne.