Instantier og aktivér stedfortrædertyper

10 minutter

Stedfortrædertyper implementeres ved hjælp af følgende proces:

Deklarer stedfortræderen: Definer en stedfortrædertype med en bestemt signatur, som omfatter returtypen og parametrene.
Instantier stedfortræderen: Opret en forekomst af stedfortrædertypen, der angiver den metode, der skal kaldes.
Aktivér stedfortræderen: Kald stedfortræderforekomsten, og viderebringe eventuelle påkrævede argumenter.

Når en navngivet stedfortræder er erklæret, kan du oprette forekomster af denne stedfortrædertype og bruge dem til at kalde metoder, der svarer til stedfortræderens signatur. Hver forekomst af stedfortræderen kan pege på en anden metode, hvilket giver mulighed for aktivering af fleksible og dynamiske metoder. Derudover kan stedfortrædere kombineres for at oprette multicast-stedfortrædere, hvilket gør det muligt at aktivere flere metoder i et enkelt kald.

Når en stedfortræder aktiveres, kalder den den eller de metoder, den peger på, og overfører eventuelle argumenter, der er angivet i stedfortræderens signatur.

Instantier og aktivér stedfortrædere

Stedfortrædere kan instantieres ved hjælp af navngivne metoder, konvertering af metodegrupper, anonyme metoder eller lambda-udtryk. Valget af instantieringsmetode afhænger af den specifikke use case og det ønskede niveau af læsbarhed og vedligeholdelse.

Instantier stedfortrædere med navngivne metoder

Navngivne metoder defineres med et bestemt navn og kan genbruges. Det er nyttigt at bruge navngivne metoder, når du vil oprette en forekomst af stedfortræderen, der peger på en bestemt metode. Navngivne metoder defineres typisk i en klasse eller struktur og kan være statiske metoder eller forekomstmetoder.


public delegate void Notify(string message);

public class Program
{
    public static void Main()
    {
        // Create an instance of the delegate using a named method
        Notify notify = new Notify(NotificationService.SendNotification);

        // Invoke the delegate
        notify("Hello, World!");
    }
}

public static class NotificationService
{
    // Method that matches the delegate's signature
    public static void SendNotification(string message)
    {
        Console.WriteLine("Notification sent: " + message);
    }
}

Dette eksempel viser, hvordan du opretter en stedfortrædertype Notify , der tager en strengparameter og returnerer void. Metoden SendNotification svarer til stedfortræderens signatur, så den kan tildeles til stedfortræderforekomsten. Når stedfortræderen aktiveres, kalder den SendNotification metoden med den angivne meddelelse.

Instantier stedfortrædere med konvertering af metodegruppe

Konvertering af metodegrupper er en oversigt over, hvordan du opretter en forekomst af stedfortræderen ved direkte at referere til en metode uden eksplicit at oprette en stedfortræderforekomst. Det er nyttigt at bruge konvertering af metodegrupper, når du vil oprette en forekomst af stedfortræderen, der peger på en bestemt metode, uden at der er behov for en eksplicit stedfortræderkonstruktør. Konvertering af metodegruppe giver dig mulighed for at tildele en metode direkte til en stedfortrædertype uden eksplicit at oprette en stedfortræderforekomst. Denne mulighed er nyttig, når metodesignaturen svarer til stedfortræderens signatur, da den giver mulighed for renere og mere præcis kode.


public delegate void Notify(string message);

public class Program
{
    public static void Main()
    {
        // Create an instance of the delegate using a method group conversion for a named method
        Notify notifyMethodGroup = NotificationService.SendNotification;

        // Invoke the delegate
        notifyMethodGroup("Hello from Method Group!");

    }
}

public static class NotificationService
{
    // Method that matches the delegate's signature
    public static void SendNotification(string message)
    {
        Console.WriteLine("Notification sent: " + message);
    }
}

I dette eksempel vises det, hvordan du opretter en stedfortræderforekomst ved hjælp af en metodegruppekonvertering. Metoden SendNotification tildeles direkte til stedfortræderforekomsten notifyMethodGroup, hvilket gør det muligt at aktivere den med en meddelelse. Når stedfortræderen aktiveres, kalder den SendNotification metoden med den angivne meddelelse.

Instantier stedfortrædere med anonyme metoder

Anonyme metoder giver dig mulighed for at definere en indbygget metode uden eksplicit at navngive den. Denne mulighed er nyttig til kortvarige handlinger, eller når du vil definere funktionsmåden direkte på brugspunktet. Anonyme metoder kan bruges til at oprette stedfortræderforekomster uden at definere en separat metode. Brug af anonyme metoder giver mulighed for mere præcis kode og kan forbedre læsbarheden i visse scenarier.


public delegate void Notify(string message);

public class Program
{
    public static void Main()
    {
        // Create an instance of the delegate using an anonymous method
        Notify notifyAnonymous = delegate (string message) { Console.WriteLine("Anonymous notification: " + message); };

        // Invoke the delegate
        notifyAnonymous("Hello from Anonymous Method!");

    }
}

I dette eksempel vises det, hvordan du opretter en stedfortræderforekomst ved hjælp af en anonym metode. Den anonyme metode delegate (string message) { Console.WriteLine("Anonymous notification: " + message); } definerer funktionsmåden for den indbyggede stedfortræder, så den kan aktiveres med en meddelelse. Når stedfortræderen aktiveres, udføres den kode, der er defineret i den anonyme metode.

Instantier stedfortrædere med lambda-udtryk

Lambda-udtryk er en præcis måde at definere anonyme metoder på. De giver dig mulighed for at oprette stedfortræderforekomster uden eksplicit at definere en metode. Denne mulighed er nyttig til kortvarige handlinger, eller når du vil definere funktionsmåden direkte på brugspunktet.


public delegate void Notify(string message);

public class Program
{
    public static void Main()
    {
        // Create an instance of the delegate using a lambda expression
        Notify notifyLambda = (message) => Console.WriteLine("Lambda notification: " + message);

        // Invoke the delegate
        notifyLambda("Hello from Lambda!");
    }
}

Dette eksempel viser, hvordan du opretter en stedfortræderforekomst ved hjælp af et lambda-udtryk. Lambda-udtrykket (message) => Console.WriteLine("Lambda notification: " + message) definerer funktionsmåden for den indbyggede stedfortræder, hvilket gør det muligt at aktivere det med en meddelelse. Når stedfortræderen aktiveres, udføres den kode, der er defineret i lambda-udtrykket.

Aktivér enkelt- og multicast-stedfortrædere

Stedfortrædere kan aktiveres som almindelige metoder. Når en stedfortræder aktiveres, kalder den den eller de metoder, den peger på, og overfører eventuelle argumenter, der er angivet i stedfortræderens signatur. Aktiveringen af en stedfortræder svarer til at kalde en metode direkte.

Stedfortrædere kan kombineres for at oprette multicast-stedfortrædere, hvilket gør det muligt at aktivere flere metoder i et enkelt kald. Muligheden for at multicast er nyttig, når du vil udføre flere handlinger, f.eks. give flere hændelsesabonenter besked eller udføre flere metoder i en bestemt rækkefølge.

Flere objekter kan tildeles til én stedfortræderforekomst ved hjælp af operatoren + . Multicast-stedfortræderen indeholder en liste over de tildelte stedfortrædere. Når multicast-stedfortræderen kaldes, aktiveres stedfortræderne på listen i rækkefølge. Det er kun stedfortrædere af samme type, der kan kombineres.

Operatoren - kan bruges til at fjerne en komponentstedfortræder fra en multicast-stedfortræder.

I følgende eksempel vises det, hvordan du kombinerer stedfortrædere ved hjælp af operatoren + og fjerner en stedfortræder ved hjælp af operatoren - :


using System;

namespace DelegateExamples;

// Define a custom delegate that has a string parameter and returns void.
delegate void CustomCallback(string s);

class TestClass
{
    // Define two methods that have the same signature as CustomCallback.
    static void Hello(string s)
    {
        Console.WriteLine($"  Hello, {s}!");
    }

    static void Goodbye(string s)
    {
        Console.WriteLine($"  Goodbye, {s}!");
    }

