Übergeben von Werttypparametern (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 Werttypvariablen sind die Daten direkt enthalten, während eine Verweistypvariable einen Verweis auf die Daten enthält. Ein Werttyp die Variable an eine Methode als Wert übergeben bedeutet die Übergabe einer Kopie der Variablen an die Methode. Alle Änderungen am Parameter, die innerhalb der Methode haben keinen Einfluss auf den ursprünglichen Daten stattfinden, die in der Argument die Variable gespeichert werden. Wenn Sie die aufgerufene Methode den Wert des Parameters ändern möchten, müssen Sie ihn durch einen Verweis, mit ref oder des Timeout-Schlüsselwort übergeben. Der Einfachheit halber wird in den folgenden Beispielen ref verwendet.

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
        */

Variable n ist ein Werttyp. Er enthält seine Daten, den Wert 5. Wenn SquareIt aufgerufen wird, wird der Inhalt von n in den Parameter x kopiert, der in der Methode quadriert wird. In MainAllerdings ist der Wert von n gleich, nachdem er die SquareIt-Methode aufgerufen hat, die er zuvor befand. Die Änderung, die innerhalb der Methode ausgeführt wird, wirkt sich nur auf die lokale Variable x.

Das folgende Beispiel entspricht dem vorhergehenden Beispiel, mit dem Unterschied, dass das Argument ref wird als Parameter übergeben. Der Wert des zugrunde liegenden nArguments 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 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 x innerhalb der Methode quadriert, was tatsächlich quadriert wird, was x verweist, ist n.

Ein allgemeines Beispiel einer Änderung der Werte der Argumente ist eine Austausch Methode, in der Sie zwei Variablen an die Methode übergeben, und die Methode lagert ihre Inhalte aus. Sie müssen die Argumente der Austausch Methode durch einen Verweis übergeben. Andernfalls lagern Sie lokale Kopien der Parameter innerhalb der Methode aus, und keine Änderung wird in der aufrufenden Methode ein. Das folgende Beispiel lagert ganzzahligen Werten aus.

            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 im Aufruf ref , 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
            */

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

Anzeigen: