Parametri della funzione

Nel capitolo precedente, abbiamo dato un'occhiata alle funzioni. Abbiamo discusso brevemente i parametri, ma solo brevemente. Mentre i parametri sono molto semplici e chiari da usare, ci sono trucchi che possono renderli molto più efficaci.

La prima cosa alla quale daremo un'occhiata sono i modificatori di out e ref. Anche C# e altri linguaggi differiscono tra due parametri: "per valore" e "per riferimento". L'impostazione predefinita in C# è "per valore", che in pratica significa che quando si passa una variabile a una chiamata di funzione, si invia effettivamente una copia dell'oggetto, anziché un riferimento ad esso. Ciò significa anche che è possibile apportare modifiche al parametro dall'interno della funzione, senza influire sull'oggetto originale passato come parametro.

Con la parola chiave ref e out, possiamo modificare questo comportamento, quindi passiamo un riferimento all'oggetto invece del suo valore.

Il modificatore ref

Considera il seguente esempio:

static void Main(string[] args)
{
    int number = 20;
    AddFive(number);
    Console.WriteLine(number);
    Console.ReadKey();
}

static void AddFive(int number)
{
    number = number + 5;
}

Creiamo un intero, assegniamo il numero 20 ad esso, e quindi usiamo il metodo AddFive (), che dovrebbe aggiungere 5 al numero. Ma lo fa? No. Il valore che assegniamo al numero all'interno della funzione, non viene mai eseguito dalla funzione, perché abbiamo passato una copia del valore numerico anziché un riferimento ad esso. Questo è semplicemente il modo in cui C# funziona e, in molti casi, è il risultato preferito. Tuttavia, in questo caso, in realtà desideriamo modificare il numero all'interno della nostra funzione. Inserisci la parola chiave ref:

static void Main(string[] args)
{
    int number = 20;
    AddFive(ref number);
    Console.WriteLine(number);
    Console.ReadKey();
}

static void AddFive(ref int number)
{
    number = number + 5;
}

Come puoi vedere, tutto ciò che abbiamo fatto è aggiungere la parola chiave ref alla dichiarazione della funzione, nonché la chiamata alla funzione. Se esegui il programma ora, vedrai che il valore del numero ora è cambiato.

Il modificatore out

Il modificatore out funziona in modo molto simile al modificatore ref. Entrambi assicurano che il parametro sia passato per riferimento anziché per valore, ma presentano due importanti differenze: un valore passato a un modificatore ref deve essere inizializzato prima di chiamare il metodo - questo non è vero per il modificatore out, dove puoi usare valori non inizializzati. D'altra parte, non è possibile lasciare una chiamata di funzione con un parametro out, senza assegnargli un valore. Poiché è possibile passare valori non inizializzati come parametro out, non si è in grado di utilizzare effettivamente un parametro out all'interno di una funzione, è possibile solo assegnare un nuovo valore ad esso.

Usare "out" o "ref" dipende davvero dalla situazione, come realizzerai una volta che inizi a usarli. Entrambi sono in genere utilizzati per aggirare il problema di essere in grado di restituire un solo valore da una funzione, con C#.

Usare il modificatore out è come usare il modificatore ref, come mostrato sopra. Basta cambiare la parola chiave ref nella parola chiave out.

Il modificatore params

Finora, tutte le nostre funzioni hanno accettato una quantità fissa di parametri. Tuttavia, in alcuni casi, potrebbe essere necessaria una funzione che richiede un numero arbitrario di parametri. Questo potrebbe essere tranquillamente fatto accettando un array o un elenco come parametro, come questo:

static void GreetPersons(string[] names) { }

Tuttavia, chiamarlo sarebbe un po' impacciato. Nella forma più breve, sarebbe simile a questo:

GreetPersons(new string[] { "John", "Jane", "Tarzan" });

È accettabile, ma può essere fatto anche in modo più intelligente, con la parola chiave params:

static void GreetPersons(params string[] names) { }

Chiamarlo sarebbe quindi simile a questo:

GreetPersons("John", "Jane", "Tarzan");

Un altro vantaggio dell'utilizzo dell'approccio params è che è possibile passare anche zero parametri ad esso. Le funzioni con params possono anche prendere altri parametri, purché il parametro con la parola chiave params sia l'ultimo. Inoltre, è possibile utilizzare solo un parametro che utilizza la parola chiave params per funzione. Ecco un ultimo e più completo esempio:

static void Main(string[] args)
{
    GreetPersons(0);
    GreetPersons(25, "John", "Jane", "Tarzan");
    Console.ReadKey();
}

static void GreetPersons(int someUnusedParameter, params string[] names)
{
    foreach(string name in names)
    Console.WriteLine("Hello, " + name);
}