Delen via

Gedelegeerden gebruiken (C#-programmeerhandleiding)

Een gemachtigde is een type dat een methode veilig inkapselt, vergelijkbaar met een functieaanwijzer in C en C++. In tegenstelling tot C-functiepointers zijn delegates objectgeoriënteerd, typeveilig en goed beveiligd. In het volgende voorbeeld wordt een delegate gedeclareerd die een methode kan inkapselen die een tekenreeks als argument gebruikt en void retourneert.

public delegate void Callback(string message);

Een gedelegeerdeobject wordt normaal gesproken aangemaakt door de naam van de methode op te geven die de gedelegeerde omvat, of met een lambda-expressie. Een delegate kan worden aangeroepen zodra deze op deze manier is geïnstantieerd. Het aanroepen van een delegate roept de methode op die aan de delegate-klasse is gekoppeld. De parameters die door de aanroeper worden doorgegeven aan de gemachtigde, worden doorgegeven aan de methode. De gedelegeerde retourneert de retourwaarde, indien van toepassing, van de methode. Voorbeeld:

// Create a method for a delegate.
public static void DelegateMethod(string message)
{
    Console.WriteLine(message);
}

// Instantiate the delegate.
Callback handler = DelegateMethod;

// Call the delegate.
handler("Hello World");

Gedelegeerdentypen zijn afgeleid van de Delegate klasse in .NET. Gedelegeerdentypen zijn verzegeld, kunnen niet worden afgeleid van en het is niet mogelijk om aangepaste klassen af te leiden van Delegate. Omdat de geïnstantieerde gemachtigde een object is, kan deze worden doorgegeven als argument of worden toegewezen aan een eigenschap. Een methode kan een gemachtigde accepteren als parameter en de gemachtigde op een later tijdstip aanroepen. Dit wordt een asynchrone callback genoemd en is een veelgebruikte methode om een aanroeper op de hoogte te stellen wanneer een lang proces is voltooid. Wanneer een gemachtigde op deze manier wordt gebruikt, heeft de code die de gemachtigde gebruikt geen kennis nodig van de implementatie van de gebruikte methode. De functionaliteit is vergelijkbaar met de inkapselingsinterfaces.

Een ander veelvoorkomend gebruik van callbacks is het definiëren van een aangepaste vergelijkingsmethode en het doorgeven van die gemachtigde aan een sorteermethode. Hiermee kan de code van de aanroeper deel uitmaken van het sorteeralgoritmen. In de volgende voorbeeldmethode wordt het Callback type als parameter gebruikt:

public static void MethodWithCallback(int param1, int param2, Callback callback)
{
    callback("The number is: " + (param1 + param2).ToString());
}

Vervolgens kunt u de delegate die in het vorige voorbeeld is gemaakt, door te geven aan die methode.

MethodWithCallback(1, 2, handler);

En ontvang de volgende uitvoer naar de console:

The number is: 3

MethodWithCallback hoeft de console niet rechtstreeks aan te roepen. Het hoeft niet te worden ontworpen met een console in gedachten. Wat MethodWithCallback doet, is een tekenreeks voorbereiden en de tekenreeks doorgeven aan een andere methode. Een gedelegeerde methode kan een willekeurig aantal parameters gebruiken.

Wanneer een delegate is gemaakt om een instantiemethode te omhullen, verwijst de delegate naar zowel het exemplaar als de methode. Een gemachtigde heeft geen kennis van het exemplaartype, afgezien van de methode die wordt verpakt. Een gemachtigde kan verwijzen naar elk type object zolang er een methode is voor dat object dat overeenkomt met de handtekening van de gemachtigde. Wanneer een delegate is geconstrueerd om een statische methode te omhullen, verwijst deze alleen naar de methode. Houd rekening met de volgende declaraties:

public class MethodClass
{
    public void Method1(string message) { }
    public void Method2(string message) { }
}

Samen met de statische DelegateMethod weergave die eerder getoond is, hebben we nu drie methoden die u in een Callback exemplaar kunt omsluiten.

Een delegate kan meer dan één methode aanroepen wanneer deze wordt aangeroepen, dit wordt aangeduid als multicasting. Als u een extra methode wilt toevoegen aan de lijst met methoden van de gedelegeerde( de aanroeplijst), moet u gewoon twee gemachtigden toevoegen met behulp van de operatoren voor optellen of toevoegen van toewijzingen ('+' of '+='). Voorbeeld:

var obj = new MethodClass();
Callback d1 = obj.Method1;
Callback d2 = obj.Method2;
Callback d3 = DelegateMethod;

//Both types of assignment are valid.
Callback allMethodsDelegate = d1 + d2;
allMethodsDelegate += d3;

De allMethodsDelegate bevat drie methoden in de aanroeplijst ,Method1Method2 en DelegateMethod. De oorspronkelijke drie gemachtigden, d1, d2en d3, blijven ongewijzigd. Wanneer allMethodsDelegate wordt aangeroepen, worden alle drie de methoden op volgorde aangeroepen. Als de gemachtigde referentieparameters gebruikt, wordt de verwijzing opeenvolgend doorgegeven aan elk van de drie methoden en zijn eventuele wijzigingen per methode zichtbaar voor de volgende methode. Wanneer een van de methoden een uitzondering genereert die niet in de methode wordt opgevangen, wordt die uitzondering doorgegeven aan de aanroeper van de gemachtigde. Er worden geen volgende methoden in de aanroeplijst aangeroepen. Als de gemachtigde een retourwaarde en/of out-parameters heeft, retourneert deze de retourwaarde en parameters van de laatste aangeroepen methode. Als u een methode uit de aanroepingslijst wilt verwijderen, gebruikt u de aftrekoperator of aftrektoewijzingsoperator (- of -=). Voorbeeld:

//remove Method1
allMethodsDelegate -= d1;

// copy AllMethodsDelegate while removing d2
Callback oneMethodDelegate = (allMethodsDelegate - d2)!;

Omdat gedelegeerdentypen worden afgeleid van System.Delegate, kunnen de methoden en eigenschappen die door die klasse zijn gedefinieerd, worden aangeroepen voor de gemachtigde. Als u bijvoorbeeld het aantal methoden in de aanroeplijst van een gemachtigde wilt vinden, kunt u het volgende schrijven:

int invocationCount = d1.GetInvocationList().GetLength(0);

Delegates met meer dan één methode in hun aanroeplijst zijn afgeleid van MulticastDelegate, wat een subklasse is van System.Delegate. De voorgaande code werkt in beide gevallen omdat beide klassen ondersteuning bieden GetInvocationList.

Multicast-gemachtigden worden uitgebreid gebruikt bij het verwerken van gebeurtenissen. Gebeurtenisbronobjecten verzenden gebeurtenismeldingen naar ontvangerobjecten die zijn geregistreerd om die gebeurtenis te ontvangen. Voor het registreren van een gebeurtenis maakt de ontvanger een methode die is ontworpen om de gebeurtenis te verwerken, maakt vervolgens een gemachtigde voor die methode en geeft de gemachtigde door aan de gebeurtenisbron. De bron belt de gemachtigde wanneer de gebeurtenis zich voordoet. De gedelegeerde roept vervolgens de methode voor gebeurtenisafhandeling aan op de ontvanger, waarbij de gebeurtenisgegevens worden bezorgd. De gebeurtenisbron definieert het type gemachtigde voor een bepaalde gebeurtenis. Zie Gebeurtenissen voor meer informatie.

Het vergelijken van gemachtigden van twee verschillende typen die tijdens het compileren zijn toegewezen, resulteert in een compilatiefout. Als de gemachtigde instanties statisch van het type System.Delegatezijn, is de vergelijking toegestaan, maar retourneert onwaar tijdens runtime. Voorbeeld:

delegate void Callback1();
delegate void Callback2();

static void method(Callback1 d, Callback2 e, System.Delegate f)
{
    // Compile-time error.
    Console.WriteLine(d == e);

    // OK at compile-time. False if the run-time type of f
    // is not the same as that of d.
    Console.WriteLine(d == f);
}

Zie ook