Delen via

Gemachtigden met benoemde versus anonieme methoden (C#-programmeerhandleiding)

  • Artikel

Een gemachtigde kan worden gekoppeld aan een benoemde methode. Wanneer u een gemachtigde instantieert met behulp van een benoemde methode, wordt de methode doorgegeven als een parameter, bijvoorbeeld:

// 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;

Dit wordt aangeroepen met behulp van een benoemde methode. Gedelegeerden die zijn samengesteld met een benoemde methode, kunnen een statische methode of een instantiemethode inkapselen. Benoemde methoden zijn de enige manier om een gemachtigde in eerdere versies van C# te instantiëren. In een situatie waarin het maken van een nieuwe methode echter ongewenste overhead is, kunt u met C# een gemachtigde instantiëren en onmiddellijk een codeblok opgeven dat door de gemachtigde wordt verwerkt wanneer deze wordt aangeroepen. Het blok kan een lambda-expressie of een anonieme methode bevatten.

De methode die u als een gemachtigdeparameter doorgeeft, moet dezelfde handtekening hebben als de gedelegeerdedeclaratie. Een gemachtigde instantie kan een statische of instantiemethode inkapselen.

Notitie

Hoewel de gemachtigde een outparameter kan gebruiken, raden we het gebruik ervan niet aan met multicast-gebeurtenisdelegenden, omdat u niet weet welke gemachtigde wordt aangeroepen.

Vanaf C# 10 hebben methodegroepen met één overbelasting een natuurlijk type. Dit betekent dat de compiler het retourtype en parametertypen voor het gemachtigde type kan afleiden:

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

Voorbeelden

Hier volgt een eenvoudig voorbeeld van het declareren en gebruiken van een gemachtigde. U ziet dat zowel de gemachtigde als MultiplyCallbackde bijbehorende methode MultiplyNumbersdezelfde handtekening hebben

// 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
*/

In het volgende voorbeeld wordt één gemachtigde toegewezen aan zowel statische methoden als instantiemethoden en worden specifieke gegevens van elke gemachtigde geretourneerd.

// 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.
*/

Zie ook