Passaggio di parametri di tipi di valore (Guida per programmatori C#)

Una variabile associata a un tipo che rappresenta un valore contiene direttamente i dati, mentre una variabile associata a un tipo che rappresenta un riferimento contiene un riferimento ai dati. Il passaggio a un metodo di una variabile associata a un tipo che rappresenta un valore consiste pertanto nel passaggio al metodo di una copia della variabile. Eventuali modifiche del parametro apportate nel metodo non avranno alcun effetto sui dati originali archiviati nella variabile. Per fare in modo che il metodo chiamato modifichi il valore del parametro, è necessario passarlo per riferimento mediante la parola chiave ref o out. Per semplicità, negli esempi che seguono viene utilizzata solo la parola chiave ref.

Esempio

Nell'esempio che segue viene illustrato il passaggio di parametri associati a tipi che rappresentano un valore per valore. La variabile n viene passata per valore al metodo SquareIt. Eventuali modifiche apportate nel metodo non avranno alcun effetto sul valore originale della variabile.

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 variabile n, essendo un tipo di valore, contiene i propri dati (il valore 5). Quando si richiama SquareIt, il contenuto di n viene copiato nel parametro x, che viene elevato al quadrato all'interno del metodo. In Main, tuttavia, il valore di n è sempre lo stesso, sia prima che dopo la chiamata al metodo SquareIt. La modifica apportata nel metodo ha effetto solo sulla variabile locale x.

L'esempio riportato di seguito è analogo a quello precedente, con la differenza che il parametro viene passato utilizzando la parola chiave ref. Il valore del parametro risulta modificato dopo la chiamata al metodo.

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 questo esempio non viene passato il valore di n, ma solo un riferimento a n. Il parametro x non è di tipo int ma è un riferimento a un valore int, in questo caso un riferimento a n. Pertanto, quando la variabile x viene elevata al quadrato all'interno del metodo, l'operazione ha effetto sull'elemento a cui x fa riferimento, ovvero n.

Un esempio comune di modifica dei valori dei parametri passati è costituito dal metodo Swap, in cui si passano due variabili, x e y, il cui contenuto viene scambiato dal metodo. È necessario passare i parametri al metodo Swap per riferimento. In caso contrario, si opererà semplicemente su una copia locale dei parametri all'interno del metodo. Di seguito è illustrato un esempio del metodo Swap che utilizza i parametri di riferimento:

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

Quando si richiama questo metodo, utilizzare la parola chiave ref nella chiamata, come illustrato di seguito:

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

Vedere anche

Riferimenti

Passaggio di parametri (Guida per programmatori C#)

Passaggio di parametri di tipi di riferimento (Guida per programmatori C#)

Concetti

Guida per programmatori C#