I metodi consentono di effettuare operazioni sui tipi. La sintasi per la dichiarazione del metodo che è composta di una testa ed un corpo. La testa sarà fatta nel seguente modo:

[attributi] [modificatori] tipo_ritorno nome_metodo ([ parametri_formali] )
{
  corpo metodo
}

Ad esempio

using System;
namespace Sample
{
  public class Sample
  {
     private static string a;
     private static string b;

     public static void Main()
     {
        a = "Prima parte";
        b = "seconda parte";

        Console.WriteLine(concatenaStringhe(a, b));
     }

     private static string concatenaStringhe(string a, string b)
     {
           return a + ", " + b;
     }
  }
}

Attributi

Gli attributi dei metodi sono come quelli visti per le classi

Modificatori

Ci sono diversi modificatori di metodo.

abstract
Metodi dichiarati 'abstract' non possono essere richiamati, sono dichiarati solo per consentire l’ereditarietà, di conseguenza non hanno un corpo.

static
I metodi 'static' sono dei metodi di classe e possono essere richiamati esclusivamente quando non esiste una istanza corrente della classe.

extern
Sono metodi definiti esternamente

Parametri Formali

I parametri di un metodo sono dei tipi che vengono passati al metodo quando questo viene richiamato.
Ecco la dichiarazione di un parametro:

[Modificatore] tipo_parametro identificatore_parametro

Passaggio dei parametri

Passaggio per valore

Se non viene specificato niente, i parametri sono passati per valore. In questo caso, quando viene richiamato il metodo, il valore viene copiato nella variabile specificata nella dichiarazione del metodo.
Ne deriva che quando usciamo dalla funzione, la variabile passata, mantiene il valore che aveva prima dell’invocazione.

using System;
namespace Sample
{
  public class Sample
  {
    public static void Main()
    {
      int a = 1;
      int b = 1;
      int c = 1;
      c = somma(a, b);
      Console.WriteLine("a = " + a);
      Console.WriteLine("b = " + b);
      Console.WriteLine("c = " + c);
    }
    private static int somma(int a, int b)
    {
      a++;
      return a + b;
    }
  }
}

Come output avremo:
a = 1
b = 1
c = 3

Il valore di a viene modificato solo all'interno della funzione mentre sesta invariato al di fuori. Questo perchè passiamo una copia di a alla funzione

Passaggio per riferimento

Passando un valore per riferimento, (mediante il modificatore 'ref' specificato sia nella dichiarazione sia nell’invocazione), passiamo in realtà una locazione di memoria, ne risulta che i valori passati alla funzione potranno essere modificati e le modifiche resteranno anche dopo l’uscita dalla funzione.

using System;
namespace Sample
{
  public class Sample
  {
    public static void Main()
    {
      int a = 1;
      int b = 1;
      int c = 1;
      c = somma(ref a, b);
      Console.WriteLine("a = " + a);
      Console.WriteLine("b = " + b);
      Console.WriteLine("c = " + c);
    }

    private static int somma(ref int a, int b)
    {
      a++;
      return a + b;
    }
  }
}

Come output avremo:

a = 2
b = 1
c = 3

Nell'esempio vediamo che dopo l'uscita dalla funzione, il valore di a è modificato, questo perchè passiamo la locazione di memoria che contiene la variabile a alla funzione

Parametri di 'output'

Quando definiamo un parametro con il modificatore 'out', questo viene passato per riferimento, il valore del parametro viene modificato dal metodo.

using System;
namespace Sample
{
  public class Sample
  {
    private static string a;
    private static string b;

    public static void Main()
    {
      string outputString = "";
      a = "Prima parte";
      b = "seconda parte";
      concatenaStringhe(a, b, out outputString);
      Console.WriteLine(outputString);
    }

    private static void concatenaStringhe(string a, string b, out string outputString)
    {
      outputString = a + ", " + b;
    }
  }
}

Tipo di ritorno

Se abbiamo delle funzioni che restituiscono un valore dobbiamo specificarne il tipo nella dichiarazione. Per i metodi che non restituiscono valori, utilizziamo la parola chiave 'void' come tipo di ritorno
Se il metodo restituisce un valore occorre utilizzare la parola chiave return.

using System;
namespace Sample
{
  public class Sample
  {
     private static string a;
     private static string b;

     public static void Main()
     {
        a = "Prima parte";
        b = "seconda parte";
        Console.WriteLine(concatenaStringhe(a, b));
     }
     private static string concatenaStringhe(string a, string b)
     {
           return a + ", " + b;
     }
  }
}

Overloading

Ogni metodo ha una propria signature che comprende il nome del metodo, il tipo di ritorno e la lista dei parametri.
Possiamo effettuare l’overloading di un metodo cambiandone la signature. Non basta cambiare il tipo di ritorno, ma occorre cambiare il tipo o il numero dei parametri.
Questo consente ad esempio di avere delle funzioni che reagiscono in modo diverso in base al tipo dei parametri passati. Vediamo un esempio:

using System;
namespace Sample
{
  public class Sample
  {

    public static void Main()
    {
      int a = 1;
      int b = 1;
      double d = 2.4;
      double e = 3.7;
      somma(a, b);
      somma(d, e);
    }

    private static void somma(int a, int b)
    {
      int c = a + b;
      Console.WriteLine("Sto eseguendo la somma di due interi");
      Console.WriteLine("risultato = " + c);
    }

    private static void somma(double d, double e)
    {
      double f = d + e;
      Console.WriteLine("Sto eseguendo la somma di due double");
      Console.WriteLine("risultato = " + f);
    }
  }
}

Output:

Sto eseguendo la somma di due interi
risultato = 2
Sto eseguendo la somma di due double
risultato = 6,1