Siamo giunti finalmente all’ultimo breve argomento che riguarda i metodi.

Sappiamo ormai che un metodo può, tramite la parola chiave return, restituire un solo valore al codice che lo ha invocato. A volte, però, possiamo trovarci di fronte alla necessità che il nostro metodo, a seguito dell’elaborazione del suo codice, deve assegnare dei valori a più variabili che saranno poi restituite al codice chiamante. Una tale situazione è realmente fattibile tramite la tecnica definita

"passaggio di parametri out"

I parametri out (da output, uscita) non comunicano dei valori al metodo che li ha definiti, ma li ricevono. Quindi avviene una comunicazione unidirezionale in uscita perché i parametri out ricevono dei valori prima che siano "esportati" (out) al di fuori del metodo.

La situazione poteva tranquillamente essere risolta utilizzando i parametri ref. E allora la domanda nasce spontanea: "perché utilizzare i parametri out?".

La logica del programma imposta dal programmatore è ciò che influenza certe scelte tecniche rispetto ad altre; laddove il metodo debba ricevere dei valori per poi modificarli, è sicuramente idoneo utilizzare parametri ref, ma quando il metodo deve solo assegnare dei valori a delle variabili (parametri), è meglio utilizzare i parametri out. Tutto qui.

Veniamo ora al sodo. La sintassi per l’uso dei parametri out è questa:

static tipo-di-ritorno nome-metodo (out tipo nome-par, --)
   {
      // corpo del codice
   }

dove nell’elenco dei parametri compaiono i parametri in questione preceduti dalla parola chiave out che deve comparire anche tra gli argomenti dell’invocazione del metodo.

Per vedere in azione tale tecnica, riprendiamo il codice dell’esempio Swap.cs rinominandolo Swapout.cs:

using System;
class Swapout
    {
      static void LeggiNum(out int numero1, out int numero2)
       {
          Console.Write("\nInserire il primo valore ");
         numero1=Convert.ToInt32(Console.ReadLine());
         Console.Write("\nInserire il secondo valore ");
         numero2=Convert.ToInt32(Console.ReadLine());
        }
     static void Swapnum(ref int num1, ref int num2)
       {
          int temp;
          // effettua lo scambio
          temp=num1;
          num1=num2;
          num2=temp;
        }
     static void Main() // entry point
        {
          // variabili locali
          int num1=0;
          int num2=0;
          LeggiNum(out num1, out num2); // acquisisce i valori
          Console.Write("\n\nGli argomenti prima dell'invocazione sono: {0} e {1}\n",num1,num2);
          Swapnum(ref num1, ref num2); // invocazione del metodo per lo scambio
          Console.Write("\nGli argomenti dopo l'invocazione sono: {0} e {1}\n\n",num1,num2);
        }
    }

Compiliamo e lo lanciamo. In figura, un esempio:

Rispetto al codice del programma swap.cs, è cambiato solo il metodo LeggiNum(..) il quale ha i suoi parametri dichiarati out. Al parametro numero1 viene assegnato, alla riga 7, il primo valore che l’utente inserisce da tastiera, mentre al secondo numero2, viene assegnato il secondo valore alla riga 10.

Apparentemente il metodo, che è stato volutamente dichiarato void, non ritorna alcun valore al codice chiamante ma, come spiegato in precedenza, esso esporta (out) i suoi parametri all’esterno dopo averli inizializzati.

Nell’invocazione del metodo, alla riga 28, compaiono due argomenti anch’essi definiti out e fanno riferimento alle due variabili locali dichiarate ed inizializzati nelle due righe precedenti. Tali variabili riceveranno i valori esportati dal metodo.

Pagina precedente - Pagina successiva