Condividi tramite

Delegati con metodi denominati e anonimi (Guida per programmatori C#)

È possibile associare un delegato a un metodo denominato. Quando si crea un'istanza di un delegato usando un metodo denominato, il metodo viene passato come parametro, ad esempio:

// Declare a delegate.
delegate void WorkCallback(int x);

// Define a named method.
void DoWork(int k) { /* ... */ }

// Instantiate the delegate using the method as a parameter.
WorkCallback d = obj.DoWork;

Nell'esempio precedente viene utilizzato un metodo denominato. I delegati costruiti con un metodo denominato possono incapsulare un metodo statico o un metodo di istanza. I metodi denominati rappresentano l'unico modo per creare un'istanza di un delegato nelle versioni precedenti di C#. C# consente di creare un'istanza di un delegato e di specificare immediatamente un blocco di codice che il delegato elabora quando viene chiamato. Il blocco può contenere un'espressione lambda o un metodo anonimo, come illustrato nell'esempio seguente:

// Declare a delegate.
delegate void WorkCallback(int x);

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

La firma del metodo che viene passato come parametro del delegato deve essere uguale a quella della dichiarazione del delegato. Un'istanza del delegato può incapsulare un metodo statico o un metodo di istanza.

Nota

Anche se il delegato può usare un parametro out, è consigliabile non usarlo con delegati di eventi multicast perché non è possibile sapere quale delegato verrà chiamato.

I gruppi di metodi con un singolo sovraccarico hanno un tipo naturale . Il compilatore può dedurre il tipo restituito e i tipi di parametro per il tipo delegato:

var read = Console.Read; // Just one overload; Func<int> inferred
var write = Console.Write; // ERROR: Multiple overloads, can't choose

Esempi

L'esempio seguente è un semplice esempio di dichiarazione e uso di un delegato. Si noti che sia il delegato, MultiplyCallback, che il metodo associato, MultiplyNumbers, hanno la stessa firma

// Declare a delegate
delegate void MultiplyCallback(int i, double j);

class MathClass
{
    static void Main()
    {
        MathClass m = new MathClass();

        // Delegate instantiation using "MultiplyNumbers"
        MultiplyCallback d = m.MultiplyNumbers;

        // Invoke the delegate object.
        Console.WriteLine("Invoking the delegate using 'MultiplyNumbers':");
        for (int i = 1; i <= 5; i++)
        {
            d(i, 2);
        }

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }

    // Declare the associated method.
    void MultiplyNumbers(int m, double n)
    {
        Console.Write(m * n + " ");
    }
}
/* Output:
    Invoking the delegate using 'MultiplyNumbers':
    2 4 6 8 10
*/

Nell'esempio che segue un delegato viene mappato sia al metodo statico che al metodo di istanza e restituisce informazioni specifiche da ciascuno di essi.

// Declare a delegate
delegate void Callback();

class SampleClass
{
    public void InstanceMethod()
    {
        Console.WriteLine("A message from the instance method.");
    }

    static public void StaticMethod()
    {
        Console.WriteLine("A message from the static method.");
    }
}

class TestSampleClass
{
    static void Main()
    {
        var sc = new SampleClass();

        // Map the delegate to the instance method:
        Callback d = sc.InstanceMethod;
        d();

        // Map to the static method:
        d = SampleClass.StaticMethod;
        d();
    }
}
/* Output:
    A message from the instance method.
    A message from the static method.
*/

Vedi anche