Che cos'è un callback e come viene implementato in C #?

Nella programmazione per computer , un callback è un codice eseguibile che viene passato come argomento ad altro codice.

- Wikipedia: Callback (informatica)

C # ha delegati a tale scopo. Sono ampiamente utilizzati con gli eventi , in quanto un evento può invocare automaticamente un numero di delegati collegati (gestori di eventi).

Ti ho appena incontrato,
E questo è pazzo,
ma ecco il mio numero (delegato),
quindi se succede qualcosa (evento),
chiamami, forse (richiamata)?

Un callback è una funzione che verrà chiamata quando un processo viene eseguito eseguendo un'attività specifica.

L'uso di un callback è di solito in logica asincrona.

Per creare un callback in C #, è necessario memorizzare un indirizzo di funzione all'interno di una variabile. Questo si ottiene usando uno delegateo il nuovo lambda semantico Funco 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);
    }

Oggi in C #, questo potrebbe essere fatto usando lambda come:

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

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

Definizione

Un callback è un codice eseguibile che viene passato come argomento ad altro codice.

Implementazione

// 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();
    }
}

uso

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

link

• maggiori dettagli per C #.

Un callback è un puntatore a funzione che si passa a un'altra funzione. La funzione che stai chiamando 'callback' (eseguirà) l'altra funzione una volta completata.

Dai un'occhiata a questo link.

Se ti riferisci ai callback ASP.Net:

Nel modello predefinito per le pagine Web ASP.NET, l'utente interagisce con una pagina e fa clic su un pulsante o esegue qualche altra azione che provoca un postback. La pagina e i relativi controlli vengono ricreati, il codice della pagina viene eseguito sul server e viene visualizzata una nuova versione della pagina nel browser. Tuttavia, in alcune situazioni, è utile eseguire il codice server dal client senza eseguire un postback. Se lo script client nella pagina mantiene alcune informazioni sullo stato (ad esempio, i valori delle variabili locali), pubblicare la pagina e ottenerne una nuova copia distrugge tale stato. Inoltre, i postback di pagina introducono un sovraccarico di elaborazione che può ridurre le prestazioni e costringere l'utente ad attendere che la pagina venga elaborata e ricreata.

Per evitare di perdere lo stato del client e non incorrere nel sovraccarico di elaborazione di un roundtrip del server, è possibile codificare una pagina Web ASP.NET in modo che possa eseguire callback client. In una richiamata client, una funzione di script client invia una richiesta a una pagina Web ASP.NET. La pagina Web esegue una versione modificata del suo normale ciclo di vita. La pagina viene avviata e vengono creati i suoi controlli e altri membri, quindi viene richiamato un metodo appositamente contrassegnato. Il metodo esegue l'elaborazione che è stata codificata e quindi restituisce un valore al browser che può essere letto da un'altra funzione di script client. Durante questo processo, la pagina è attiva nel browser.

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

Se ti riferisci ai callback nel codice:

I callback sono spesso delegati ai metodi chiamati quando l'operazione specifica è stata completata o esegue un'azione secondaria. Li troverai spesso in operazioni asincrone. È un principio di programmazione che puoi trovare in quasi tutti i linguaggi di programmazione.

Maggiori informazioni qui: http://msdn.microsoft.com/en-us/library/ms173172.aspx

Dedizione a LightStriker:
Codice di esempio:

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();
    }       
}

Spiegazione del codice:

Ho creato il codice per implementare la divertente spiegazione fornita da LightStriker nella precedente delle risposte. Stiamo passando delegato (numero) a un metodo ( MetYourCrush). Se l'interessato (evento) si verifica nel metodo ( MetYourCrush), chiamerà il delegato (numero) che conteneva il riferimento del CallMeBackmetodo. Quindi, CallMeBackverrà chiamato il metodo. Fondamentalmente, stiamo passando delegato per chiamare il metodo di callback.

Per favore fatemi sapere se avete domande.

Probabilmente non la definizione del dizionario, ma un callback di solito si riferisce a una funzione, che è esterna a un particolare oggetto, che viene memorizzata e quindi chiamata su un evento specifico.

Un esempio potrebbe essere quando viene creato un pulsante UI, che memorizza un riferimento a una funzione che esegue un'azione. L'azione è gestita da una parte diversa del codice ma quando si preme il pulsante, viene richiamato il callback e questo richiama l'azione da eseguire.

C #, piuttosto che usare il termine 'callback' usa 'eventi' e 'delegati' e puoi scoprire di più sui delegati qui .

Un callback consente di passare il codice eseguibile come argomento ad altro codice. In C e C ++ questo è implementato come puntatore a funzione. In .NET useresti un delegato per gestire i puntatori a funzione.

Alcuni usi includono la segnalazione di errori e il controllo dell'azione o meno di una funzione.

Wikipedia

fasi di lavoro di callback:

1) dobbiamo implementare l' ICallbackEventHandlerinterfaccia

2) Registrare lo script client:

 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) dalla chiamata dell'interfaccia utente Fare clic su Onclient per chiamare la funzione javascript per EX: - builpopup(p1,p2,p3...)

var finalfield = p1, p2, p3; UseCallBack(finalfield, ""); dati dal client passati al lato server utilizzando UseCallBack

2) public void RaiseCallbackEvent(string eventArgument) In eventArgument otteniamo i dati passati // eseguiamo alcune operazioni sul lato server e passiamo a "callbackResult"

3) GetCallbackResult() // utilizzando questo metodo i dati verranno passati al lato client (funzione ReceiveServerData ())

callbackResult

4) Ottieni i dati sul lato client:, ReceiveServerData(text) nella risposta del server di testo, otterremo.

I delegati fanno la stessa cosa dei callback basati su interfaccia in C ++ (COM li usa), sebbene siano molto più semplici da usare.

Nota che Microsoft ha inserito i delegati nella sua implementazione Java (J ++) ma a Sun non piacciono [java.sun.com], quindi non aspettarti di vederli presto nella versione ufficiale di Java. Ho hackerato insieme un preprocessore per consentirti di usarli in C ++, quindi non sentirti escluso se non stai programmando in C # o sulla piattaforma .NET (cioè in Managed C ++ o Visual Basic.NET).

Se sei abituato a far funzionare i puntatori in C, un delegato è fondamentalmente una coppia di puntatori raggruppati in uno:

• Un puntatore a un oggetto (opzionale)
• Un puntatore a un metodo di quell'oggetto

Ciò significa che un singolo delegato passa tutte le informazioni necessarie per individuare una funzione nel programma, che si tratti di un metodo statico o associato a un oggetto.

Li definisci così in C #:

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

Quando si desidera utilizzarli, si rende delegato dalla funzione che si desidera chiamare:

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.
    }
}

Se vuoi fare in modo che un delegato punti a un metodo statico, sembra proprio lo stesso:

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 );
    }
}

Tutto sommato, fanno la stessa cosa dei callback basati su interfaccia in C ++, ma causano un po 'meno problemi perché non devi preoccuparti di nominare le tue funzioni o creare oggetti helper e puoi fare delegati con qualsiasi metodo. Sono più flessibili.