Pasar parámetros de tipo de valor (Guía de programación de C#)

Una variable tipo de valor contiene sus datos directamente, en oposición a la variable tipo de referencia, que contiene una referencia a sus datos. Pasar una variable tipo de valor a un método en función del valor significa pasar una copia de la variable al método. Ningún cambio realizado en el parámetro dentro del método afecta a los datos originales almacenados en la variable de argumentos. Si desea que el método al que se llama cambie el valor del argumento, debe pasarlo en función de la referencia, con la palabra clave ref o out. También puede usar la palabra clave in para pasar un parámetro de valor por referencia para evitar la copia, a la vez que se asegura de que el valor no se modificará. Para simplificar, en el ejemplo siguiente se usa ref.

Pasar tipos de valor en función del valor

En el ejemplo siguiente se muestra cómo pasar los parámetros de tipo de valor en función del valor. La variable n se pasa en función del valor al método SquareIt. Los cambios que tienen lugar dentro del método no tienen ningún efecto en el valor original de la 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
*/

La variable n es un tipo de valor. Contiene sus datos, el valor 5. Cuando se invoca SquareIt, el contenido de n se copia en el parámetro x, que se multiplica dentro del método. En Main, sin embargo, el valor de n es el mismo después de llamar al métodoSquareIt que el que era antes. El cambio que tiene lugar dentro del método solo afecta a la variable local x.

Pasar tipos de valor en función de la referencia

El ejemplo siguiente es el mismo que el anterior, salvo que el argumento se pasa como un parámetro ref. El valor del argumento subyacente, n, se cambia cuando se modifica x en el método.

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

En este ejemplo, no es el valor de n el que se pasa, sino una referencia a n. El parámetro x no es un entero; se trata de una referencia a int, en este caso, una referencia a n. Por tanto, cuando x se multiplica dentro del método, lo que realmente se multiplica es a lo que x hace referencia, n.

Intercambiar tipos de valor

Un ejemplo común de modificación de valores de argumentos es un método de intercambio, donde se pasan dos variables al método, y el método intercambia su contenido. Debe pasar los argumentos al método de intercambio en función de la referencia. De lo contrario, se intercambian copias locales de los parámetros dentro del método, y no se produce ningún cambio en el método de llamada. En el ejemplo siguiente se intercambian valores enteros.

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

Al llamar al método SwapByRef, use la palabra clave ref en la llamada, como se muestra en el ejemplo siguiente.

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

Vea también