Übergeben von Verweistypparametern (C#-Programmierhandbuch)Passing Reference-Type Parameters (C# Programming Guide)

Eine Variable eines Verweistyps enthält direkt keine Daten. Sie enthält einen Verweis auf die Daten.A variable of a reference type does not contain its data directly; it contains a reference to its data. 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.When you pass a reference-type parameter by value, it is possible to change the data pointed to by the reference, such as the value of a class member. 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.However, you cannot change the value of the reference itself; that is, you cannot use the same reference to allocate memory for a new class and have it persist outside the block. Dazu müssen Sie den Parameter mit den Schlüsselwörtern ref oder out übergeben.To do that, pass the parameter using the ref or out keyword. Der Einfachheit halber wird im folgenden Beispiel ref verwendet.For simplicity, the following examples use ref.

Übergeben von Verweistypen nach WertPassing Reference Types by Value

Im folgenden Beispiel wird gezeigt, wie Verweistypparameter, arr, nach Wert an eine Methode, Change, übergeben werden.The following example demonstrates passing a reference-type parameter, arr, by value, to a method, Change. Da der Parameter ein Verweis auf arr ist, ist es möglich, die Werte der Arrayelemente zu ändern.Because the parameter is a reference to arr, it is possible to change the values of the array elements. 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.However, the attempt to reassign the parameter to a different memory location only works inside the method and does not affect the original 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 vorherigen Beispiel, wurde das Verweistyp-Array arr ohne den ref-Parameter an die Methode übergeben.In the preceding example, the array, arr, which is a reference type, is passed to the method without the ref parameter. In diesem Fall wird eine Kopie des Verweises, die auf arr zeigt, an die Methode übergeben.In such a case, a copy of the reference, which points to arr, is passed to the method. Die Ausgabe zeigt, dass die Methode den Inhalt eines Arrayelements ändern kann, in diesem Fall von 1 in 888.The output shows that it is possible for the method to change the contents of an array element, in this case from 1 to 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.However, allocating a new portion of memory by using the new operator inside the Change method makes the variable pArray reference a new array. Alle nachfolgenden Änderungen wirken sich daher nicht auf das ursprüngliche Array arr aus, das in Main erstellt wird.Thus, any changes after that will not affect the original array, arr, which is created inside Main. Tatsächlich werden in diesem Beispiel zwei Arrays erstellt, eines in der Main, und das andere in der Change-Methode.In fact, two arrays are created in this example, one inside Main and one inside the Change method.

Übergeben von Verweistypen nach VerweisPassing Reference Types by Reference

Das folgende Beispiel entspricht dem vorherigen, mit dem Unterschied, dass dem Methodenheader und -aufruf das ref-Schlüsselwort hinzugefügt wird.The following example is the same as the previous example, except that the ref keyword is added to the method header and call. Alle Änderungen in der Methode haben Auswirkungen auf die ursprüngliche Variable im aufrufenden Programm.Any changes that take place in the method affect the original variable in the calling program.

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.All of the changes that take place inside the method affect the original array in Main. Das ursprüngliche Array wird in der Tat mit dem new-Operator neu zugewiesen.In fact, the original array is reallocated using the new operator. 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.Thus, after calling the Change method, any reference to arr points to the five-element array, which is created in the Change method.

Austauschen von zwei ZeichenfolgenSwapping Two Strings

Das Austauschen von Zeichenfolgen ist ein gutes Beispiel für das Übergeben von Verweistypparametern nach Verweis.Swapping strings is a good example of passing reference-type parameters by reference. 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.In the example, two strings, str1 and str2, are initialized in Main and passed to the SwapStrings method as parameters modified by the ref keyword. Die beiden Zeichenfolgen werden innerhalb der Methode und auch in Main ausgetauscht.The two strings are swapped inside the method and inside Main as well.

 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.In this example, the parameters need to be passed by reference to affect the variables in the calling program. Wenn Sie das ref-Schlüsselwort aus dem Methodenheader und dem Methodenaufruf entfernen, erfolgen keine Änderungen im aufrufenden Programm.If you remove the ref keyword from both the method header and the method call, no changes will take place in the calling program.

Weitere Informationen zu Zeichenfolgen finden Sie unter string.For more information about strings, see string.

Siehe auchSee Also

C#-ProgrammierhandbuchC# Programming Guide
Übergeben von ParameternPassing Parameters
Übergeben von Arrays mithilfe von "ref" und "out"Passing Arrays Using ref and out
refref
VerweistypenReference Types