Übergeben von Werttypparametern (C#-Programmierhandbuch)

In einer Werttypvariablen sind die Daten direkt enthalten, während eine Verweistypvariable einen Verweis auf die Daten enthält. Wenn eine Werttypvariable als Wert an eine Methode übergeben wird, bedeutet dies die Übergabe einer Kopie der Variablen an die Methode. Alle Änderungen am Parameter, die innerhalb der Methode erfolgen, haben keine Auswirkung auf die ursprünglichen Daten, die in der Argumentvariable gespeichert sind. Wenn Sie möchten, dass mit der aufgerufenen Methode der Wert des Parameters geändert wird, müssen Sie ihn als Verweis übergeben, unter Verwendung des Schlüsselworts ref oder out. Der Einfachheit halber wird im folgenden Beispiel ref verwendet.

Übergeben von Werttypen als Wert

Im folgenden Beispiel wird gezeigt, wie Werttypparameter als Wert übergeben werden. Die Variable n wird als Wert an die SquareIt-Methode ü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
*/

Die Variable n ist eine Werttypvariable. Sie enthält Daten, den Wert 5. Beim Aufruf von SquareIt werden die Inhalte von n in den Parameter x kopiert, der in der Methode quadriert wird. In Main ist der Wert von n jedoch auch nach dem Aufruf der SquareIt-Methode derselbe wie zuvor. Die Änderung, die innerhalb der Methode stattfindet, wirkt sich nur auf die lokale Variable x aus.

Übergeben von Werttypen als Verweis

Das folgende Beispiel entspricht dem vorhergehenden Beispiel, mit dem Unterschied, dass das Argument als ref-Parameter übergeben wird. Der Wert des zugrunde liegenden Arguments, n, wird geändert, wenn x in der Methode geändert wird.

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 ein Verweis auf n übergeben. Der Parameter x ist kein int, sondern ein Verweis auf int – in diesem Fall ein Verweis auf n. Beim Quadrieren von x innerhalb der Methode wird deshalb tatsächlich das Element quadriert, auf das x verweist: n.

Austauschen von Werttypen

Ein allgemeines Beispiel zum Ändern der Werte von Argumenten ist eine swap-Methode, bei der Sie zwei Variablen an die Methode übergeben und die Methode deren Inhalte austauscht. Sie müssen die Argumente als Verweis an die swap-Methode übergeben. Andernfalls tauschen Sie lokale Kopien der Parameter innerhalb der Methode aus, und es erfolgt keine Änderung in der aufrufenden Methode. Im folgenden Beispiel werden ganzzahlige Werte getauscht.

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

Wenn Sie die SwapByRef-Methode aufrufen, verwenden Sie das Schlüsselwort ref im Aufruf, wie im folgenden Beispiel gezeigt.

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

C#-Programmierhandbuch
Übergeben von Parametern
Übergeben von Verweistypparametern