Что такое обратный вызов и как он реализован в C #?

В компьютерном программировании обратный вызов - это исполняемый код, который передается в качестве аргумента другому коду.

- Википедия: Обратный звонок (информатика)

В C # есть делегаты для этой цели. Они активно используются с событиями , поскольку событие может автоматически вызывать ряд присоединенных делегатов (обработчиков событий).

Я только что познакомился с тобой,
и это безумие,
Но вот мой номер (делегат),
так что если что-то случится (событие),
позвони мне, может быть (обратный звонок)?

Обратный вызов - это функция, которая будет вызываться, когда процесс завершит выполнение определенной задачи.

Использование обратного вызова обычно происходит в асинхронной логике.

Чтобы создать обратный вызов в C #, вам нужно сохранить адрес функции внутри переменной. Это достигается с помощью delegateновой лямбда-семантики Funcor 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);
    }

В сегодняшнем C # это можно сделать с помощью лямбда, например:

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

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

Определение

Обратный вызов исполняемый код , который передается в качестве аргумента другого кода.

Реализация

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

Применение

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

Ссылки

• подробнее о C #.

Обратный вызов - это указатель на функцию, который вы передаете другой функции. Функция, которую вы вызываете, по завершении выполнит обратный вызов (выполнит) другую функцию.

Ознакомьтесь с этой ссылкой.

Если вы имеете в виду обратные вызовы ASP.Net:

В модели по умолчанию для веб-страниц ASP.NET пользователь взаимодействует со страницей и нажимает кнопку или выполняет какое-либо другое действие, которое приводит к обратной передаче. Страница и ее элементы управления воссоздаются, код страницы выполняется на сервере, а новая версия страницы отображается в браузере. Однако в некоторых ситуациях полезно запускать код сервера от клиента без выполнения обратной передачи. Если клиентский сценарий на странице поддерживает некоторую информацию о состоянии (например, значения локальных переменных), публикация страницы и получение ее новой копии разрушает это состояние. Кроме того, обратная передача страниц приводит к накладным расходам на обработку, которые могут снизить производительность и вынудить пользователя ждать, пока страница будет обработана и воссоздана.

Чтобы избежать потери состояния клиента и не вызывать накладных расходов на обработку, связанных с обходом сервера, вы можете закодировать веб-страницу ASP.NET, чтобы она могла выполнять обратные вызовы клиента. В обратном вызове клиента функция клиентского сценария отправляет запрос на веб-страницу ASP.NET. Веб-страница выполняет измененную версию своего обычного жизненного цикла. Страница инициируется, создаются ее элементы управления и другие элементы, а затем вызывается специально отмеченный метод. Метод выполняет закодированную вами обработку и затем возвращает браузеру значение, которое может быть прочитано другой функцией клиентского скрипта. На протяжении всего этого процесса страница отображается в браузере.

Источник: http://msdn.microsoft.com/en-us/library/ms178208.aspx

Если вы имеете в виду обратные вызовы в коде:

Обратные вызовы часто являются делегатами методов, которые вызываются, когда конкретная операция завершена или выполняет под-действие. Вы часто найдете их в асинхронных операциях. Это принцип программирования, который можно найти почти во всех языках программирования.

Больше информации здесь: http://msdn.microsoft.com/en-us/library/ms173172.aspx

Посвящение LightStriker:
Пример кода:

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

Пояснение кода:

Я создал код для реализации забавного объяснения, предоставленного LightStriker в одном из ответов выше. Мы передаем делегат (число) методу ( MetYourCrush). Если интересующее (событие) происходит в методе ( MetYourCrush), тогда он вызовет делегат (номер), который содержал ссылку на CallMeBackметод. Итак, CallMeBackметод будет вызван. По сути, мы передаем делегат для вызова метода обратного вызова.

Пожалуйста, дай мне знать, если возникнут какие-либо вопросы.

Вероятно, это не определение словаря, но обратный вызов обычно относится к функции, которая является внешней по отношению к определенному объекту, которая сохраняется и затем вызывается при определенном событии.

Примером может служить создание кнопки пользовательского интерфейса, в которой хранится ссылка на функцию, выполняющую действие. Действие обрабатывается другой частью кода, но при нажатии кнопки вызывается обратный вызов, который вызывает действие для выполнения.

В C # вместо термина «обратный вызов» используются «события» и «делегаты», и вы можете узнать больше о делегатах здесь .

Обратный вызов позволяет передавать исполняемый код в качестве аргумента другому коду. В C и C ++ это реализовано как указатель на функцию. В .NET вы должны использовать делегата для управления указателями функций.

Несколько применений включают сигнализацию об ошибках и контроль за тем, действует функция или нет.

Википедия

шаги работы обратного вызова:

1) нам нужно реализовать ICallbackEventHandlerинтерфейс

2) Зарегистрируйте клиентский скрипт:

 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) из пользовательского интерфейса вызова Onclient щелкните функцию javascript для EX: - builpopup(p1,p2,p3...)

var finalfield = p1, p2, p3; UseCallBack(finalfield, ""); данные от клиента передаются на сервер с помощью UseCallBack

2) public void RaiseCallbackEvent(string eventArgument) В eventArgument мы получаем переданные данные // выполняем некоторую операцию на стороне сервера и передаем в callbackResult

3) GetCallbackResult() // с помощью этого метода данные будут переданы на сторону клиента (функция ReceiveServerData ())

callbackResult

4) Получить данные на стороне клиента: ReceiveServerData(text) в текстовом ответе сервера мы получим.

Делегаты делают то же самое, что и обратные вызовы на основе интерфейса в C ++ (их использует COM), хотя их гораздо проще использовать.

Обратите внимание, что Microsoft поместила делегатов в свою реализацию Java (J ++), но Sun они не нравятся [java.sun.com], поэтому не ожидайте увидеть их в официальной версии Java в ближайшее время. Я собрал препроцессор, чтобы вы могли использовать их на C ++, поэтому не чувствуйте себя обделенным, если вы не программируете на C # или на платформе .NET (например, на Managed C ++ или Visual Basic.NET).

Если вы привыкли к указателям на функции в C, делегат - это, по сути, пара указателей, объединенных в один:

• Указатель на объект (необязательно)
• Указатель на метод этого объекта

Это означает, что один делегат передает всю информацию, необходимую для поиска функции в вашей программе, будь то статический метод или связанный с объектом.

Вы определяете их так в C #:

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

Когда вы хотите их использовать, вы делаете делегатом функцию, которую хотите вызвать:

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

Если вы хотите, чтобы делегат указывал на статический метод, он выглядит так же:

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

В целом, они делают то же самое, что и обратные вызовы на основе интерфейса в C ++, но вызывают немного меньше проблем, потому что вам не нужно беспокоиться об именах ваших функций или создании вспомогательных объектов, и вы можете делать делегатов из любого метода. Они более гибкие.