Übergeben von Verweistypparametern (C#-Programmierhandbuch)

Eine Variable eines Verweistyps enthält direkt keine Daten. Sie enthält einen Verweis auf die Daten. Wenn Sie einen Verweistypparameter nach Wert übergeben, ist es möglich, die Daten zu ändern, auf die die Daten zeigen, z.B. den Wert eines Klassenmembers. Sie können jedoch nicht den Wert des Verweises selbst ändern. Das bedeutet, dass Sie nicht mit dem gleichen Verweis einer neuen Klasse Arbeitsspeicher zuweisen und ihn außerhalb des Blocks beibehalten können. Dazu müssen Sie den Parameter mit den Schlüsselwörtern ref oder out übergeben. Der Einfachheit halber wird im folgenden Beispiel ref verwendet.

Übergeben von Verweistypen nach Wert

Im folgenden Beispiel wird gezeigt, wie Verweistypparameter, arr, nach Wert an eine Methode, Change, übergeben werden. Da der Parameter ein Verweis auf arr ist, ist es möglich, die Werte der Arrayelemente zu ändern. Der Versuch, den Parameter einem anderen Speicherort zuzuweisen, funktioniert aber nur innerhalb der Methode und wirkt sich nicht auf die ursprüngliche Variable arr aus.

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
*/

Im vorherigen Beispiel, wurde das Verweistyp-Array arr ohne den ref-Parameter an die Methode übergeben. In diesem Fall wird eine Kopie des Verweises, die auf arr zeigt, an die Methode übergeben. Die Ausgabe zeigt, dass die Methode den Inhalt eines Arrayelements ändern kann, in diesem Fall von 1 in 888. Durch das Zuweisen eines neuen Teils des Arbeitsspeichers mithilfe des Operators new innerhalb der Change-Methode verweist die Variable pArray jedoch auf ein neues Array. Alle nachfolgenden Änderungen wirken sich daher nicht auf das ursprüngliche Array arr aus, das in Main erstellt wird. Tatsächlich werden in diesem Beispiel zwei Arrays erstellt, eines in der Main, und das andere in der Change-Methode.

Übergeben von Verweistypen nach Verweis

Das folgende Beispiel entspricht dem vorherigen, mit dem Unterschied, dass dem Methodenheader und -aufruf das ref-Schlüsselwort hinzugefügt wird. Alle Änderungen in der Methode haben Auswirkungen auf die ursprüngliche Variable im aufrufenden Programm.

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
*/

Alle Änderungen innerhalb der Methode haben Auswirkungen auf das ursprüngliche Array in Main. Das ursprüngliche Array wird in der Tat mit dem new-Operator neu zugewiesen. Nach dem Aufruf der Change-Methode zeigt jeder Verweis auf arr auf die fünf Elemente umfassendes Array, das in der Change-Methode erstellt wird.

Austauschen von zwei Zeichenfolgen

Das Austauschen von Zeichenfolgen ist ein gutes Beispiel für das Übergeben von Verweistypparametern nach Verweis. Im Beispiel werden zwei Zeichenfolgen, str1 und str2, in Main initialisiert und der SwapStrings-Methode als Parameter übergeben, die vom ref-Schlüsselwort geändert wurden. Die beiden Zeichenfolgen werden innerhalb der Methode und auch in Main ausgetauscht.

 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
*/

In diesem Beispiel müssen die Parameter nach Verweis übergeben werden, damit die Variablen im aufrufenden Programm beeinflusst werden. Wenn Sie das ref-Schlüsselwort aus dem Methodenheader und dem Methodenaufruf entfernen, erfolgen keine Änderungen im aufrufenden Programm.

Weitere Informationen zu Zeichenfolgen finden Sie unter string.

Siehe auch

C#-Programmierhandbuch
Übergeben von Parametern
Übergeben von Arrays mithilfe von „ref“ und „out“
ref
Verweistypen