Übergeben von Verweistypparametern (C#-Programmierhandbuch)

 

Veröffentlicht: Juli 2016

Die neueste Dokumentation zu Visual Studio 2017 RC finden Sie unter Visual Studio 2017 RC Documentation (Dokumentation zu Visual Studio 2017 RC).

In einer Verweistypvariablen sind keine Daten, sondern ist lediglich ein Verweis auf die Daten enthalten. Wenn Sie einen Verweistypparameter als Wert übergeben, können Sie die Daten ändern, auf die verwiesen wird, z. B. den Wert eines Klassenmembers. Der Wert des Verweises selbst kann jedoch nicht geändert werden, d. h., es ist nicht möglich, mit ein und demselben Verweis Speicher für eine neue Klasse zu belegen und gleichzeitig den Wert zu ändern, sodass die Änderung außerhalb des Blocks Bestand hat. Zu diesem Zweck muss der Parameter mit dem ref-Schlüsselwort oder dem out-Schlüsselwort übergeben werden. Der Einfachheit halber wird in den folgenden Beispielen ref verwendet.

Im folgenden Beispiel wird der arr-Verweistypparameter der Change-Methode als Wert übergeben. Da es sich bei dem Parameter um einen Verweis auf arr handelt, können die Werte der Arrayelemente geändert werden. Der Versuch, den Parameter einer neuen Speicheradresse zuzuweisen, wirkt sich jedoch nur innerhalb der Methode aus und hat keinen Einfluss auf die ursprüngliche Variable 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
        */

Im vorangegangenen Beispiel wird das Array arr, bei dem es sich um einen Verweistyp handelt, ohne den ref-Parameter an die Methode übergeben. In diesem Fall wird eine Kopie des Verweises, der auf arr zeigt, an die Methode übergeben. Die Ausgabe zeigt, dass der Inhalt eines Arrayelements durch die Methode geändert werden kann, in diesem Fall von 1 bis 888. Da unter Verwendung des Operators new innerhalb der Change-Methode ein neuer Speicherbereich belegt wird, verweist die Variable pArray jedoch auf ein neues Array. Alle später vorgenommenen Änderungen haben daher keinen Einfluss auf das ursprüngliche Array arr, das innerhalb von Main erstellt wird. Tatsächlich werden in diesem Beispiel zwei Arrays erstellt, das eine in Main und das andere in der Change-Methode.

Das folgende Beispiel entspricht dem vorhergehenden Beispiel, mit der Ausnahme, dass das ref-Schlüsselwort wird dem Header und der Aufruf Methoden hinzugefügt. Alle Änderungen, die im Methoden affekt die ursprüngliche Variable im aufrufenden Programm stattfinden.

        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, die innerhalb der Methode vorgenommen werden, haben Einfluss auf das ursprünglichen Array in Main. Das ursprüngliche Array wird eigentlich mithilfe des Operators new neu zugeordnet. Nach dem Aufrufen der Change-Methode zeigt daher jeder Verweis auf arr auf das aus fünf Elementen bestehende Array, das in der Change-Methode erstellt wird.

Das Vertauschen von Zeichenfolgen ist ein gutes Beispiel dafür, wie Verweistypparameter als Verweis übergeben werden. Im vorliegenden Beispiel werden zwei Zeichenfolgen, str1 und str2, in Main initialisiert und als Parameter, die durch das ref-Schlüsselwort geändert wurden, an die SwapStrings-Methode übergeben. Die beiden Zeichenfolgen werden sowohl innerhalb der Methode als auch innerhalb von Main vertauscht.

        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 als Verweis übergeben werden, damit sich der Vorgang auf die Variablen im aufrufenden Programm auswirkt. Wenn Sie das ref-Schlüsselwort sowohl aus dem Header als auch aus dem Aufruf der Methode entfernen, werden im aufrufenden Programm keine Änderungen vorgenommen.

Weitere Informationen über Zeichenfolgen finden Sie unter Zeichenfolgen.

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

Anzeigen: