Delegates

Delegates

Afgevaardigden definiëren een type, dat een bepaalde methodesignatuur specificeert. Een methode (statisch of instantie) die aan deze handtekening voldoet, kan worden toegewezen aan een variabele van dat type, vervolgens direct worden aangeroepen (met de juiste argumenten) of als argument zelf aan een andere methode worden doorgegeven en vervolgens worden opgeroepen. In het volgende voorbeeld ziet u hoe je een delegate declareert en gebruikt is.

Dat een object als een parameter aan een functie kan worden meegegeven, daar kijken we niet van op. Dat zijn we gewoon. Maar wat te denken van een methode? Kan een methode / functie worden meegegeven als een parameter? Niet direct, nee.

Maar (en dit is een kracht van een delegate) zijn delegate (afgevaardigde) kan in de plaats van de methode zelf worden meegegeven.

Delegates hebben de volgende eigenschappen:

• delegates zijn net als C ++ functie pointers, maar zijn type-safe;
• met delegates kunnen methoden worden doorgegeven als parameters;
• met deelnemers kunnen callback-methoden gedefiniëerd worden;
• delegates kunnen aan elkaar worden geketend; zo kunnen meerdere methoden worden opgeroepen voor één enkele event;

Delegates definiëren

Wanneer je een klasse in C # wilt gebruiken, doet je dat in twee stappen:

1. klasse definiëren, d.w.z. je definiëert de velden, eigenschappen en methoden;
2. een exemplaar, object of instantie van de klasse maken;

Delegates volgen hetzelfde proces:

1. Eerst declareer je de delegates die je wilt gebruiken. Dat houdt in dat je de compiler vertelt wat voor soort methode een delegate van dat type zal vertegenwoordigen.
2. Dan moet je op een of meer exemplaren van die delegate creëren. Achter de schermen, creëert de compiler een klasse die de delegate vertegenwoordigt.

De syntaxis voor het definiëren van een delegate is als volgt:

delegate void IntVertegenwoordiger(int x);

Hiermee declareer je een delegate met de naam IntVertegenwoordiger, en geef je aan dat elk exemplaar van deze delegate een verwijzing kan bevatten naar een methode die een int parameter aanneemt en void retourneert. Delegates zijn dus type-safe. In de declaratie van de delegate geef je de details op over de signatuur en het retourtype van de methode die de delegate vertegenwoordigt.

Om een delegate te definiëren met de naam LongVertegenwoordiger, die een methode vertegenwoordigt die twee long parameters aanneemt en een double retourneert:

delegate double LongVertegenwoordiger(long x, long y);

Om een delegate te definiëren die een string retourneert, zonder parameters:

delegate string StringVertegenwoordiger();

Om een delegate te definiëren die een Tekstbestand retourneert en een string FileName parameter aanneemt:

delegate Dal.Tekstbestand TekstbestandVertegenwoordiger(string fileName);

De syntax gelijkt op de syntax van een definitie van een methode. Maar dan zonder methodeblok en de definitie is prefixed met het trefwoord delegate. Het komt neer op het definiëren van een nieuwe klasse. Je kan dus een delegate overal definiëren waar je een klasse kan definiëren. M.a.w. zowel binnen een andere klasse, buiten een klasse, of in een namespace als een top-level object. Het bereik van een delegate, kan net zoals van een klasse, public, private, protected, enz zijn.

Een delegate definiëren komt op hetzelfde neer als een klasse definiëren. Delegates zijn klassen die afgeleid worden van de klasse System.MulticastDelegate, Die is afgeleid van de basisklasse System.Delegate. De C # compiler is zich bewust van deze klasse en gebruikt de delegate syntax om de details te verbergen
van hoe die klasse werkt.

Delegates gebruiken

We maken een klasse met de naam DelegatesAndLambdas, waarin we alle voorbeelden voor het leren werken met delegates, zullen plaatsen.

Open het project of solution met de naam Learning.

Maak een DelegatesAndLambdas klasse in de Learning namespace.

We maken een delegate type met een bepaaldesignatuur, namelijk een methode die een string parameter aanneemt en een string retourneert:

public delegate string IntToString();

On line 6, we define the implementation of the delegate by providing a method that has the exact same signature.

We definiëren de implementatie van de delegate door er een methode aan toe te kennen die dezelfde signatuur heeft:

On line 13, the method is assigned to a type that conforms to the Reverse delegate.

Finally, on line 15 we invoke the delegate passing a string to be reversed.

using System;

namespace DotNetCore.Learning
{
    public class DelegatesAndLambdas
    {
        public delegate string IntToString();
        public static void DelegatesGebruiken()
        {
            int x = 1021;
            IntToString xToString = new IntToString(x.ToString);
            Console.WriteLine("x to string: {0}", xToString()); }
    }
}

En roep die op in de Main methode van de Program klasse zoals je dat met elke andere klasse zou doen:

using System;

namespace DotNetCore.Learning
{
    class Program
    {
   

static void Main(string[] args) { /* Les 19: * Delegates en lambda's */ DelegatesAndLambdas delegatesAndLambdas = new DelegatesAndLambdas(); DelegatesAndLambdas.DelegatesGebruiken(); Console.ReadKey(); } } }

Deze code instantieert een delegate van het type IntToString en ïnitialiseert de delegate variable met een verwijzing naar de ToString methode van de integer variabele x.

In C# aanvaarden delegates altijd een ​​één-parameter-constructor. De parameter is dan de methode waarnaar de delegate verwijst. Deze methode moet overeekomen met de handtekening waarmee je de oorspronkelijk delegate gedefiniëerd hebt. Doe je dat met een methode met een andere handtekening krijg je een compilatie fout. Vermits int.ToString een instantie methode en geen static methode is, moet je zowel de instantie (x) als de naam van de methode opgeven om de delegate te initialiseren.

Ronde haakjes toevoegen aan de delegate instantie is hetzelfde als het aanroepen van de Invoke methode van de delegate klasse. Omdat xToString een variabele van een type delegate is, vervangt de C# compiler xToString door xToString.Invoke():

Console.WriteLine("x to string: {0}", xToString.Invoke());

Je kan ook gewoon de naam van het adres doorgeven i.p.v. van eerst een delegate instantie te maken:

WerkenMetDelegates.IntToString xToString = x.ToString;
Console.WriteLine("x to string met adres: {0}", xToString.Invoke());

Dit is bekend onder de naam delegate inference. Deze C # functie werkt zo lang als de compiler een delegate instantie kan terug brengen naar een bepaalde type.

Bronnen

• Delegates in C# - Attempt to look inside. Part 1 - How to understand and use delegates in your program.
• Delegates in C# - Attempt to look inside. Part 2 - Call delegates asynchronously if you need.
• Delegates in C# - Attempt to look inside. Part 3 - More about delegates. Meet the Event.
• Delegates in C# - Attempt to look inside. Part 4 - More Delegates in .NET.