    static void Main()
    {
        // Declare instances of the custom delegate.
        CustomCallback hiDel, byeDel, multiDel, multiMinusHiDel;

        // Initialize the delegate object hiDel that references the
        // method Hello.
        hiDel = Hello;

        // Initialize the delegate object byeDel that references the
        // method Goodbye.
        byeDel = Goodbye;

        // The two delegates, hiDel and byeDel, are combined to
        // form multiDel.
        multiDel = hiDel + byeDel;

        // Remove hiDel from the multicast delegate, leaving byeDel,
        // which calls only the method Goodbye.
        multiMinusHiDel = (multiDel - hiDel)!;

        Console.WriteLine("Invoking delegate hiDel:");
        hiDel("Elize Harmsen");

        Console.WriteLine("Invoking delegate byeDel:");
        byeDel("Mattia Trentini");

        Console.WriteLine("Invoking delegate multiDel:");
        multiDel("Peter Zammit");

        Console.WriteLine("Invoking delegate multiMinusHiDel:");
        multiMinusHiDel("Lennart Kangur");
    }
}

/* Output:
Invoking delegate hiDel:
  Hello, Elize Harmsen!
Invoking delegate byeDel:
  Goodbye, Mattia Trentini!
Invoking delegate multiDel:
  Hello, Peter Zammit!
  Goodbye, Peter Zammit!
Invoking delegate multiMinusHiDel:
  Goodbye, Lennart Kangur!
*/

I dette eksempel vises det, hvordan du opretter en multicast-stedfortræder ved at kombinere to stedfortrædere (hiDel og byeDel) ved hjælp af operatoren + . Den kombinerede stedfortræder (multiDel) aktiverer begge metoder, når den kaldes. Operatoren - bruges til at fjerne en af stedfortræderne fra multicast-stedfortræderen, så det kun er den anden stedfortræder, der aktiveres.

Outputtet viser resultaterne af aktiveringen af hver stedfortræder og demonstrerer, hvordan multicast-stedfortræderen fungerer.

Almindelige scenarier for brug af stedfortrædere

Stedfortrædere er alsidige og kan bruges i forskellige scenarier til at forbedre kodefleksibiliteten og vedligeholdelsen. De er nyttige i situationer, hvor du skal overføre metoder som parametre, implementere tilbagekaldsmekanismer eller oprette hændelseshandlere.

Her er nogle almindelige scenarier, hvor stedfortrædere bruges:

Sortering og filtrering: Stedfortrædere kan bruges til at overføre sammenligningsfunktioner til sorterings- og filtreringsmetoder. Denne proces giver dig mulighed for dynamisk at angive kriterierne for sortering eller filtrering af en samling objekter. Du kan f.eks. sortere en liste over bankkunder efter forskellige kriterier, f.eks. navn, kontosaldo eller kunde-id.
Tilbagekaldsmetoder: Stedfortrædere bruges ofte til at implementere tilbagekaldsmetoder. Denne funktion er nyttig i scenarier, hvor en metode skal kalde en anden metode, når en bestemt handling er fuldført. Du kan f.eks. bruge en stedfortræder til at give besked om fuldførelsen af en databehandlingsopgave.
Asynkron programmering: Stedfortrædere bruges til at aktivere asynkrone metoder. Denne funktion er nyttig til at udføre opgaver, der kan tage lang tid at fuldføre, f.eks. fil-I/O-handlinger eller netværksanmodninger. Stedfortrædere giver dig mulighed for at angive den metode, der skal kaldes, når den asynkrone handling er fuldført.
Hændelseshåndtering: Stedfortrædere er grundlaget for hændelser i C#. De giver dig mulighed for at definere hændelseshandlere, der kan aktiveres, når en hændelse opstår. I et bankprogram kan du f.eks. bruge stedfortrædere til at give kunderne besked, når en transaktion er fuldført.
Implementering af designmønstre: Stedfortrædere bruges i forskellige designmønstre, f.eks. strategimønsteret, hvor du dynamisk kan ændre funktionsmåden for en metode på kørselstidspunktet ved at overføre forskellige implementeringer af stedfortrædere.

Bemærk

Scenariet for hændelseshåndtering dækkes i et separat modul sammen med en introduktion til brug af hændelser i C#-apps.

Nøglepunkter

Stedfortræderforekomster kan oprettes ved hjælp af navngivne metoder, konvertering af metodegrupper, anonyme metoder eller lambda-udtryk.
Stedfortrædere kan aktiveres som almindelige metoder og kan kombineres for at oprette multicast-stedfortrædere.
Stedfortrædere bruges i forskellige scenarier, herunder sortering og filtrering, tilbagekaldsmetoder, asynkron programmering, hændelseshåndtering og implementering af designmønstre.

Feedback

Var denne side nyttig?