Объясните мне пожалуйста принцип работы функций обратного вызова.

Полный код

Код

using System; class MyClass {     public delegate int CallbackDelegate(string arg);     public static void Main()     {         MyClass myClass = new MyClass();         CallbackDelegate myDelegate = new CallbackDelegate (myClass.MyCallbackMethod);         int result = myDelegate("Hello, World");         Console.WriteLine(result);     }                 int MyCallbackMethod(String s)     {         return s.Length;     } }

//(код не проверял)

1. Объявляется делегат:

Код

class MyClass {          public int delegate CallbackDelegate (string arg);

2. Объявляется метод с той же сигнатурой, что и делегат, т.е. с тем же возвращаемым значением и аргументами

Код

int MyCallbackMethod(String s)          {                  return s.Length;          }

3. Создается объекта класса, который содержит нужный метод

Код

MyClass myClass = new MyClass();

4. Создается сам объект-делегат, которому передается ссылка на метод

Код

CallbackDelegate myDelegate = new CallbackDelegate (myClass.MyCallbackMethod);

5. Вызывается делегат

Код

int result = delegate("Hello, World");

Делегат - это по сути дела класс, наследющий от Delegate\ При создании делегата ему передается ссылка на метод (то же самое что и в С, но "безопасное",
т.е. ссылку на метод "самому" пользовать нельзя, только через делегат). Можно передавать ссылку на статик метод, или инстанс метод, как в данном случае. Главное чтоб сигнатура совпадала.
При этом генерируется класс, содержащий ссылку на данный метод, плюс ряд вспомогательных методов, для асинхронного вызова и т п; и далее создается объект этого класса (myDelegate).
У данного объекта есть метод DynamicInvoke(), который вызывает переданный делегату метод. Для упрощения этот метод можно вызывать просто myDelegate(/*аргументы*/).
Например, то же самое, что и в примере, можно было бы сделать так

Код

int result = (int) myDelegate.DynamicInvoke(new object[] {"Hello, World"});

Сокращение позволяет рассматривать объект делегат как "метод", т.е. вызывать delegate("Hello, World").

Делегаты можно комбинировать, класс делегата может хранить ссылки на любое число методов, главное чтобы сигнатуры были одинаковы:

Код

myDelegate += new CallbackDelegate (myClass.MyCallbackMethod);         myDelegate += new CallbackDelegate (myClass.MyCallbackMethod);         myDelegate += new CallbackDelegate (myClass.MyCallbackMethod);

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

thx.

Вообще если честно, то меня интересует сам принцип. Т.е. как разработчики .NET обеспечили возможность использования делегатов. Как это рабоает на самом низком уровне.

Цитата(Pegas @ 4.7.2005, 16:29)

Т.е. как разработчики .NET обеспечили возможность использования делегатов. Как это рабоает на самом низком уровне.

Только Гейтс это знает

Хотя, можно предположить, что примерно так:

Код

using System; using System.Reflection; namespace ConsoleApplication1 {     public class MyDelegate     {         object Target;         MethodInfo Mtd;         public MyDelegate(object Target, MethodInfo Mtd)         {             this.Target = Target;             this.Mtd = Mtd;         }         public void Invoke()         {             Mtd.Invoke(Target,null);         }     }     class Class1     {         public void SomeMethod()         {             Console.WriteLine("SomeMethod called");         }         public void Test()         {             MyDelegate dlg = new MyDelegate(this,Assembly.GetExecutingAssembly().GetType("ConsoleApplication1.Class1").GetMethod("SomeMethod"));             dlg.Invoke();         }         public Class1()         {         }         [STAThread]         static void Main(string[] args)         {             Class1 cls = new Class1();             cls.Test();             Console.ReadLine();         }     } }

Для не public методов нужно ещё учесть это

Цитата

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns a null reference (Nothing in Visual Basic).

И т.п.

Хорошо, задам вопрос по другому.

Я пишу свой компилятор и разработал для него свой язык. Хочу, чтобы программисты, которые будут писать на этом языке, могли определять и использовать события, говоря по другому callback function.

Как мне это реализовать? Может кто-нибудь объяснить теорию?

Pegas
Странный вопрос.

Для реализации этого в Си используются указатели на функции. В C# - рефлекшн.

С точки зрения компилятора Си, в переменную просто сохраняется адрес в памяти, по которому находится нужная функция, в С# сохраняется какая-то информация из метаданных.

Я, похоже, просто не понимаю в чём проблема.

Это сообщение отредактировал(а) Дрон - 4.7.2005, 17:43

Цитата

С точки зрения компилятора Си, в переменную просто сохраняется адрес в памяти, по которому находится нужная функция, в С# сохраняется какая-то информация из метаданных.

В каком формате?

В Си это просто 32-битное число -- адрес
Ну и на этапе компиляции ещё сверяется соответствие типов данных (возвращаемое значение и параметры)

В C# если заглянуть в делегат, то видно, что есть поле Method - информация о вызываемом методе и Target - информация об объекте, которому принадлежит данный метод (я в примере такую штуку и реализовал без использоваия делегата). Хотя на самом деле, делегат вещь более сложная, т.к. может хранить в себе инфу о многих разных методах.

Кстати, до C# точно такая же штука была в C++ Builder и называлась closure.

Вот.
Добавлено @ 18:21
Дрон
Конкретная реализация хранения ссылки на метод в C# от нас скрыта.

Либо там хранится какой-то внутренний указатель (число). Что вероятно, но вызывает сомнения.
Либо там хранится просто описание вроде "ConsoleApplication1.Class1.SomeMethod", которого достаточно благодаря метаданным.

Это сообщение отредактировал(а) Дрон - 4.7.2005, 18:21

Вот что пишет MSDN

Цитата

Delegates enable scenarios that other languages — such as C++, Pascal, and Modula — have addressed with function pointers. Unlike C++ function pointers, however, delegates are fully object oriented, and unlike C++ pointers to member functions, delegates encapsulate both an object instance and a method. A delegate declaration defines a class that is derived from the class System.Delegate. A delegate instance encapsulates an invocation list, which is a list one or more methods, each of which is referred to as a callable entity. For instance methods, a callable entity consists of an instance and a method on that instance. For static methods, a callable entity consists of just a method. Invoking a delegate instance with an appropriate set of arguments causes each of the delegate's callable entities to be invoked with the given set of arguments.

Спасибо.