Questa documentazione è stata archiviata e non viene gestita.

Metodi anonimi (Guida per programmatori C#)

Nelle versioni di C# precedenti alla 2.0 era possibile dichiarare un delegato solo tramite metodi denominati. In C# 2.0 sono stati introdotti i metodi anonimi.

La creazione di metodi anonimi consente essenzialmente di passare un blocco di codice come parametro del delegato. Esempio:

// Create a handler for a click event
button1.Click += delegate(System.Object o, System.EventArgs e)
                   { System.Windows.Forms.MessageBox.Show("Click!"); };

oppure

// Create a delegate instance
delegate void Del(int x);

// Instantiate the delegate using an anonymous method
Del d = delegate(int k) { /* ... */ };

Utilizzando i metodi anonimi si riduce l'overhead della codifica nella creazione di istanze dei delegati, eliminando la necessità di creare un metodo separato.

La specifica di un blocco di codice al posto di un delegato può risultare utile nelle situazioni in cui la necessità di creare un metodo potrebbe sembrare un overhead inutile, ad esempio quando viene avviato un nuovo thread. Questa classe crea un thread e contiene anche il codice eseguito dal thread, senza richiedere la creazione di un metodo aggiuntivo per il delegato.

void StartThread()
{
    System.Threading.Thread t1 = new System.Threading.Thread
      (delegate()
            {
                System.Console.Write("Hello, ");
                System.Console.WriteLine("World!");
            });
    t1.Start();
}

L'ambito dei parametri di un metodo anonimo è anonymous-method-block.

È errato inserire nel blocco di metodo anonimo un'istruzione di salto, ad esempio goto, break o continue la cui destinazione è esterna al blocco. È altresì errato inserire all'esterno del blocco di metodo anonimo un'istruzione di salto, ad esempio goto, break o continue, la cui destinazione è interna al blocco.

Le variabili e i parametri locali il cui ambito contiene una dichiarazione di metodo anonimo sono denominati variabili esterne o acquisite del metodo anonimo. Nel segmento di codice riportato di seguito, ad esempio, n è una variabile esterna:

int n = 0;
Del d = delegate() { System.Console.WriteLine("Copy #:{0}", ++n); };

A differenza delle variabili locali, la durata della variabile esterna si estende finché i delegati che fanno riferimento ai metodi anonimi non diventano adatti per la Garbage Collection. Al momento della creazione del delegato viene acquisito un riferimento a n.

Un metodo anonimo non può accedere ai parametri ref o out di un ambito esterno.

All'interno di anonymous-method-block non è possibile accedere a codice unsafe.

Nell'esempio riportato di seguito sono illustrati i due modi disponibili per la creazione di un'istanza di un delegato:

  • Associazione del delegato con un metodo anonimo.

  • Associazione del delegato con un metodo denominato (DoWork).

In ogni caso quando il delegato viene richiamato verrà visualizzato un messaggio.

// Declare a delegate
delegate void Printer(string s);

class TestClass
{
    static void Main()
    {
        // Instatiate the delegate type using an anonymous method:
        Printer p = delegate(string j)
        {
            System.Console.WriteLine(j);
        };

        // Results from the anonymous delegate call:
        p("The delegate using the anonymous method is called.");

        // The delegate instantiation using a named method "DoWork":
        p = new Printer(TestClass.DoWork);

        // Results from the old style delegate call:
        p("The delegate using the named method is called.");
    }

    // The method associated with the named delegate:
    static void DoWork(string k)
    {
        System.Console.WriteLine(k);
    }
}

The delegate using the anonymous method is called.

The delegate using the named method is called.

Mostra: