Was ist ein Rückruf und wie wird er in C # implementiert?

Bei der Computerprogrammierung ist ein Rückruf ausführbarer Code , der als Argument an anderen Code übergeben wird.

- Wikipedia: Rückruf (Informatik)

C # hat zu diesem Zweck Delegierte . Sie werden häufig bei Ereignissen verwendet , da ein Ereignis automatisch eine Reihe von angehängten Delegaten (Ereignishandlern) aufrufen kann.

Ich habe dich gerade getroffen,
und das ist verrückt,
aber hier ist meine Nummer (Delegierter).
Wenn also etwas passiert (Ereignis),
ruf mich vielleicht an (Rückruf)?

Ein Rückruf ist eine Funktion, die aufgerufen wird, wenn ein Prozess eine bestimmte Aufgabe ausführt.

Die Verwendung eines Rückrufs erfolgt normalerweise in asynchroner Logik.

Um einen Rückruf in C # zu erstellen, müssen Sie eine Funktionsadresse in einer Variablen speichern. Dies wird mit einer delegateoder der neuen Lambda-Semantik Funcoder erreicht Action.

    public delegate void WorkCompletedCallBack(string result);

    public void DoWork(WorkCompletedCallBack callback)
    {
        callback("Hello world");
    }

    public void Test()
    {
        WorkCompletedCallBack callback = TestCallBack; // Notice that I am referencing a method without its parameter
        DoWork(callback);
    }

    public void TestCallBack(string result)
    {
        Console.WriteLine(result);
    }

Im heutigen C # könnte dies mit Lambda wie folgt erfolgen:

    public void DoWork(Action<string> callback)
    {
        callback("Hello world");
    }

    public void Test()
    {
        DoWork((result) => Console.WriteLine(result));
    }

Definition

Ein Rückruf ist ausführbarer Code, der als Argument an anderen Code übergeben wird.

Implementierung

// Parent can Read
public class Parent
{
    public string Read(){ /*reads here*/ };
}

// Child need Info
public class Child
{
    private string information;
    // declare a Delegate
    delegate string GetInfo();
    // use an instance of the declared Delegate
    public GetInfo GetMeInformation;

    public void ObtainInfo()
    {
        // Child will use the Parent capabilities via the Delegate
        information = GetMeInformation();
    }
}

Verwendung

Parent Peter = new Parent();
Child Johny = new Child();

// Tell Johny from where to obtain info
Johny.GetMeInformation = Peter.Read;

Johny.ObtainInfo(); // here Johny 'asks' Peter to read

Links

• Weitere Details für C #.

Ein Rückruf ist ein Funktionszeiger, den Sie an eine andere Funktion übergeben. Die von Ihnen aufgerufene Funktion ruft die andere Funktion zurück, wenn sie abgeschlossen ist.

Schauen Sie sich diesen Link an.

Wenn Sie sich auf ASP.Net-Rückrufe beziehen:

Im Standardmodell für ASP.NET-Webseiten interagiert der Benutzer mit einer Seite und klickt auf eine Schaltfläche oder führt eine andere Aktion aus, die zu einem Postback führt. Die Seite und ihre Steuerelemente werden neu erstellt, der Seitencode wird auf dem Server ausgeführt und eine neue Version der Seite wird im Browser gerendert. In einigen Situationen ist es jedoch hilfreich, Servercode vom Client aus auszuführen, ohne ein Postback durchzuführen. Wenn das Client-Skript auf der Seite einige Statusinformationen (z. B. lokale Variablenwerte) verwaltet, wird dieser Status durch das Posten der Seite und das Abrufen einer neuen Kopie zerstört. Darüber hinaus führen Seiten-Postbacks zu einem Verarbeitungsaufwand, der die Leistung verringern und den Benutzer dazu zwingen kann, auf die Verarbeitung und Neuerstellung der Seite zu warten.

Um zu vermeiden, dass der Clientstatus verloren geht und kein Verarbeitungsaufwand für einen Server-Roundtrip anfällt, können Sie eine ASP.NET-Webseite so codieren, dass Client-Rückrufe ausgeführt werden können. Bei einem Client-Rückruf sendet eine Client-Skript-Funktion eine Anforderung an eine ASP.NET-Webseite. Auf der Webseite wird eine geänderte Version ihres normalen Lebenszyklus ausgeführt. Die Seite wird initiiert und ihre Steuerelemente und andere Mitglieder werden erstellt. Anschließend wird eine speziell gekennzeichnete Methode aufgerufen. Die Methode führt die von Ihnen codierte Verarbeitung durch und gibt dann einen Wert an den Browser zurück, der von einer anderen Client-Skriptfunktion gelesen werden kann. Während dieses Vorgangs befindet sich die Seite im Browser.

Quelle: http://msdn.microsoft.com/en-us/library/ms178208.aspx

Wenn Sie sich auf Rückrufe im Code beziehen:

Rückrufe sind häufig Delegaten an Methoden, die aufgerufen werden, wenn die bestimmte Operation abgeschlossen ist oder eine Unteraktion ausführt. Sie finden sie häufig in asynchronen Vorgängen. Es ist ein Programmierprinzip, das Sie in fast jeder Codierungssprache finden können.

Weitere Informationen finden Sie hier: http://msdn.microsoft.com/en-us/library/ms173172.aspx

Widmung an LightStriker:
Beispielcode:

class CallBackExample
{
    public delegate void MyNumber();
    public static void CallMeBack()
    {
        Console.WriteLine("He/She is calling you.  Pick your phone!:)");
        Console.Read();
    }
    public static void MetYourCrush(MyNumber number)
    {
        int j;
        Console.WriteLine("is she/he interested 0/1?:");
        var i = Console.ReadLine();
        if (int.TryParse(i, out j))
        {
            var interested = (j == 0) ? false : true;
            if (interested)//event
            {
                //call his/her number
                number();
            }
            else
            {
                Console.WriteLine("Nothing happened! :(");
                Console.Read();
            }
        }
    }
    static void Main(string[] args)
    {
        MyNumber number = Program.CallMeBack;
        Console.WriteLine("You have just met your crush and given your number");
        MetYourCrush(number);
        Console.Read();
        Console.Read();
    }       
}

Code Erläuterung:

Ich habe den Code erstellt, um die lustige Erklärung von LightStriker in der obigen Antwort zu implementieren. Wir übergeben delegate (number) an eine method ( MetYourCrush). Wenn das Interessierte (Ereignis) in der Methode () auftritt, MetYourCrushruft es den Delegaten (Nummer) auf, der die Referenz der CallMeBackMethode enthielt. Die CallMeBackMethode wird also aufgerufen. Grundsätzlich übergeben wir den Delegaten, um die Rückrufmethode aufzurufen.

Bitte lassen Sie mich wissen, wenn Sie Fragen haben.

Wahrscheinlich nicht die Wörterbuchdefinition, aber ein Rückruf bezieht sich normalerweise auf eine Funktion, die außerhalb eines bestimmten Objekts liegt, gespeichert und dann auf ein bestimmtes Ereignis aufgerufen wird.

Ein Beispiel könnte sein, dass beim Erstellen einer UI-Schaltfläche ein Verweis auf eine Funktion gespeichert wird, die eine Aktion ausführt. Die Aktion wird von einem anderen Teil des Codes ausgeführt. Wenn jedoch die Taste gedrückt wird, wird der Rückruf aufgerufen und die auszuführende Aktion aufgerufen.

C # verwendet nicht den Begriff "Rückruf", sondern "Ereignisse" und "Delegierte". Weitere Informationen zu Delegierten finden Sie hier .

Mit einem Rückruf können Sie ausführbaren Code als Argument an anderen Code übergeben. In C und C ++ wird dies als Funktionszeiger implementiert. In .NET würden Sie einen Delegaten verwenden, um Funktionszeiger zu verwalten.

