Pagina personale di:
Carlo Vecchio
appunti di C#, R, SQL Server, ASP.NET, algoritmi, numeri
Vai ai contenuti

C# - Metodi in C#

C#

Metodi

  • Un metodo è una sequenza di istruzioni identificata da un nome.
  • Un metodo non può essere globale, ma è sempre contenuto in una classe; nell'esempio sotto, il metodo 'SommaNumeri' è contenuto nella classe 'MyClass'.

   class MyClass
   {
       
public int SommaNumeri(int a, int b)
       {
           
return a + b;
       }
   }


  • Un metodo può avere uno o più parametri di input (nell’esempio due valori int ‘a’ e ‘b’) e può restituire un valore di output (nell’esempio un ‘int’); nel caso non restituisca un valore, occorre scrivere la parola chiave ‘void’ al posto del tipo di dato restituito.
  • L’istruzione ‘return’ è l’ultima istruzione del metodo; è seguita dal valore restituito o dal solo punto e virgola se il metodo non restituisce alcun valore.
  • Essendo un metodo applicato a una classe, per utilizzarlo occorre istanziare un oggetto:

   MyClass p = new MyClass();
   
Console.WriteLine(p.SommaNumeri(1,2));

  • Un metodo può essere statico o può far parte di una classe statica. In questo caso per utilizzarlo non serve istanziare un oggetto, ma basta richiamarlo dal nome della classe. Per esempio se 'MyClass' fosse statica, 'SommaNumeri' si potrebbe richiamare con la semplice istruzione seguente:

   Console.WriteLine(MyClass.SommaNumeri(1,2));

Passaggio parametri a un metodo
  • I parametri a un metodo possono essere passati per valore e per riferimento.
  • Per valore (default): viene passata una copia del parametro, qualsiasi modifica fatta all’interno del metodo non influenza la variabile passata.
  • Per riferimento (‘ref’): viene passato l’indirizzo del parametro, qualsiasi modifica fatta all’interno del metodo viene fatta sulla variabile passata.
  • La classe seguente ha tre metodi statici: nel primo viene passato un argomento per valore, nel secondo e nel terzo viene passato un argomento per riferimento.
  • La differenza tra il secondo e il terzo metodo mostra l’utilizzo della parola chiave ‘out’: essa permette di richiamare il metodo senza prima aver inizializzato il parametro (che deve essere poi inizializzato all’interno del metodo).

   static class MyClass
   {
       
public static void IncrementaPerValore(int a)
       {
           a++;
       }
       
public static void IncrementaPerRiferimento(ref int a)
       {
           a++;
       }
       
public static void IncrementaPerRiferimentoOut(out int a)
       {
           a = 10;
           a++;
       }
   }

  • I seguenti codici richiamano i tre metodi.

   int a = 10;
   MyClass.IncrementaPerValore(a);
   Console.WriteLine(a);
// scrive 10

   
int a = 10; // obbligo di inizializzare la variabile
   MyClass.IncrementaPerRiferimento(
ref a);
   Console.WriteLine(a);
// scrive 11

   
int a; // nessun obbligo di inizializzare la variabile
   MyClass.IncrementaPerRiferimentoOut(
out a);
   Console.WriteLine(a);
// scrive 11

Parametri per nome
  • I parametri di un metodo, vanno passati nello stesso ordine nel quale sono definiti.
  • C'è anche la possibilità di passare i parametri in qualsiasi ordine, indicando - per ogni parametro - il nome seguito dai due punti ':'.
  • Esempio. Dato il seguente semplice metodo:

   private int Divisione(int dividendo, int divisore)
   {
       return dividendo / divisore;
   }

  • Si può richiamare il metodo nei seguenti modi:

   Console.WriteLine(Divisione(10, 5));                        // Risultato: 2
   Console.WriteLine(Divisione(divisore: 5, dividendo: 10));   // Risultato: 2

Parametri opzionali
  • I parametri di un metodo, possono essere opzionali.
  • Per ottenere questo, basta indicare nella definizione del metodo, un valore di default.
  • Se non tutti i parametri vengono passati, quelli omessi sono gli ultimi, che assumono il valore di default.
  • I tipi riferimento, possono essere opzionali solo se il valore di default è 'null'. I tipi riferimento non possono avere i modificatori 'ref' o 'out'.
  • I parametri opzionali devono seguire i parametri obbligatori e sono seguiti dall'array 'params'.
  • Esempio. Dato il seguente semplice metodo:

   private int Divisione(int dividendo = 10, int divisore = 5)
   {
       return dividendo / divisore;
   }

  • Si può richiamare il metodo nei seguenti modi:

   Console.WriteLine(Divisione());        // Risultato: 10 / 5 = 2
   Console.WriteLine(Divisione(20));      // Risultato: 20 / 5 = 4
   Console.WriteLine(Divisione(20, 2));   // Risultato: 20 / 2 = 10

Metodi con overload
  • Un metodo può avere molti overload. Ogni overload ha un elenco di parametri, ognuno di un certo tipo. Il compilatore, riconosce quanti e che tipo di parametri vengono passati al metodo e ne esegue il codice corrispondente.
  • La funzione seguente definisce due overload per il metodo ‘Media’, il prima accetta due valori interi, il secondo ne accetta tre.

   static public Single Media(int a, int b)
   {
       
return (Single)(a + b) / 2;
   }

   
static public Single Media(int a, int b, int c)
   {
       
return (Single)(a + b + c) / 3;
   }

  • I metodi seguenti vengono eseguiti con le istruzioni seguenti.

   System.Console.WriteLine(Media(8, 20));
   System.Console.WriteLine(Media(8, 20, 65));


Metodi con array di parametri
  • Se il numero di argomenti è sconosciuto viene in aiuto la parola chiave ‘params’. Essa permette di chiamare un metodo senza prima convertire un elenco di parametri in un array: al metodo viene passata quindi una lista di argomenti.
  • L’array di parametri è unidimensionale.
  • L’array di parametri deve essere passato come ultimo argomento.
  • Nell’esempio seguente il metodo ‘Media’ che riceve un qualunque numero di argomenti interi.

   static public Single Media(params int[] args)
   {
       
if (args == null || args.Length == 0)
           
throw new ArgumentException("Nessun parametro.");
       
int total = 0;
       
for (short i = 0; i < args.Length; i++)
       {
           total += args[i];
       }
       
return (Single)total / args.Length;
   }
   Console.WriteLine(Media(1, 2, 3, 4, 5));


  • L’array di parametri può essere di tipo ‘object’, in questo modo i parametri possono essere di tipi diversi. L’argomento può anche essere null o un array vuoto.

   static public Single Media(params object[] args)

Passaggio di un parametro per valore / riferimento
  • In un metodo, il passaggio di un parametro per valore, comporta la copia del valore che viene effettuata nello stack. Se il valore è di grandi dimensioni o viene la copia viene ripetuta molte volte, le prestazioni possono essere rallentate.
  • Il passaggio di un parametro per riferimento, comporta la copia del solo indirizzo del valore. Le prestazioni sono migliori ma il metodo può modificare la variabile rendendola non sicura.
  • Nel passaggio di un parametro, si può indicare al compilatore il fatto che il metodo deve restituire un valore. Basta utilizzare la parola chiave out.


© 2020 Carlo Vecchio
Torna ai contenuti