O que é um retorno de chamada?

139

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

cam
fonte
Você está se referindo aos retornos de chamada do ASP.Net ou delegar parâmetros de retorno de chamada?
SLaks
8
Pode significar várias coisas - em que contexto você já ouviu isso?
UpTheCreek
1
Eu acho que ele está falando sobre um Async. Callback
George Johnston
8
-1 A questão não é clara (não há detalhes suficientes).
Serhio
1
Você deve fazer perguntas definitivas ao Google.
Ozgur Dogus

Respostas:

123

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

Joey
fonte
10
na verdade, uma chamada de retorno é um ponteiro para o código executável que é passado como um argumento para outro código ... na página precisa de uma revisão
Gianluca Ghettini
8
@G_G: Não há nada que diga que precisa ser um ponteiro. Geralmente é porque o segmento de dados não é executável, mas isso é tecnicamente um detalhe de implementação.
Joey
Joey: você está certo, é um detalhe de implementação, mas mesmo o retorno de chamada é um detalhe de implementação. Você pode reescrever seu código sem usar um único retorno de chamada. É como 'while' vs 'for'.
Gianluca Ghettini
1053

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)?

LightStriker
fonte
33
Explicação totalmente legal. Vou usar essa explicação sempre que alguém perguntar, espero que eu tenha direitos de usá-la?
Nikola Davidovic
15
+1: Adoro. É ruínas da música, mas que deve ler `Mas aqui está o meu número e as instruções para o uso de um tipo específico de telefone (delegado)'
Ido Codificação
8
Aprenda a delegar com o sorriso em seu rosto :-)
Aakash
8
Melhor explicação de sempre!
zhengtonic
3
Note-se que o ensino delegado para outras pessoas com essa explicação só funciona com uma boa coreografia :)
Sébastien Sevrin
87

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));
    }
Vigilante Pierre-Alain
fonte
49

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

serhio
fonte
2
oi @serhio obrigado pela sua resposta. ainda é um pouco obscuro para mim: onde exatamente o código é passado como argumento para outro código Parece ser a adição do método Peter.Read ao delegado da criança?
BKSpurgeon
1
O link do @serhio está morto.
Jude
10

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.

TLiebe
fonte
2
Um retorno de chamada pode ser implementado como delegado a um método, mas você poderia igualmente dizer que passar um objeto que suporta um método de retorno de chamada em sua interface é um retorno de chamada.
Joe
Array.Sort (arrayObject); chamar obj.CompareTo (anotherObj) em elementos de arrayObject é um exemplo clássico de retorno de chamada usando Interface (ICompareable) em .Net.
precisa saber é o seguinte
8

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

Zyphrax
fonte
4

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.

Mani
fonte
Isso não responde adequadamente à pergunta. Você poderia explicar o que seu código está fazendo, para descrever como funciona um retorno de chamada e como ele é implementado em C #.
Adam
Oi Adam, Obrigado pela sua resposta. Eu criei o código para implementar a explicação engraçada fornecida pelo LightStriker. 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 método CallMeBack. Portanto, o método CallMeBack 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.
Mani
1

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 .

Antony Woods
fonte
0

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

David
fonte
0

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.

Ganesha
fonte
0

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.

Gomathi
fonte