Einige Anwendungen umfassen die Fehlersignalisierung und die Steuerung, ob eine Funktion funktioniert oder nicht.

Wikipedia

Rückruf-Arbeitsschritte:

1) Wir müssen ICallbackEventHandlerInterface implementieren

2) Registrieren Sie das Client-Skript:

 String cbReference = Page.ClientScript.GetCallbackEventReference(this, "arg", "ReceiveServerData", "context");
    String callbackScript = "function UseCallBack(arg, context)" + "{ " + cbReference + ";}";
    Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "UseCallBack", callbackScript, true);

1) Klicken Sie im UI-Aufruf Onclient auf Javascript-Funktion für EX aufrufen: - builpopup(p1,p2,p3...)

var finalfield = p1, p2, p3; UseCallBack(finalfield, ""); Daten vom Client werden mithilfe von UseCallBack an den Server übergeben

2) public void RaiseCallbackEvent(string eventArgument) In eventArgument erhalten wir die übergebenen Daten // führen eine serverseitige Operation durch und übergeben sie an "callbackResult"

3) GetCallbackResult() // Mit dieser Methode werden Daten an die Client-Seite (ReceiveServerData () -Funktion) übergeben

callbackResult

4) Holen Sie sich die Daten auf der Clientseite: ReceiveServerData(text) In der Antwort des Textservers erhalten wir.

Delegaten machen dasselbe wie schnittstellenbasierte Rückrufe in C ++ (COM verwendet diese), obwohl sie viel einfacher zu verwenden sind.

Beachten Sie, dass Microsoft Delegierte in seine Java-Implementierung (J ++) aufgenommen hat, Sun sie jedoch nicht mag [java.sun.com]. Erwarten Sie daher nicht, sie bald in der offiziellen Java-Version zu sehen. Ich habe einen Präprozessor gehackt, damit Sie sie in C ++ verwenden können. Fühlen Sie sich also nicht ausgeschlossen, wenn Sie nicht in C # oder auf der .NET-Plattform (dh in Managed C ++ oder Visual Basic.NET) programmieren.

Wenn Sie es gewohnt sind, Zeiger in C zu funktionieren, ist ein Delegat im Grunde ein Paar von Zeigern, die in einem zusammengefasst sind:

• Ein Zeiger auf ein Objekt (optional)
• Ein Zeiger auf eine Methode dieses Objekts

Das bedeutet, dass ein einzelner Delegat alle Informationen übergibt, die zum Auffinden einer Funktion in Ihrem Programm erforderlich sind, unabhängig davon, ob es sich um eine statische Methode handelt oder einem Objekt zugeordnet ist.

Sie definieren sie wie folgt in C #:

public delegate void FooCallbackType( int a, int b, int c );

Wenn Sie sie verwenden möchten, machen Sie aus der Funktion, die Sie aufrufen möchten, einen Delegaten:

class CMyClass
{
    public void FunctionToCall( int a, int b, int c )
    {
        // This is the callback
    }

    public void Foo()
    {
        FooCallbackType myDelegate = new FooCallbackType(
            this.FunctionToCall );
        // Now you can pass that to the function
        // that needs to call you back.
    }
}

Wenn Sie einen Delegaten dazu bringen möchten, auf eine statische Methode zu verweisen, sieht es genauso aus:

class CMyClassWithStaticCallback
{
    public static void StaticFunctionToCall( int a, int b, int c )
    {
        // This is the callback
    }

    public static void Foo()
    {
        FooCallbackType myDelegate = new FooCallbackType(
            CMyClass.StaticFunctionToCall );
    }
}

Alles in allem tun sie dasselbe wie schnittstellenbasierte Rückrufe in C ++, verursachen jedoch etwas weniger Probleme, da Sie sich nicht um die Benennung Ihrer Funktionen oder das Erstellen von Hilfsobjekten kümmern müssen und aus jeder Methode Delegaten erstellen können. Sie sind flexibler.