Делегаты
При использовании механизма обратного вызова приходится выполнять вспомогательные операции для регистрации вызываемых функций. В оставшейся части главы будет показано, что при этом происходит и как при помощи этих операций добиться максимальной эффективности обратного вызова.
Механизм обратного вызова (а следовательно, и события) в VB .NET зависит от особой разновидности объектов .NET, называемых делегатами. Делегат является экземпляром класса System.Delegate. В простейшем случае в делегате инкапсулируется объект и адрес заданной функции или процедуры этого объекта. Такие делегаты идеально подходят для схем обратного вызова вроде той, что используется при обработке событий. Почему? Потому что делегат содержит всю информацию, необходимую для обратного вызова, и может использоваться для вызова нужного метода объекта-приемника.
Но прежде, чем переходить к описанию работы с делегатами, стоит подчеркнуть одно важное обстоятельство. Хотя обработка событий на платформе .NET основана на использовании делегатов, в подавляющем большинстве случаев вам не придется работать непосредственно с делегатами. Команда AddHandl ег предоставляет в ваше распоряжение все необходимое для гибкой обработки событий в VB .NET (впрочем, как вы вскоре увидите, у делегатов есть и другие применения).
В делегатах также могут инкапсулироваться общие методы класса без привязки ккон-кретному экземпляру. Кроме того, в групповых делегатах инкапсулируется сразу несколько объектов с несколькими процедурами.
Традиционные средства вызова функции по адресу были основаны на языковой поддержке указателей на функции. Как показано в следующей врезке, применение указателей на функции сопряжено с потенциальным риском. По сравнению с указателями на функции делегаты обеспечивают дополнительную защиту, значение которой не стоит недооценивать.
Указатели на функции в VB6 . При вызовах функций API часто передается адрес функции для обратного вызова, поэтому в VB6 поддерживался оператор AddressOf. В VB6 адрес функции мог передаваться при любом вызове API. Но что происходило, если список параметров функции, адрес которой передавался при вызове, отличался от предполагаемого? Обычно это приводило к общей ошибке защиты (GPF) и даже к фатальным сбоям с появлением синего экрана.
Таким образом, произвольные указатели на функции обладают принципиальным недостатком: компилятор не может проверить, что такой указатель относится к функции правильного типа. Делегаты представляют собой разновидность указателей на функции, безопасных по отношению к типам. Следуя принципу «доверяй, но проверяй», компилятор автоматически проверяет сигнатуру вызываемой функции — такой вариант работает гораздо надежнее.
Делегаты и события
Мы рассмотрели разнообразные примеры использования делегатов, однако ни один из них не имел отношения к обработке событий. Впрочем, связь между делегатами и событиями в VB .NET весьма проста. При каждом использовании сокращенного синтаксиса обработки событий, описанного в первой половине главы, VB .NET незаметно определяет класс делегата для обработки события, а команда AddressOf создает экземпляр делегата для этого обработчика. Например, следующие две строки эквивалентны (EventHandler — имя неявно определяемого делегата):
AddHandler Buttonl.Click.AddressOf Me.Buttonl_Click
AddHandler Buttonl.Click.New EventHandler(AddressOf Buttonl Click)
В сущности, каждое событие соответствует делегату следующего вида:
Public Delegate Event (sender As Object.evt As EventArgs)
Вызов RaiseEvent просто приводит к вызову Invoke для автоматически сгенерированного делегата.
Динамическая обработка событий
Основной проблемой синтаксиса WithEvents является его недостаточная гибкость. Обработчики событий нельзя динамически устанавливать и отключать на программном уровне — фактически вся схема обработки событий жестко фиксируется в программе. Однако в VB .NET поддерживается другой способ динамической обработки событий, значительно более гибкий. Он основан на возможности указания процедуры класса-приемника, вызываемой при возникновении события (исключение добавленных обработчиков также происходит динамически).
Конечно, для установки обработчика события необходимо зарегистрировать не только класс-приемник, но и метод, который должен вызываться при возникновении события. Для этой цели применяется команда AddHandler, которой при вызове передаются два параметра:
адрес метода (процедуры событий) класса-приемника, вызываемого при возникновении события.
Код AddHandl ег включается в класс-приемник, а не в класс-источник. Адрес метода, вызываемого при возникновении события, определяется оператором AddressOf. При вызове AddressOf передается имя метода объекта класса-приемника. Например, следующая команда устанавливает динамический обработчик события для объекта
tom:
AddHandler tom.SalarySecurityEvent.AddressOf anEmp1oyee_SalarySecurityEvent
В результате тестовая программа будет обнаруживать событие Sal arySecuri tyEvent объекта tom и в случае его возникновения — вызывать процедуру anEmployee_SalarySecurityEvent текущего модуля (разумеется, процедура anEmployee_SalarySecurityEvent должна обладать правильной сигнатурой!).
Ниже приведен фрагмент решения AddHandlerExamplel (ключевые строки выделены жирным шрифтом):
Module Modulel
Private WithEvents anEmployee As EmployeeWithEvents Sub Main()
Dim torn As New EmployeeWithEvents("Tom". 100000)
Console.WriteLine(tom.TheName & "has salary " & tom.Salary)
AddHandler tom.SalarySecurityEvent,
AddressOf anEmployee_SalarySecurityEvent
tom.RaiseSalary(0.2D) ' Суффикс D - признак типа Decimal
Console.WriteLine(tom.TheName & "still has salary " & tom.Salary)
Console.WriteLine("Please press the Enter key")
Console. ReadLine()
End Sub
Public Sub anEmployee_SalarySecurity£vent(ByVal Sender _
As AddHandlerExamplel.EmployeeWi thEvents,_
ByVal e As AddHandlerExamplel.ImproperSalaryRaiseEvent)_
Handles anEmployee.SalarySecurityEvent
MsgBox(Sender.TheName & "had an improper salary raise of " & _
FormatPercent(e.theRaise) & "with INCORRECT PASSWORD!")
End Sub
End Module
Команда AddHandler обладает просто невероятной гибкостью. Например, установка обработчиков событий может зависеть от имени типа:
If TypeName(tom)="Manager" Then
AddHandler tom.SalarySecurityEvent.AddressOf _
anEmployee_SalarySecurityEvent e
End If
Кроме того, один обработчик событий можно связать с несколькими разными событиями, происходящими в разных классах. Это позволяет выполнять в VB .NET централизованную обработку событий с динамическим назначением обработчиков — в VB такая возможность встречается впервые. В приведенном ниже листинге инициируются разные события в зависимости от переданных параметров командной строки. Главное место в нем занимают фрагменты вида
Case "first"
AddHandler m_EventGenerator.TestEvent,_
AddressOf m_EventGenerator_TestEventl
При передаче в командной строке аргумента first устанавливается соответствующий обработчик события.
В программе используется полезный метод GetCommandLineArgs класса System.Environment. Как упоминалось в главе 3, этот метод возвращает массив аргументов командной строки. Начальный элемент массива содержит имя исполняемого файла; поскольку индексация массива начинается с 0, для получения первого аргумента используется вызов System.Environment.GetComman3LineArgs(l), однако предварительно необходимо убедиться в существовании аргументов командной строки, для чего проверяется длина массива System.Environment.GetCommandLineArgs. Перед запуском программы перейдите на страницу Configuration Properties диалогового окна Project Properties и укажите аргументы командной строки для тестирования.
Ниже приведен полный исходный текст программы:
Option Strict On Module Modulel
Private m_EventGenerator As EventGenerator
Sub Main()
m_EventGenerator= New EventGenerator()
Dim commandLinesOAs String = System.Environment.GetCommandLineArgs
If commandLines.Length = 1 Then
MsgBox("No command argument.program ending!")
Environment.Exit(-l) Else
Dim theCommand As String = commandLines(l)
Console.WriteLine("Thecommand lineoption is" StheCommand)
' Проверить параметр командной строки и назначить
' соответствующий обработчик события.
Select Case theCommand Case "first"
AddHandler m_EventGenerator.TestEvent. AddressOf
m_EventGenerator_TestEvent1
Case "second"
AddHandler m_EventGenerator.TestEvent,_ AddressOf
m_EventGenerator_TestEvent2
Case Else
AddHandler m_EventGenerator.TestEvent. AddressOf
m_EventGenerator_TestEventDefault
End Select
' Инициировать события
m_EventGenerator.TriggerEvents()
End If
Console.WriteLine("Press enter to end.")
Console. ReadLine()
End Sub
'Обработчик по умолчанию для непустой командной строки
Public Sub m_EventGenerator_TestEventDefault(_
ByVal sender As Object.ByVal evt As EventArgs) System.Console.WriteLine("Default choice " & _
m_EventGenerator.GetDescri pti on()) End Sub
' Обработчик 12 для строки "first"
Public Sub m_EventGenerator_TestEvent1(_
ByVal sender As Object.ByVal evt As EventArgs)
System.Console.WriteLineC'lst choice " & _
m_EventGenerator.GetDescription()) End Sub
'Обработчик 13 для строки "second"
Public Sub m_EventGenerator_TestEvent2(
ByVal sender As Object.ByVal evt As EventArgs)
System.Console.WriteLinet"2nd choice " & _
m_EventGenerator.GetDescri pti on ())
End Sub
End Module
Public Class EventGenerator
' В классе определяется только одно событие
Public Event TestEvent(ByVal sender As Object, ByValevt As EventArgs)
' Также можно было использовать конструктор по умолчанию
Public Sub New()
' Пустой конструктор
End Sub
.Public Function GetDescription() As String
Return "EventGenerator class"
End Function
' Процедура вызывается для инициирования событий
Public Sub TriggerEvents()
Dim e As System.EventArgs = New System.EventArgs()
RaiseEvent TestEvent(Me.e)
End Sub
End Class
Групповые делегаты
В приведенных выше примерах в делегате инкапсулировался адрес одной функции или процедуры. Нередко в делегатах требуется инкапсулировать сразу несколько процедур (инкапсуляция нескольких функций особого смысла не имеет — каким должно быть возвращаемое значение?). Подобные делегаты называются групповыми (multicast) и реализуются в виде делегата, содержащего несколько однотипных делегатов. При наличии группового делегата все инкапсулированные процедуры вызываются одним методом Invoke, причем это происходит в соответствии с порядком занесения их делегатов в групповой делегат.
Чтобы создать групповой делегат, следует объединить минимум двух делегатов одного типа и присвоить результат переменной того же типа. Задача решается статическим методом Combine класса System.Delegate, который возвращает новый делегат.
Допустим, firstDel и secDel — экземпляры класса MyMultiCastDelegate. Следующая команда объединяет firstDel и secDel в групповой делегат, хранящийся в
firstDel: firstDel =System.Delegate.Combine(firstDel,secDel)
Ниже приведено простое приложение, объединяющее адреса нескольких функций в групповом делегате:
1 Option Strict On
2 Module Modulel
3 Sub Main()
4 Console.WriteLine("Calling delegate function...")
5 RegisterDelegate(AddressOf CallBackHandlerl)
6 RegisterDelegate(AddressOf CallBackHandler2)
7 Call Delegates ()
8 Console.WriteLine(
9 "Finished calling.delegate function...")
10 Console.ReadLine()
11 End Sub
12 Public Sub CallBackHandlerHByVal lngVal As RETURNJALUES)
13 Console.WriteLine("Callback 1 returned " & IngVal)
14 End Sub
15 Public Sub CallBackHandler2(ByVallngVal As RETURNJALUES)
16 Console.WriteLine("Callback 2 returned " & IngVal)
17 End Sub
18 End Module
19 Module Module2
20 Public Delegate Sub CallBackFunc(ByVallngValAs RETURN_VALUES)
21 Private m_cbFunc As CallBackFunc
22 Public Enum RETURN_VALUES
23 VALUE_SUCCESS
24 VALUE_FAILURE
25 End Enum
26 Public Sub RegisterDelegate(ByRef cbFunc As CallBackFunc)
27 m_cbFunc = CType(System.Delegate.Combine(_
28 m_cbFunc.cbFunc).CallBackFunc)
29 End Sub
30 Public Sub Call Delegates ()
31 Dim IngCounter As Long = 0
32 ' Вызвать процедуры через делегата
33 ' и вернуть признак успешного вызова
34 m_cbFunc(RETURN VALUES.VALUE_SUCCESS)
35 End Sub
36 End Module
В строках 5 и 6 вызывается процедура модуля Module2 (строки 26-28), где и происходит фактическое построение группового делегата. Это возможно благодаря тому, что делегат передается по ссылке, а не по значению. Обратите внимание на преобразование типа метода Combine к типу делегата в строке 27. Непосредственный вызов функций группового делегата происходит в строках 30-35. Всем зарегистрированным функциям передается значение перечисляемого типа RETURNJALUES . VALUE_SUCCESS. Результат выполнения программы показан на рисунке.
Групповые делегаты как члены классов
В предыдущем примере все модули имеют доступ ко всем функциям остальных модулей. Такую архитектуру нельзя признать удачной — правильнее было бы оформить делегат в виде члена класса, нежели в виде открытого объекта. Это позволит выполнить перед его созданием проверку, аналогичную той, которая выполняется для других членов класса. Ниже приведен слегка измененный вариант предыду-
щей архитектуры, где перед дополнением группового делегата новыми функциями выполняется проверка (в данном примере — весьма тривиальная). Соответствующий фрагмент выделен жирным шрифтом:
Option Strict On
Public Class DelegateServer
Public Delegate Sub ClientCallback(ByVal IngVal As Long)
Private m_Clients As ClientCallback
' Использовать конструктор по умолчанию
Public Sub RegisterDelegate(ByVal aDelegate As
ClientCallback.ByVal dolt As Boolean)
' Обычно здесь выполняется полноценная проверка.
' В данном примере функция обратного вызова регистрируется
' лишь в том случае, если второй параметр равен
True. If dolt Then
m_Clients = CType(System.Delegate.Combine(m_ Clients.aDelegate)._
ClientCallback)
End If
End Sub
Public Sub CallClients(ByVal IngVal As Long)
m_Clients( IngVal)
End Sub
End Class
Module Modulel
Sub Main()
Dim delsrv As New DelegateServer()
delsrv.RegisterDelegate(AddressOf DelegateCallbackHandlerl.True)
' He вызывается - второй параметр равен False!
delsrv.RegisterDelegate(AddressOf DelegateCal1backHandler2.False)
' Инициировать обращение к клиентам
delsrv.CallClients(125)
Console.WriteLine("Press enter to end.")
Console.ReadLine()
End Sub
Public Sub DelegateCallbackHandlerKByValIngVal As Long)
System.Console.WriteLine("DelegateCa11backHandlerl cal1ed")
End Sub
Public Sub DelegateCallbackHandler2(ByVal IngVal As Long)
System.Console.Wri teLine("DelegateCal1backHandler2 cal1ed")
End Sub
End Module
Обработка событий с точки зрения ООП
Поскольку сущность объектно-ориентированного программирования в конечном счете сводится к обмену сообщениями между взаимодействующими объектами, события должны занимать определенное место в этой схеме. В каком-то отношении они нормально вписываются в нее: объект-источник отправляет сообщение, которое указывает на возникновение события.
Но при этом возникает очевидная проблема: каким объектам следует отправлять сообщения? Оповещать о каждом событии все объекты, в настоящий момент существующие в программе? Это было бы слишком неэффективно. Для большийства объектов событие не представляет ни малейшего интереса, а быстродействие станет неприемлемо низким.
Вместо этого VB .NET пытается ограничить число получателей события, для чего используется модель «подписка/публикация». В этой модели объекты-приемники событий регистрируют объекты-источники тех событий, которые представляют для них интерес. На события от одного источника могут подписаться сразу несколько объектов-приемников. О том, что источник инициировал событие, оповещаются только зарегистрированные получатели.
Впрочем, реализовать подобную схему не так просто. Какие сообщения должны передаваться приемнику от источника? Как организовать их отправку? Что должно происходить при получении сообщения? Как говорилось выше, взаимодействие между объектами на базе обмена сообщениями строится на вызове методов класса-приемника. В конечном счете обработка событий строится по тому же принципу, но при этом приходится учитывать ряд дополнительных тонкостей.
Общий смысл происходящего заключается в том, что при возникновении события объект-источник вызывает заранее определенные функции объектов-приемников. Вызываемая функция приемника регистрируется источником события одновременно с регистрацией объекта-приемника. Такая схема называется оповещением посредством обратного вызова (callback notification), потому что источник события вызывает метод приемника по заранее известному ему адресу. На Рисунок 6.1 показан объект-«начальник» с событием HighRating, при возникновении вызываются разные методы объектов-приемников. Во второй половине этой главы будет рассказано, как это происходит в VB .NET.
Чтобы регистрация прошла успешно, методы объекта-приемника должны иметь строго определенную форму (например, обладать конкретной сигнатурой). По этой причине в некоторых языках (например, в Java) механизм обратного вызова реализуется с применением интерфейсов — это гарантирует наличие метода с правильной сигнатурой.
Обработка событий в иерархии наследования
Производный класс может в любой момент инициировать открытые или защищенные события своего базового класса, при этом событие идентифицируется ключевым словом MyBase. Кроме того, производные классы автоматически наследуют все обработчики открытых и защищенных событий своих предков. Время от времени в производном классе возникает необходимость в переопределении методов, используемых при обработке открытых и защищенных событий базового класса. Для этой цели используется конструкция Handles MyBase. Пример:
Public Class ParentClass
Public Event ParentEventtByVal aThing As Object.
ByVal E As System.EventArgs)
' Программный код End Class
' Производный класс
Public Class ChildClass
Inherits ParentClass
Sub EventHandler(ByVal x As Integer)
Handles MyBase ParentEvent
'Обработка событий базового класса
End Sub
End Class
Отключение обработчиков событий
Обработчики событий, динамически назначаемые командой AddHandler, отключаются командой RemoveHandler, которой должны передаваться точно такие же аргументы, как и при соответствующем вызове AddHandlеr. Обычно для удаления динамически назначаемых обработчиков хорошо подходит метод Dispose. По этой причине в каждом классе, использующем динамическое назначение обработчиков, рекомендуется реализовать интерфейс IDisposable — это напомнит пользователям класса о необходимости вызова Dispose.
Подключение приемников к источнику
В нашем распоряжении имеется весь код, необходимый для рассылки событий, но пока нет ни одного заинтересованного получателя. Существует несколько способов, которыми класс может сообщить VB .NET о своем желании получать события от другого класса. Простейший способ очень похож на тот, который использовался в VB6: на уровне модуля (или класса) объявляется переменная класса-приемника с ключевым словом WithEvents. Например, если включить в класс следующую строку, не входящую ни в один из членов: Private WithEvents anEmployee As Employee
объекты этого класса становятся потенциальными приемниками событий, инициируемых классом Employee. Обратите особое внимание на некоторые особенности этого объявления:
Объявление располагается на уровне модуля или класса и не содержит ключевого слова New.
После включения этой строки в программу объектная переменная anEmpl oyee может использоваться всюду, где вас интересует событие SalarySecurityEvent. Как показано на Рисунок 6.2, IDE автоматически создает обработчик события с именем, построенным по схеме А_В, для каждой объектной переменной, объявленной с ключевым словом Wi thEvents. Чтобы вызвать автоматически сгенерированный «скелет» события, достаточно выбрать его в раскрывающемся списке, как на Рисунок 6.2.
Построение классов событий
В предыдущем примере мы воспользовались готовым классом System.EventArgs. Возможности этого класса весьма ограничены, поскольку его конструктор вызывается без аргументов. При более профессиональном подходе в программе определяется новый класс события, дополняющий этот базовый класс. Например, в него можно включить ReadOnly-свойство, возвращающее информацию о предполагаемом повышении зарплаты, и другое свойство для текста сообщения. Пример подобного класса приведен ниже (решение CustomEventArgExample в архиве). Запрашиваемый рост зарплаты и сообщение инкапсулируются в конструкторе события. В дальнейшем для получения этих данных используются два свойства, доступных только для чтения:
Public Class ImproperSalaryRaiseEvent
Inherits System.EventArgs
Private m_Message As String
Private m_theRaise As Decimal
Sub New(ByVal theRaise As Decimal. ByVal theReason As String)
MyBase.New()
m_Message = theReason
m_theRaise = theRaise
End Sub
Readonly Property Message() As String
Get
Return m_Message
End Get End Property Readonly Property theRaise() As Decimal
Get
Return m_theRaise
End Get
End Property
End Class
После того как этот класс будет включен в решение, следует внести небольшие изменения в объявление события в классе Empl oyee:
Public Event SalarySecurityEvent(ByVal Sender As
CustomEventArgExample.EmployeeWithEvents. ByVale As
ImproperSalaryRaiseEvent)
Теперь во втором аргументе передается переменная класса ImproperSalaryRai seEvent. Следующие изменения вносятся во фрагмент, в котором непосредственно вызывается событие:
Public Overloads Sub RaiseSalary(ByVal Percent As Decimal)
If Percent > LIMIT Then
' Операция запрещена - необходим пароль
RaiseEvent SalarySecurityEvent(Me,
New ImproperSalaryRaiseEvent(Percent, "INCORRECT PASSWORD!"))
Else
m_Salary =(1 + Percent) * m_Salary
End If
End Sub
Остается лишь слегка исправить код обработчика события (изменения выделены жирным шрифтом).
Module Modulel
Private WithEvents anEmployee As EmployeeWithEventsII Sub Maine)
Dim tom As New EmployeeWithEventsII("Tom". 100000)
anEmployee = tom
Console.Wntel_ine(tom.TheName &"has salary " & tom.Salary)
anEmployee.RaiseSalary(0.2D)'Суффикс D - признак типа Decimal
Console.WriteLine(tom.TheName & "still has salary " & tom.Salary)
Console.Writeline("Please press the Enter key")
Console.ReadLine()
End Sub
Public Sub anEmployee_SalarySecuhtyEvent(ByVal Sender _ As
CustomEventArgExample.EmployeeWithEvents. ByVal e As
CustomEventArgExample.ImproperSalaryRaiseEvent) Handles
anEmployee.SalarySecurityEvent
MsgBox(Sender.TheName & "had an improper salary raise of " & _ FormatPercent(e.theRaise) & "with INCORRECT PASSWORD!")
End Sub
End Module
Результат показан на следующем рисунке. Как видно из рисунка, данные о запрошенном росте заработной платы доступны в обработчике события.
Практический пример: специализированная сортировка
Предыдущие примеры выглядят искусственно и относятся к категории «игрушечных программ». В этом разделе мы покажем, как использовать делегаты при специализированной сортировке — одной из стандартных областей применения функций обратного вызова. Общая идея заключается в том, что один метод сортировки в зависимости от ситуации может использовать разные критерии сортировки. Предположим, у вас имеется массив имен: «Mike Item», «Dave Mendlen», «Alan Carter», «Tony Goodhew», «Ari Bixhorn», «Susan Warren»-.
Если вызвать метод Sort класса Array, сортировка будет произведена по именам. А если вы хотите отсортировать массив по фамилиям?
Возможный подход к решению этой задачи описан в главе 5 — вы можете написать собственную реализацию интерфейса IComparer и передать ее Sort. Применение обратного вызова на базе делегатов выглядит чуть более элегантно и теоретически обладает большей гибкостью, поскольку программист может определить собственные процедуры сортировки, которые в конкретной ситуации работают эффективнее стандартных алгоритмов.
Чтобы массив поддерживал сортировку по именам, следует определить класс с несколькими методами Compare и при помощи делегата связать алгоритм сортировки с нужным методом Compare через механизм обратного вызова. В частности, это позволит динамически изменять критерий сортировки во время работы программы.
Прежде всего определяется класс, выполняющий сортировку. Чтобы избежать подробного обсуждения различных алгоритмов сортировки, мы воспользуемся простейшим алгоритмом волновой сортировки:
-
Начать с первого элемента.
Последовательно просмотреть все остальные элементы. Если очередной элемент окажется меньше текущего первого элемента, поменять их местами.
Начать со второго элемента, просмотреть все остальные элементы.
Продолжать до последнего элемента. Основной код волновой сортировки выглядит так:
For i =bottom To (top - bottom) For j =i + 1 To top
If Stuff(j) < Stuff(i))Then
temp = Stuff(i)
Stuff(i) = Stuff(j)
Stuff(j) = temp
End If
Next j
Next I
Чтобы реализовать этот алгоритм с применением функций обратного вызова, необходимо определить класс Special Sort с делегатом, используемым при обратном вызове. Код этого класса приведен ниже:
1 Public Class Special Sort
2 ' Определение делегата
3 Public Delegate Function SpecialCompareCallback(ByVal flrstString _
As String,ByVal secondString As String) As Boolean
4 ' Определение процедуры, вызываемой делегатом
5 Public Shared Sub IfySort(ByVal Stuff As String()._
ByVal MyCompare As SpecialCompareCallback)
6 Dim i, j As Integer
7 Dim temp As String
8 Dim bottom As Integer = Stuff.GetLowerBound(0)
9 Dim top As Integer = Stuff.GetUpperBound(0)
10 For i = bottom To (top = bottom)
11 For j = i + 1 To top
12 If MyCompare(Stuff(j). Stuff(i)) Then
13 temp = Stuff(i)
14 Stuff(1) - Stuff (j)
15 Stuff(j) = temp
16 End If
17 Next j
18 Next i
19 End Sub
20 End Class
В строке З определяется делегат, при помощи которого классу передается информация об используемом порядке сортировки. Делегат может инкапсулировать любую функцию, которая, как и все нормальные функции сравнения строк, получает два строковых параметра и возвращает логическую величину.
В строке 5 определяется общая процедура, одним из параметров которой является переменная с типом делегата. Таким образом, в ключевой строке 12:
If MyCompare(Stuff(j). Stuff(i)) Then
функция сравнения, инкапсулированная в делегате MyCompare, может относиться к другому классу! Например, если определить приведенный ниже класс, эта схема позволит использовать любой из его методов Compare (обратите внимание: методы Compare объявлены общими, поэтому для их вызова нам даже не нужно создавать конкретный экземпляр класса):
Public Class MyCustomCompare
Public Shared Function TheBasicComparetByVal firstString As String,
ByVal secondString As String) As Boolean
Return (firstString <- secondString)
End Function
Public Shared Function TheSpecialCompare(ByVal firstString As String.
ByVal secondString As String)As Boolean Dint tokensl,tokens2 As String()
tokensl = firstString.Split(Chr(32))
tokens2 = secondString.Split(Chr(32))
Return (tokensl(l) <- tokens2(l))
' Сравнение по фамилии!
End Function
End Class
Класс содержит две общие функции, которые ниже будут использованы для создания делегатов. Первая функция, TheBasicCompare, просто сравнивает строки в алфавитном порядке. Более интересная функция TheSpecialCompare предполагает, что строка передается в формате «имя фамилия», и сравнивает фамилии, выделяя их при помощи удобной функции Split.
Остается лишь создать экземпляры класса SpecialSort и делегаты. Это происходит в следующей функции Main (ключевые строки выделены жирным шрифтом):
1 Module Modulel
2 Sub Main()
3 Dim test()As String ={"Mike Iem"."Dave Mendlen"."Alan Carter".
4 "Tony Goodhew","An Bixhorn"."Susan Warren"}
5 ' Объявить переменную обратного вызова в форме класс.делегат
6 Dim MyCallBack As Special Sort.SpecialCompareCal1back
7 MyCallBack = AddressOf MyCustomCompare.TheBasicCompare
8 SpecialSort.MySort(test,MyCallBack)
9 Console.WriteLine("Here is a basic sort by FIRST name")
10 Dim temp As String
11 For Each temp In test
12 Console.WriteLine(temp)
13 Next
14 ' Передать другую процедуру сравнения
15 MyCallBack = AddressOf MyCustomCompare.TheSpecialCompare
16 Sped al Sort. MySort (test. MyCallBack)
17 Console.WriteLine()
18 Console.WriteLineC'Here is a sort by LAST name")
19 For Each temp In test
20 Console.WriteLine(temp)
21 Next
22 Console. ReadLine()
23 End Sub
24 End Module
В строке 6 объявляется «псевдоуказатель на функцию». Чтобы задать его значение, мы передаем адрес функции с правильной сигнатурой (строки 7-15). Поскольку функции объявлены общими, создавать экземпляр класса MyCustomCompare для этого не нужно. После создания делегата в строках 8 и 16 вызывается нужная процедура сортировки класса Special Sort. Поскольку при вызове MySort передается делегат, процедура обращается к классу MyCustomCompare и узнает, по какому критерию должно осуществляться сравнение.
Простейшее инициирование событий
Давайте вернемся к простому классу Empl oyee и подробно, шаг за шагом разберем все, что необходимо сделать для определения и инициирования событий. Предположим, событие должно инициироваться при попытке увеличения заработной платы более чем на 10 процентов без ввода пароля. В главе 4 метод RaiseSalary выглядел так:
Public Overloads Sub RaiseSalary(ByVal percent As Decimal)
If percent > LIMIT Then
' Операция запрещена - Необходим пароль
Console.WriteLine("MUST HAVE PASSWORD TO RAISE SALARY " & _
"MORE THAN LIMIT!!!!") Else
m_Sa1ary =(1 + percent) * m_salary
End If
End Sub
Вместо выделенной команды, выводящей текстовое сообщение на консоль, должно инициироваться событие. Задача решается в несколько этапов. В простейшем случае в классе сначала объявляется открытая переменная с ключевым словом Event, с указанием имени события и его параметров. Например, следующая строка весьма близка к синтаксису VB6: Public Event SalarySecurityEventdnessage as String) В этой строке объявляется открытое событие с параметром строкового типа.
События обычно объявляются с модификатором Public, никогда не возвращают значений и могут получать параметры произвольного типа, кроме ParamArray.
После того как переменная события будет определена, событие инициируется командой следующего вида (впрочем, для того, чтобы событие действительно произошло, потребуются еще кое-какие дополнительные действия):
RaiseEvent SalarySecurityEventC'MUST HAVE PASSWORD TO RAISE " & _
"Salary MORE THAN LIMIT!! !!")
Однако из этого не следует, что для любого события следует ограничиваться одним строковым параметром. В соответствии с парадигмой программирования .NET в качестве параметров любого события передается объект-источник и информация о событии, инкапсулированная в объекте события. На первых порах вполне достаточно объявления вида
Public Event SalarySecurityEvent(ByVal who As Employee, ByVale As system.EventArgs)
Событие инициируется следующей командой RaiseEvent:
RaiseEvent SalarySecurityEvent(Me,New System.EventArgs())
Хотя события обычно объявляются открытыми, это не является обязательным требованием — событие может иметь любой модификатор уровня доступа. Закрытыми (Private) объявляются события, представляющие интерес только для объектов этого класса, а защищенные (Protected) события также могут обрабатываться объектами производных классов. Допускается даже объявление общих (Shared) событий, которые, как и общие члены классов, существуют на уровне класса в целом, а не его отдельных членов (в частности, общие методы могут инициировать только общие события).
По сигнатуре события приемник узнает, от какого источника поступило событие (в данном примере это объект-работник, которому попытались неправильно повысить заработную плату); сам объект передается в виде ключевого слова Me. Впрочем, приведенное объявление не использует возможностей передачи данных в переменной события е. Вскоре мы разработаем класс, производный от System. EventArgs, в объектах которого будет содержаться строка предупреждения вместе с данными о попытке повышения заработной платы.
Схема оповещения посредством обратного
Конечно, вы можете определить собственную сигнатуру для методов объекта-приемника, вызываемых источником, однако в .NET существует практически общепринятое правило, согласно которому функции приемника передаются два параметра:
Объект события (класса, производного от System.EventArgs), содержащий информацию о событии (разные классы, производные от System.Event.Args, обладают разными свойствами, ориентированными на разные обработчики событий).
Пример приводился ранее в главе 1. При размещении кнопки на форме генерировалась процедура события Click:
Private Sub Buttonl_Click(ByVal sender As System.Object.
ByValeAs System.EventArgs) Handles Button1.Click
End Sub
Параметры имеют следующий смысл:
Объектная переменная е содержит объект события, который (по крайней мере теоретически) содержит дополнительную информацию о событии.
Традиционно в VB источник (отправитель) события не идентифицировался в процедуре события. Единственным исключением были массивы управляющих элементов, когда конкретный элемент-отправитель выделялся из массива при помощи параметра-индекса. Смысл дополнительной объектной переменной sender в обобщенной процедуре события VB .NET становится очевидным, если вспомнить, что одна процедура может обрабатывать несколько событий, поступающих от разных объектов. Попробуйте вызвать встроенный метод ToString в приведенной выше процедуре события: MsgBox(sender.ToString) Результат будет выглядеть так:
Таким образом, процедура-обработчик может однозначно определить, какой объект был источником события.
В данном примере объект события е не представляет интереса, поскольку он не содержит сколько-нибудь полезной информации о событии. С другой стороны, в некоторых ситуациях он может пригодиться. Например, из объектной переменной класса MouseEventArgs можно узнать, в какой точке был сделан щелчок мышью. В общем случае программист определяет собственные классы событий, производные от класса System. EventArgs и содержащие любую полезную информацию о событии (о том, как это делается, будет рассказано ниже).
Также обратите внимание на новое ключевое слово Hand! es в определении процедуры события. Как нетрудно догадаться, это ключевое слово указывает, какие события обрабатываются данной процедурой. Возможно, в данном примере ключевое слово Handl es выглядит излишним, однако оно предоставляет программисту дополнительные возможности, поскольку теперь обработчики события не обязаны обладать жестко заданными именами (фиксируются только сигнатуры). Следовательно, одна процедура может обрабатывать несколько событий, для чего в конец объявления процедуры включаются несколько секций Handl es. Новый подход обладает большей гибкостью по сравнению с массивами управляющих элементов, использовавшимися в прежних версиях VB (в VB .NET массивы элементов не поддерживаются).
Хотя IDE генерирует процедуры событий со стандартными именами, в VB .NET это уже не является обязательным требованием. Если процедура имеет правильный набор параметров и в ее заголовке присутствует ключевое слово Handles, эта процедура может использоваться для обработки событий. Пример:
Private Sub MyClickProcedure(ByVal sender As System.Object,_
ByValeAs System.EventArgs) Handles Buttonl.Click
Процедура MyClickProcedure может обрабатывать событие Buttonl. Click благодаря наличию правильных параметров. Она обрабатывает это событие, поскольку в заголовке указано ключевое слово Handles. Главное новшество заключается в явном указании обрабатываемых событий с ключевым словом Handles.
Рассмотрим другой пример. Допустим, предыдущий фрагмент был приведен к следующему виду:
Private Sub MyClickProcedureCByVal sender As System.Object._
ByVal e As System.EventArgs) Handles Buttonl.Click. Button2.Click._
mnuTHing.Click
Теперь одна процедура обрабатывает события сразу от двух разных кнопок и команды меню! В VB6 подобная универсальность была невозможна, поскольку в прежних версиях VB обработчики событий вызывались по имени элемента. Надеемся, читатель согласится с тем, что ключевое слово Handl es обладает значительно большим потенциалом, чем массивы управляющих элементов.
| Содержание
|
Вперед
|
Создание делегата
Начнем с создания простейшего делегата, инкапсулирующего объект и «указатель» на процедуру этого объекта. Как показано ниже, синтаксис создания объектов чуть сложнее синтаксиса, используемого при создании простых объектов. Прежде всего нам понадобится класс, содержащий процедуру с определенной сигнатурой:
Class ClassForStringSubDelegate
' Использовать конструктор по умолчанию
Public Sub TestSub(ByVal aString As String)
Console. WriteLine(aString SaString)
End Sub
End Class
Чтобы создать делегат для обратного вызова этой процедуры, необходимо сообщить компилятору об использовании делегата для процедуры с одним строковым параметром. Первый шаг этого сценария выполняется за пределами Sub Main следующей строкой:
Public Delegate Sub StringSubDelegate(ByVal
aString As String)
Обратите внимание: в этой строке мы не объявляем делегат, а определяем его. Компилятор VB .NET автоматически создает новый класс StringSubDel egate, производный от System . Delegate1.
Далее в процедуре Sub Main экземпляр класса делегата создается оператором AddressOf для адреса процедуры, имеющей правильную сигнатуру. VB .NET автоматически вычисляет объект по полному имени процедуры. Команда создания экземпляра выглядит так:
aDel egate = AddressOf test.TestSub
Компилятор VB .NET понимает, что делегат создается для объекта test. Также можно воспользоваться ключевым словом New, однако это делается редко, поскольку New неявно вызывается в первой форме:
aDelegate = New StringSubDelegate(AddressOf test.TestSub)
После того как делегат будет создан, инкапсулированная в нем процедура вызывается методом Invoke класса Delegate, как в следующем фрагменте:
Sub Main( )
Dim test As New ClassForStri ngSubDelegate()
Dim aDelegate As StringSubDelegate
aDelegate = AddressOf test.TestSub
aDelegate.Invoke( "Hello" )
Console. ReadLineb
End Sub
На самом деле использовать Invoke необязательно — достаточно передать делегату нужные параметры. VB .NET поймет команду aDelegate(" Hello"), которая выглядит значительно проще.
В этом нетрудно убедиться, просматривая полученный IL-код при помощи программы ILDASM.
Согласитесь, такой способ вывода в консольном окне строки «HelloHello» выглядит несколько необычно!
Впрочем, «если это и безумие, то в своем роде последовательное». Предположим, вы решили усовершенствовать свой класс, чтобы вместо простого вывода текста в консольном окне на экране появлялось окно сообщения. Для этого достаточно внести изменения, выделенные жирным шрифтом в следующем листинге:
Module Modulel
Public Delegate Sub StringSubDelegate(ByVal aString As String)
Sub Main()
Dim test As New ClassForStringSubDelegate()
Dim aDelegate As StringSubDelegate
aDelegate - AddressOf test.TestMsgBox
aDelegate("Hello")
Console. ReadLine()
End Sub
Class ClassForStringSubDelegate
' Использовать конструктор по умолчанию
Public Sub TestSub(ByVal aString As String)
Console.WriteLine(aString SaString)
End Sub
Public Sub TestMsgBox(ByVal aString As String)
MsgBox(aString &aString)
End Sub
End Class End Module
Поскольку для делегата важна только сигнатура инкапсулированного метода, он легко «переключается» на другой метод. Потребовалось создать новую версию для вывода информации в окне отладки (вместо консоли и окна сообщения)? Достаточно внести несколько изменений в делегат и добавить в класс функцию, инкапсулируемую делегатом.
Важнейшая особенность делегатов заключается в том, что связывание с методом производится на стадии выполнения. Таким образом, делегаты в сочетании с явным или неявным вызовом метода Invoke по своим возможностям значительно превосходят функцию VB6 CallByName.
Все вместе
А теперь давайте объединим все сказанное на практическом примере. Создайте консольное приложение и включите следующий фрагмент в первый (стартовый) модуль:
Module Modulel
Private WithEvents anEmployee As EmployeeWithEvents
Sub Main()
Dim tom As New EmployeeWithEvents("Tom". 100000)
anEmployee = tom
Console.WriteLine(tom.TheName & "has salary " & tom.Salary)
anEmployee.RaiseSalary(0.2D) ' Суффикс D - признак типа Decimal
Console.WriteLinettom.TheName & "still has salary " & tom.Salary)
Console.WritelineC'Please press the Enter key")
Console.ReadLine() End Sub End Module
