Übergeben von Werttypparametern (C#-Programmierhandbuch)Passing Value-Type Parameters (C# Programming Guide)

In einer Werttypvariablen sind die Daten direkt enthalten, während eine Verweistypvariable einen Verweis auf die Daten enthält.A value-type variable contains its data directly as opposed to a reference-type variable, which contains a reference to its data. Wenn eine Werttypvariable als Wert an eine Methode übergeben wird, bedeutet dies die Übergabe einer Kopie der Variablen an die Methode.Passing a value-type variable to a method by value means passing a copy of the variable to the method. Alle Änderungen am Parameter, die innerhalb der Methode erfolgen, haben keine Auswirkung auf die ursprünglichen Daten, die in der Argumentvariable gespeichert sind.Any changes to the parameter that take place inside the method have no affect on the original data stored in the argument variable. 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.If you want the called method to change the value of the parameter, you must pass it by reference, using the ref or out keyword. Der Einfachheit halber wird im folgenden Beispiel ref verwendet.For simplicity, the following examples use ref.

Übergeben von Werttypen als WertPassing Value Types by Value

Im folgenden Beispiel wird gezeigt, wie Werttypparameter als Wert übergeben werden.The following example demonstrates passing value-type parameters by value. Die Variable n wird als Wert an die SquareIt-Methode übergeben.The variable n is passed by value to the method SquareIt. Alle Änderungen, die innerhalb der Methode vorgenommen werden, wirken sich nicht auf den ursprünglichen Wert der Variablen aus.Any changes that take place inside the method have no affect on the original value of the variable.

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.The variable n is a value type. Sie enthält Daten, den Wert 5.It contains its data, the value 5. Beim Aufruf von SquareIt werden die Inhalte von n in den Parameter x kopiert, der in der Methode quadriert wird.When SquareIt is invoked, the contents of n are copied into the parameter x, which is squared inside the method. In Main ist der Wert von n jedoch auch nach dem Aufruf der SquareIt-Methode derselbe wie zuvor.In Main, however, the value of n is the same after calling the SquareIt method as it was before. Die Änderung, die innerhalb der Methode stattfindet, wirkt sich nur auf die lokale Variable x aus.The change that takes place inside the method only affects the local variable x.

Übergeben von Werttypen als VerweisPassing Value Types by Reference

Das folgende Beispiel entspricht dem vorhergehenden Beispiel, mit dem Unterschied, dass das Argument als ref-Parameter übergeben wird.The following example is the same as the previous example, except that the argument is passed as a ref parameter. Der Wert des zugrunde liegenden Arguments, n, wird geändert, wenn x in der Methode geändert wird.The value of the underlying argument, n, is changed when x is changed in the method.

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.In this example, it is not the value of n that is passed; rather, a reference to n is passed. Der Parameter x ist kein int, sondern ein Verweis auf int – in diesem Fall ein Verweis auf n.The parameter x is not an int; it is a reference to an int, in this case, a reference to n. Beim Quadrieren von x innerhalb der Methode wird deshalb tatsächlich das Element quadriert, auf das x verweist: n.Therefore, when x is squared inside the method, what actually is squared is what x refers to, n.

Austauschen von WerttypenSwapping Value Types

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.A common example of changing the values of arguments is a swap method, where you pass two variables to the method, and the method swaps their contents. Sie müssen die Argumente als Verweis an die swap-Methode übergeben.You must pass the arguments to the swap method by reference. Andernfalls tauschen Sie lokale Kopien der Parameter innerhalb der Methode aus, und es erfolgt keine Änderung in der aufrufenden Methode.Otherwise, you swap local copies of the parameters inside the method, and no change occurs in the calling method. Im folgenden Beispiel werden ganzzahlige Werte getauscht.The following example swaps integer values.

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.When you call the SwapByRef method, use the ref keyword in the call, as shown in the following example.

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 auchSee Also

C#-ProgrammierhandbuchC# Programming Guide
Übergeben von ParameternPassing Parameters
Übergeben von VerweistypparameternPassing Reference-Type Parameters