¿Qué es una devolución de llamada y cómo se implementa en C #?

En la programación de computadoras , una devolución de llamada es un código ejecutable que se pasa como argumento a otro código.

- Wikipedia: Callback (informática)

C # tiene delegados para ese propósito. Se usan mucho con los eventos , ya que un evento puede invocar automáticamente una cantidad de delegados adjuntos (controladores de eventos).

Acabo de conocerte,
y esto es una locura,
pero aquí está mi número (delegado),
así que si pasa algo (evento), ¿
me llamas, tal vez (devolución de llamada)?

Una devolución de llamada es una función a la que se llamará cuando se termine de ejecutar una tarea específica.

El uso de una devolución de llamada suele ser en lógica asincrónica.

Para crear una devolución de llamada en C #, debe almacenar una dirección de función dentro de una variable. Esto se logra utilizando una delegateo la nueva lambda semántica 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);
    }

En C # de hoy, esto podría hacerse usando lambda como:

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

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

Definición

Una devolución de llamada es código ejecutable que se pasa como argumento a otro código.

Implementación

// 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

Enlaces

• más detalles para C #.

Una devolución de llamada es un puntero de función que pasa a otra función. La función que está llamando 'devolverá la llamada' (ejecutará) a la otra función cuando se haya completado.

Mira este enlace.

Si se refiere a devoluciones de llamada ASP.Net:

En el modelo predeterminado para las páginas web ASP.NET, el usuario interactúa con una página y hace clic en un botón o realiza alguna otra acción que resulta en una devolución de datos. La página y sus controles se vuelven a crear, el código de la página se ejecuta en el servidor y se presenta una nueva versión de la página en el navegador. Sin embargo, en algunas situaciones, es útil ejecutar el código del servidor desde el cliente sin realizar una devolución de datos. Si el script del cliente en la página mantiene cierta información de estado (por ejemplo, valores de variables locales), publicar la página y obtener una nueva copia destruye ese estado. Además, las devoluciones de página introducen gastos generales de procesamiento que pueden disminuir el rendimiento y obligar al usuario a esperar a que la página se procese y se vuelva a crear.

Para evitar perder el estado del cliente y no incurrir en la sobrecarga de procesamiento de un viaje de ida y vuelta del servidor, puede codificar una página web ASP.NET para que pueda realizar devoluciones de llamadas del cliente. En una devolución de llamada de cliente, una función de script de cliente envía una solicitud a una página web ASP.NET. La página web ejecuta una versión modificada de su ciclo de vida normal. Se inicia la página y se crean sus controles y otros miembros, y luego se invoca un método especialmente marcado. El método realiza el procesamiento que ha codificado y luego devuelve un valor al navegador que puede ser leído por otra función de script de cliente. A lo largo de este proceso, la página está en vivo en el navegador.

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

Si se refiere a devoluciones de llamada en el código:

Las devoluciones de llamada a menudo se delegan a los métodos que se llaman cuando la operación específica se ha completado o realiza una sub-acción. A menudo los encontrarás en operaciones asincrónicas. Es un principio de programación que puede encontrar en casi todos los lenguajes de codificación.

Más información aquí: http://msdn.microsoft.com/en-us/library/ms173172.aspx

Dedicación a LightStriker:
Código de muestra:

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

Explicación del código:

Creé el código para implementar la explicación divertida proporcionada por LightStriker en la respuesta anterior. Estamos pasando delegado (número) a un método ( MetYourCrush). Si el Interesado (evento) ocurre en el método ( MetYourCrush), entonces llamará al delegado (número) que tenía la referencia del CallMeBackmétodo. Entonces, CallMeBackse llamará al método. Básicamente, estamos pasando delegado para llamar al método de devolución de llamada.

Por favor hazme saber si tienes preguntas.

Probablemente no sea la definición del diccionario, pero una devolución de llamada generalmente se refiere a una función, que es externa a un objeto en particular, que se almacena y luego se llama a un evento específico.

Un ejemplo podría ser cuando se crea un botón UI, almacena una referencia a una función que realiza una acción. La acción es manejada por una parte diferente del código, pero cuando se presiona el botón, se llama a la devolución de llamada y esto invoca la acción a realizar.

C #, en lugar de usar el término 'devolución de llamada' usa 'eventos' y 'delegados' y puede encontrar más información sobre los delegados aquí .

Una devolución de llamada le permite pasar código ejecutable como argumento a otro código. En C y C ++ esto se implementa como un puntero de función. En .NET usaría un delegado para administrar punteros de función.

Algunos usos incluyen la señalización de errores y el control de si una función actúa o no.

Wikipedia

pasos de trabajo de devolución de llamada:

1) tenemos que implementar la ICallbackEventHandlerinterfaz

2) Registre el script del cliente:

 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) desde la UI, llame a Onclient, haga clic en la función JavaScript para EX: - builpopup(p1,p2,p3...)

var campo final = p1, p2, p3; UseCallBack(finalfield, ""); los datos del cliente pasaron al lado del servidor mediante UseCallBack

2) public void RaiseCallbackEvent(string eventArgument) En eventArgument obtenemos los datos pasados ​​// hacemos algunas operaciones del lado del servidor y pasamos a "callbackResult"

3) GetCallbackResult() // utilizando este método, los datos se pasarán al lado del cliente (función ReceiveServerData ())

callbackResult

4) Obtenga los datos en el lado del cliente: ReceiveServerData(text) en la respuesta del servidor de texto, obtendremos.

Los delegados hacen lo mismo que las devoluciones de llamada basadas en interfaz en C ++ (COM las utiliza), aunque son mucho más simples de usar.

Tenga en cuenta que Microsoft puso delegados en su implementación de Java (J ++) pero a Sun no le gustan [java.sun.com], así que no espere verlos en la versión oficial de Java en el corto plazo. He pirateado un preprocesador para que pueda usarlos en C ++, así que no se sienta excluido si no está programando en C # o en la plataforma .NET (es decir, en Managed C ++ o Visual Basic.NET).

Si está acostumbrado a utilizar punteros en C, un delegado es básicamente un par de punteros en uno:

• Un puntero a un objeto (opcional)
• Un puntero a un método de ese objeto

Eso significa que un solo delegado pasa toda la información necesaria para ubicar una función en su programa, ya sea un método estático o asociado con un objeto.

Los define así en C #:

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

Cuando quiera usarlos, delegue la función a la que desea llamar:

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

Si desea hacer que un delegado apunte a un método estático, simplemente se ve igual:

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

Con todo, hacen lo mismo que las devoluciones de llamada basadas en interfaz en C ++, pero causan un poco menos de problemas porque no necesita preocuparse por nombrar sus funciones o hacer objetos auxiliares, y puede hacer delegados con cualquier método. Son mas flexibles.