Übergeben von Werttypparametern (C#-Programmierhandbuch)

In einer Werttypvariablen sind die Daten direkt enthalten, während eine Verweistypvariable einen Verweis auf die Daten enthält. Das Übergeben einer Werttypvariablen an eine Methode ist daher gleichbedeutend mit dem Übergeben einer Kopie der Variablen an die Methode. Alle Änderungen am Parameter, die innerhalb der Methode vorgenommen werden, wirken sich nicht auf die ursprünglich in der Variablen gespeicherten Daten aus. Wenn der Wert des Parameters in der aufgerufenen Methode geändert werden soll, muss er unter Verwendung des ref-Schlüsselworts oder des out-Schlüsselworts als Verweis übergeben werden. Der Einfachheit halber wird in den folgenden Beispielen ref verwendet.

Beispiel

Im folgenden Beispiel werden Werttypparameter als Wert übergeben. Die n-Variable wird der SquareIt-Methode als Wert übergeben. Alle Änderungen, die innerhalb der Methode vorgenommen werden, wirken sich nicht auf den ursprünglichen Wert der Variablen aus.

class PassingValByVal
{
    static void SquareIt(int x)
    // The parameter x is passed by value.
    // Changes to x will not affect the original value of x.
    {
        x *= x;
        System.Console.WriteLine("The value inside the method: {0}", x);
    }
    static void Main()
    {
        int n = 5;
        System.Console.WriteLine("The value before calling the method: {0}", n);

        SquareIt(n);  // Passing the variable by value.
        System.Console.WriteLine("The value after calling the method: {0}", n);

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Output:
    The value before calling the method: 5
    The value inside the method: 25
    The value after calling the method: 5
*/

Da es sich bei der Variablen n um einen Werttyp handelt, sind die Daten (der Wert 5) direkt enthalten. Wenn SquareIt aufgerufen wird, wird der Inhalt von n in den Parameter x kopiert, der in der Methode quadriert wird. In Main bleibt der Wert von n sowohl vor als auch nach dem Aufrufen der SquareIt-Methode unverändert. Die innerhalb der Methode vorgenommene Änderung wirkt sich tatsächlich nur auf die lokale Variable x aus.

Das folgende Beispiel entspricht Beispiel 1, außer dass zum Übergeben des Parameters das ref-Schlüsselwort verwendet wird. Der Wert des Parameters ändert sich nach dem Aufrufen der Methode.

class PassingValByRef
{
    static void SquareIt(ref int x)
    // The parameter x is passed by reference.
    // Changes to x will affect the original value of x.
    {
        x *= x;
        System.Console.WriteLine("The value inside the method: {0}", x);
    }
    static void Main()
    {
        int n = 5;
        System.Console.WriteLine("The value before calling the method: {0}", n);

        SquareIt(ref n);  // Passing the variable by reference.
        System.Console.WriteLine("The value after calling the method: {0}", n);

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Output:
    The value before calling the method: 5
    The value inside the method: 25
    The value after calling the method: 25
*/

In diesem Beispiel wird nicht der Wert von n, sondern vielmehr ein Verweis auf n übergeben. Der Parameter x ist kein int, sondern ein Verweis auf int (in diesem Fall ein Verweis auf n). Wenn in der Methode der Wert x quadriert wird, wird in Wirklichkeit der Wert quadriert, auf den x verweist: n.

Eine häufig verwendete Methode zum Ändern der Werte von übergebenen Parametern ist die Swap-Methode, bei der zwei Variablen, x und y, übergeben werden und ihr Inhalt dabei vertauscht wird. Die Parameter müssen als Verweise an die Swap-Methode übergeben werden. Andernfalls verarbeitet die Methode eine lokale Kopie der Parameter. Im folgenden Beispiel für die Swap-Methode werden Verweisparameter verwendet:

static void SwapByRef(ref int x, ref int y)
{
    int temp = x;
    x = y;
    y = temp;
}

Um diese Methode aufzurufen, verwenden Sie das ref-Schlüsselwort, wie im folgenden Beispiel angegeben:

static void Main()
{
    int i = 2, j = 3;
    System.Console.WriteLine("i = {0}  j = {1}" , i, j);

    SwapByRef (ref i, ref j);

    System.Console.WriteLine("i = {0}  j = {1}" , i, j);

    // Keep the console window open in debug mode.
    System.Console.WriteLine("Press any key to exit.");
    System.Console.ReadKey();
}
/* Output:
    i = 2  j = 3
    i = 3  j = 2
*/

Siehe auch

Referenz

Übergeben von Parametern (C#-Programmierhandbuch)

Übergeben von Verweistypparametern (C#-Programmierhandbuch)

Konzepte

C#-Programmierhandbuch