Язык программирования C#9 и платформа .NET5. Страница 234

// Этот делегат может указывать на любой метод, который принимает

// два целочисленных значения и возвращает целочисленное значение.

public delegate int BinaryOp(int x, int y);

Когда компилятор C# обрабатывает тип делегата, он автоматически генерирует запечатанный (

sealed
) класс, производный от
System.MulticastDelegate
. Этот класс (в сочетании со своим базовым классом
System.Delegate
) предоставляет необходимую инфраструктуру для делегата, которая позволяет хранить список методов, подлежащих вызову в будущем. Например, если вы изучите делегат
BinaryOp
с помощью утилиты
ildasm.exe
, то обнаружите показанные ниже детали (вскоре вы построите полный пример):

//     -------------------------------------------------------

//     TypDefName: SimpleDelegate.BinaryOp

//     Extends   : System.MulticastDelegate

//     Method #1

//     -------------------------------------------------------

//             MethodName: .ctor

//             ReturnType: Void

//             2 Arguments

//                     Argument #1:  Object

//                     Argument #2:  I

//     Method #2

//     -------------------------------------------------------

//             MethodName: Invoke

//             ReturnType: I4

//             2 Arguments

//                     Argument #1:  I4

//                     Argument #2:  I4

//             2 Parameters

//                     (1) ParamToken : Name : x flags: [none]

//                     (2) ParamToken : Name : y flags: [none] //

//     Method #3

//     -------------------------------------------------------

//             MethodName: BeginInvoke

//             ReturnType: Class System.IAsyncResult

//             4 Arguments

//                     Argument #1:  I4

//                     Argument #2:  I4

//                     Argument #3:  Class System.AsyncCallback

//                     Argument #4:  Object

//             4 Parameters

//                     (1) ParamToken : Name : x flags: [none]

//                     (2) ParamToken : Name : y flags: [none]

//                     (3) ParamToken : Name : callback flags: [none]

//                     (4) ParamToken : Name : object flags: [none]

//

//     Method #4

//     -------------------------------------------------------

//             MethodName: EndInvoke

//             ReturnType: I4 (int32)

//             1 Arguments

//                     Argument #1:  Class System.IAsyncResult

//             1 Parameters

//                     (1) ParamToken : Name : result flags: [none]

Как видите, в сгенерированном компилятором классе

BinaryOp
определены три открытых метода. Главным методом в .NET Core является
Invoke()
, т.к. он используется для вызова каждого метода, поддерживаемого объектом делегата, в синхронной манере; это означает, что вызывающий код должен ожидать завершения вызова, прежде чем продолжить свою работу. Довольно странно, но синхронный метод
Invoke()
может не нуждаться в явном вызове внутри вашего кода С#. Вскоре будет показано, что
Invoke()
вызывается "за кулисами", когда вы применяете соответствующий синтаксис С#.

На заметку! Несмотря на то что методы

BeginInvoke()
и
EndInvoke()
генерируются, они не поддерживаются при запуске вашего кода под управлением .NET Core. Это может разочаровывать, поскольку в случае их использования вы получите ошибку не на этапе компиляции, а во время выполнения.

Так благодаря чему же компилятор знает, как определять метод

Invoke()
? Для понимания процесса ниже приведен код сгенерированного компилятором класса
BinaryOp
(полужирным курсивом выделены элементы, указанные в определении типа делегата):

sealed class <b>BinaryOp</b> : System.MulticastDelegate

{

  public <b>int</b> Invoke(<b>int x, int y</b>);

...

}

Первым делом обратите внимание, что параметры и возвращаемый тип для метода

Invoke()
в точности соответствуют определению делегата
BinaryOp
.

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

string
и принимающий три входных параметра типа
System.Boolean
:

public delegate string MyDelegate (bool a, bool b, bool c);

На этот раз сгенерированный компилятором класс можно представить так:

sealed class <b>MyDelegate</b> : System.MulticastDelegate

{

  public <b>string</b> Invoke(<b>bool a, bool b, bool c</b>);

Перейти на страницу:
Изменить размер шрифта: