Metodi (Guida per programmatori C#)

Articolo
03/05/2013

Un metodo è un blocco di codice contenente una serie di istruzioni.Un programma provvede ad eseguire le istruzioni chiamando il metodo e specificando qualsiasi argomento richiesto dal metodo.In C# ogni istruzione viene eseguita nel contesto di un metodo.Il metodo Main è il punto di ingresso per ogni applicazione C#. Tale metodo viene chiamato dal Common Language Runtime (CLR) al momento in cui il programma viene avviato.

[!NOTA]

In questo argomento vengono illustrati i metodi denominati.Per informazioni sulle funzioni anonime, vedere Funzioni anonime (Guida per programmatori C#).

Firme di un metodo

I metodi vengono dichiarati in una classe o in una struttura specificando il livello di accesso come public o private, eventuali modificatori opzionali come abstract o sealed, il valore restituito, il nome del metodo e tutti i parametri del metodo.Queste parti rappresentano la firma del metodo.

[!NOTA]

Un tipo restituito di un metodo non fa parte della firma del metodo per gli scopi di overload dei metodi.Tuttavia, fa parte della firma del metodo quando si determina la compatibilità tra un delegato e il metodo a cui punta.

I parametri sono racchiusi tra parentesi e separati da virgole.Le parentesi vuote indicano che il metodo non richiede parametri.Questa classe contiene tre metodi:

abstract class Motorcycle
{
    // Anyone can call this.
    public void StartEngine() {/* Method statements here */ }

    // Only derived classes can call this.
    protected void AddGas(int gallons) { /* Method statements here */ }

    // Derived classes can override the base class implementation.
    public virtual int Drive(int miles, int speed) { /* Method statements here */ return 1; }

    // Derived classes must implement this.
    public abstract double GetTopSpeed(); 
}

Metodo di accesso

La chiamata a un metodo su un oggetto è simile all'accesso a un campo.Dopo il nome dell'oggetto è necessario aggiungere un punto, il nome del metodo e le parentesi.Gli argomenti sono riportati tra parentesi e separati da virgole.I metodi della classe Motorcycle possono pertanto essere chiamati come illustrato nell'esempio seguente:

class TestMotorcycle : Motorcycle
{

    public override double GetTopSpeed()
    {
        return 108.4;
    }

    static void Main()
    {

        TestMotorcycle moto = new TestMotorcycle();

        moto.StartEngine();
        moto.AddGas(15);
        moto.Drive(5, 20);
        double speed = moto.GetTopSpeed();
        Console.WriteLine("My top speed is {0}", speed);            
    }
}

Parametri del metodo VS. argomenti

La definizione del metodo specifica il nome e il tipo di qualsiasi parametro richiesto.Quando il codice chiamante effettua la chiamata del metodo, fornisce valori concreti denominati argomenti per ciascun parametro.Gli argomenti devono essere compatibili con il tipo del parametro, tuttavia il nome dell'argomento (se presente) utilizzato nel codice chiamante non deve corrispondere al nome del parametro definito nel metodo.Ad esempio:

public void Caller()
{
    int numA = 4;
    // Call with an int variable.
    int productA = Square(numA);

    int numB = 32;
    // Call with another int variable.
    int productB = Square(numB);

    // Call with an integer literal.
    int productC = Square(12);

    // Call with an expression that evaulates to int.
    productC = Square(productA * 3);
}

int Square(int i)
{
    // Store input argument in a local variable.
    int input = i;
    return input * input;
}

Passaggio per riferimento VS. il passaggio per valore

Per impostazione predefinita, quando un tipo di valore viene passato a un metodo, viene passata una copia anziché l'oggetto stesso.Pertanto, modifiche all'argomento non hanno effetto sulla copia originale nel metodo chiamante.È possibile passare un tipo-valore per riferimento tramite la parola chiave ref.Per ulteriori informazioni, vedere Passaggio di parametri di tipi di valore (Guida per programmatori C#).Per un elenco dei tipi incorporati, vedere Tabella dei tipi di valore (Riferimenti per C#).

Quando un oggetto di un tipo riferimento viene passato a un metodo, un riferimento all'oggetto passato.Ovvero il metodo riceve non l'oggetto stesso ma un argomento che indica la posizione dell'oggetto.Se si modifica un membro dell'oggetto utilizzando questo riferimento, la modifica viene riportata nell'argomento del metodo chiamante, anche se si passa l'oggetto per valore.

Creare un tipo di riferimento utilizzando la parola chiave class, come illustrato di seguito.

public class SampleRefType
{
    public int value;
}

Ora, se si passa un oggetto basato su questo tipo a un metodo, un riferimento all'oggetto passato.Nell'esempio passa un oggetto di tipo SampleRefType al metodo ModifyObject.

public static void TestRefType()
{
    SampleRefType rt = new SampleRefType();
    rt.value = 44;
    ModifyObject(rt);
    Console.WriteLine(rt.value);
}
static void ModifyObject(SampleRefType obj)
{
    obj.value = 33;
}

L'esempio è essenzialmente la stessa operazione l'esempio precedente in quanto passa un argomento per valore a un metodo.Tuttavia, poiché un tipo di riferimento viene utilizzato, il risultato sarà diverso.La modifica viene apportata in ModifyObject al campo value del parametro, obj, viene modificato il campo value dell'argomento, rt, nel metodo TestRefType.Il metodo TestRefType visualizzato 33 come output.

Per ulteriori informazioni su come passare i tipi di riferimento per riferimento e per valore, vedere Passaggio di parametri di tipi di riferimento (Guida per programmatori C#) e Tipi di riferimento (Riferimenti per C#).

Valori restituiti

I metodi possono restituire un valore al chiamante.Se il tipo restituito, ossia il tipo indicato prima del nome del metodo, non è void, il metodo può restituire il valore tramite la parola chiave return.Un'istruzione con la parola chiave return seguita da un valore che corrisponde al tipo restituito restituirà tale valore al chiamante del metodo.La parola chiave return determina anche l'interruzione dell'esecuzione del metodo.Se il tipo restituito è void, un'istruzione return senza alcun valore è comunque utile per interrompere l'esecuzione del metodo.Senza la parola chiave return, l'esecuzione del metodo viene interrotta quando viene raggiunta la fine del blocco di codice.Nei metodi con un tipo restituito non void deve essere utilizzata la parola chiave return per consentire la restituzione di un valore.Questi due metodi utilizzano ad esempio la parola chiave return per restituire interi:

class SimpleMath
{
    public int AddTwoNumbers(int number1, int number2)
    {
        return number1 + number2;
    }

    public int SquareANumber(int number)
    {
        return number * number;
    }
}

Per utilizzare un valore restituito da un metodo, il metodo chiamante può utilizzare la chiamata al metodo in qualsiasi punto in cui sarebbe sufficiente un valore dello stesso tipo.È inoltre possibile assegnare il valore restituito a una variabile.Nei due esempi di codice riportati di seguito viene ottenuto lo stesso risultato:

int result = obj.AddTwoNumbers(1, 2);
result = obj.SquareANumber(result);
// The result is 9.
Console.WriteLine(result);

result = obj.SquareANumber(obj.AddTwoNumbers(1, 2));
// The result is 9.
Console.WriteLine(result);

Utilizzo di una variabile locale, in questo caso, result, memorizzare un valore è facoltativo.Può contribuire alla leggibilità del codice, oppure potrebbe essere necessario per archiviare il valore originale dell'argomento per l'intero ambito del metodo.

Per ulteriori informazioni, vedere return (Riferimenti per C#).

Metodi di Async

Tramite la funzionalità async, è possibile richiamare i metodi asincroni senza utilizzare i callback espliciti o dividere manualmente il codice tramite i metodi o più espressioni lambda.La funzionalità async è Visual Studio 2012input.

Se si contrassegna un metodo con il modificatore async, è possibile utilizzare l'operatore attendere nel metodo.Quando il controllo raggiunge un'espressione di attesa nel metodo async, il controllo torna il chiamante e lo stato di avanzamento nel metodo viene sospeso finché l'attività attesa non completi.Quando l'attività è stata completata, l'esecuzione può riattivare il metodo.

[!NOTA]

Un metodo restituisce async al chiamante quando uno viene rilevato l'oggetto innanzitutto attesa che non è ancora completa o ottiene la fine del metodo async, qualsiasi si verifica prima.

Un metodo async può avere un tipo restituito Task<TResult>, Task, o void.Il tipo restituito void viene utilizzato principalmente per definire i gestori eventi, in cui un tipo restituito void è obbligatorio.Un metodo asincrono che restituisce void non può essere attesa e il chiamante di un metodo void- restituendo impossibile intercettare le eccezioni che il metodo genera un'eccezione.

Nell'esempio seguente, DelayAsync è un metodo async con un tipo restituito Task<TResult>.DelayAsync ha un'istruzione return che restituisce un Integer.Pertanto la dichiarazione del metodo DelayAsync deve avere un tipo restituito Task<int>.Poiché il tipo restituito è Task<int>, la valutazione di un'espressione await in DoSomethingAsync produce un Integer mentre l'istruzione seguente viene illustrato: int result = await delayTask.

Il metodo startButton_Click è un esempio di metodo async con un tipo restituito void.Poiché DoSomethingAsync è un metodo async, l'attività per la chiamata a DoSomethingAsync deve essere sospeso, come illustrato nell'istruzione seguente: await DoSomethingAsync();.Il metodo startButton_Click sia definito con il modificatore async perché il metodo è un'espressione await.

// using System.Diagnostics;
// using System.Threading.Tasks;

// This Click event is marked with the async modifier.
private async void startButton_Click(object sender, RoutedEventArgs e)
{
    await DoSomethingAsync();
}

private async Task DoSomethingAsync()
{
    Task<int> delayTask = DelayAsync();
    int result = await delayTask;

    // The previous two statements may be combined into
    // the following statement.
    //int result = await DelayAsync();

    Debug.WriteLine("Result: " + result);
}

private async Task<int> DelayAsync()
{
    await Task.Delay(100);
    return 5;
}

// Output:
//  Result: 5

Un metodo async impossibile dichiarare parametri indietro o riferimento, ma può chiamare i metodi che presentano tali parametri.

Per ulteriori informazioni sui metodi async, vedere Programmazione asincrona con Async e Await (C# e Visual Basic), Flusso di controllo in programmi asincroni (C# e Visual Basic)e Tipi restituiti asincroni (C# e Visual Basic).

Iteratori

Un iteratore esegue un'iterazione personalizzata in una raccolta, come un elenco o una matrice.Un iteratore utilizza l'istruzione prestazioni per restituire ogni elemento uno alla volta.Quando un'istruzione prestazioni viene raggiunto, la posizione corrente nel codice viene memorizzata.L'esecuzione viene riavviata da quella posizione all'iteratore verrà chiamato alla successiva.

Chiama un iteratore dal codice client utilizzando un'istruzione l'istruzione foreach.

Il tipo restituito di iteratore può essere IEnumerable, IEnumerable<T>, IEnumerator, o IEnumerator<T>.

Per ulteriori informazioni, vedere Iteratori (C# e Visual Basic).

Specifiche del linguaggio C#

Per ulteriori informazioni, vedere la Specifiche del linguaggio C#. La specifica del linguaggio è la fonte ufficiale per la sintassi e l'utilizzo di C#.