Pourquoi ref devrait-il être utilisé pour les parameters de tableau en C #?

Les changements dans la fonction appelée ne seront-ils pas répercutés sur la fonction appelant?

Les modifications apscopes au contenu du tableau seraient répercutées dans la méthode de l’appelant, mais les modifications apscopes au paramètre lui – même ne le seraient pas. Donc par exemple:

 public void Foo(int[] x) { // The effect of this line is visible to the caller x[0] = 10; // This line is pointless x = new int[] { 20 }; } ... int[] original = new int[10]; Foo(original); Console.WriteLine(original[0]); // Prints 10 

Maintenant, si nous changions Foo pour avoir une signature de:

 public void Foo(ref int[] x) 

et changé le code d’appel en:

 Foo(ref original); 

alors il imprimerait 20.

Il est très important de comprendre la différence entre une variable et l’object auquel sa valeur fait référence – et également entre la modification d’un object et la modification d’une variable .

Voir mon article sur le passage de parameters en C # pour plus d’informations.

Si vous envisagez uniquement de modifier le contenu du tableau, vous avez raison. Toutefois, si vous envisagez de modifier le tableau lui-même, vous devez alors passer par référence.

Par exemple:

 void foo(int[] array) { array[0] = 5; } void bar(int[] array) { array = new int[5]; array[0] = 6; } void barWithRef(ref int[] array) { array = new int[6]; array[0] = 6; } void Main() { int[] array = int[5]; array[0] = 1; // First, lets call the foo() function. // This does exactly as you would expect... it will // change the first element to 5. foo(array); Console.WriteLine(array[0]); // yields 5 // Now lets call the bar() function. // This will change the array in bar(), but not here. bar(array); Console.WriteLine(array[0]); // yields 1. The array we have here was never changed. // Finally, lets use the ref keyword. barWithRef(ref array); Console.WriteLine(array[0]); // yields 5. And the array's length is now 6. }