O que é um retorno de chamada e como ele é implementado em C #?

Na programação de computadores , um retorno de chamada é um código executável que é passado como argumento para outro código.

- Wikipedia: Callback (ciência da computação)

C # tem delegados para esse fim. Eles são muito usados ​​com eventos , pois um evento pode invocar automaticamente vários delegados conectados (manipuladores de eventos).

Acabei de conhecê-lo,
e isso é loucura,
mas aqui está o meu número (delegado),
Então , se algo acontecer (evento),
me ligue, talvez (retorno)?

Um retorno de chamada é uma função que será chamada quando um processo terminar de executar uma tarefa específica.

O uso de um retorno de chamada geralmente ocorre na lógica assíncrona.

Para criar um retorno de chamada em C #, você precisa armazenar um endereço de função dentro de uma variável. Isso é obtido usando uma delegateou a nova semântica Funcou lambda 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);
    }

No C # atual, isso poderia ser feito usando lambda como:

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

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

Definição

Um retorno de chamada é um código executável que é passado como argumento para outro código.

Implementação

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

Ligações

• mais detalhes para C #.

Um retorno de chamada é um ponteiro de função que você passa para outra função. A função que você está chamando retornará a chamada (execução) da outra função quando ela estiver concluída.

Confira este link.

Se você está se referindo aos retornos de chamada do ASP.Net:

No modelo padrão para páginas da Web do ASP.NET, o usuário interage com uma página e clica em um botão ou executa alguma outra ação que resulta em uma postagem. A página e seus controles são recriados, o código da página é executado no servidor e uma nova versão da página é renderizada no navegador. No entanto, em algumas situações, é útil executar o código do servidor a partir do cliente sem executar uma postagem. Se o script do cliente na página estiver mantendo algumas informações de estado (por exemplo, valores de variáveis ​​locais), publicar a página e obter uma nova cópia dela destrói esse estado. Além disso, as postagens da página introduzem uma sobrecarga de processamento que pode diminuir o desempenho e forçar o usuário a aguardar o processamento e a recriação da página.

Para evitar a perda do estado do cliente e não incorrer na sobrecarga de processamento de uma ida e volta do servidor, você pode codificar uma página da Web ASP.NET para que ele possa executar retornos de chamada do cliente. Em um retorno de chamada do cliente, uma função de script do cliente envia uma solicitação para uma página da Web do ASP.NET. A página da Web executa uma versão modificada de seu ciclo de vida normal. A página é iniciada e seus controles e outros membros são criados e, em seguida, um método especialmente marcado é chamado. O método executa o processamento que você codificou e, em seguida, retorna um valor para o navegador que pode ser lido por outra função de script do cliente. Durante todo esse processo, a página está ativa no navegador.

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

Se você está se referindo a retornos de chamada no código:

Os retornos de chamada geralmente são delegados a métodos chamados quando a operação específica é concluída ou executa uma sub-ação. Você as encontrará frequentemente em operações assíncronas. É um princípio de programação que você pode encontrar em quase todas as linguagens de codificação.

Mais informações aqui: http://msdn.microsoft.com/en-us/library/ms173172.aspx

Dedicação ao LightStriker:
Código de exemplo:

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

Código Explicação:

Eu criei o código para implementar a explicação engraçada fornecida pelo LightStriker na resposta acima. Estamos passando delegate (number) para um método ( MetYourCrush). Se o Interessado (evento) ocorrer no método ( MetYourCrush), ele chamará o delegado (número) que estava mantendo a referência do CallMeBackmétodo. Então, o CallMeBackmétodo será chamado. Basicamente, estamos passando o delegado para chamar o método de retorno de chamada.

Por favor, deixe-me saber se você tem alguma dúvida.

Provavelmente não é a definição do dicionário, mas um retorno de chamada geralmente se refere a uma função que é externa a um objeto específico, sendo armazenada e depois chamada a um evento específico.

Um exemplo pode ser quando um botão da interface do usuário é criado, ele armazena uma referência a uma função que executa uma ação. A ação é manipulada por uma parte diferente do código, mas quando o botão é pressionado, o retorno de chamada é chamado e isso invoca a ação a ser executada.

C #, em vez de usar o termo 'retorno de chamada' usa 'eventos' e 'delegados' e você pode descobrir mais sobre delegados aqui .

Um retorno de chamada permite passar o código executável como argumento para outro código. Em C e C ++, isso é implementado como um ponteiro de função. No .NET, você usaria um delegado para gerenciar ponteiros de função.

Alguns usos incluem sinalização de erro e controle se uma função atua ou não.

Wikipedia

etapas do trabalho de retorno de chamada:

1) temos que implementar ICallbackEventHandlerinterface

2) Registre o script do 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) da interface do usuário chamada Onclient clique na função javascript de chamada para EX: - builpopup(p1,p2,p3...)

var campo final = p1, p2, p3; UseCallBack(finalfield, ""); dados do cliente transmitidos para o lado do servidor usando UseCallBack

2) public void RaiseCallbackEvent(string eventArgument) No eventArgument, obtemos os dados passados ​​// realizamos alguma operação no servidor e passamos para "callbackResult"

3) GetCallbackResult() // usando esse método, os dados serão passados ​​para o lado do cliente (função ReceiveServerData ())

callbackResult

4) Obtenha os dados no lado do cliente: ReceiveServerData(text) na resposta do servidor de texto, obteremos.

Os delegados fazem o mesmo que os retornos de chamada baseados em interface em C ++ (o COM usa esses), embora sejam muito mais simples de usar.

Observe que a Microsoft colocou delegados em sua implementação Java (J ++), mas a Sun não gosta deles [java.sun.com], portanto, não espere vê-los na versão oficial do Java tão cedo. Eu hackeei um pré-processador para deixá-lo usá-lo em C ++; portanto, não fique de fora se não estiver programando em C # ou na plataforma .NET (ou seja, em Managed C ++ ou Visual Basic.NET).

Se você está acostumado a funcionar com ponteiros em C, um delegado é basicamente um par de ponteiros reunidos em um:

• Um ponteiro para um objeto (opcional)
• Um ponteiro para um método desse objeto

Isso significa que um único delegado passa todas as informações necessárias para localizar uma função no seu programa, seja um método estático ou associado a um objeto.

Você os define assim em C #:

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

Quando você deseja usá-los, você delega a função que deseja chamar:

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 você deseja fazer um delegado apontar para um método estático, é o mesmo:

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

Em suma, eles fazem o mesmo que retornos de chamada baseados em interface em C ++, mas causam um pouco menos de problemas, porque você não precisa se preocupar em nomear suas funções ou criar objetos auxiliares, e você pode fazer delegados de qualquer método. Eles são mais flexíveis.