Обработка событий и делегаты

Предыдущие версии Visual Basic убедительно показали, что модель программирования, управляемая событиями и основанная на применении объектов, повышает производительность труда программиста. Стоило вам перетащить элемент на форму, как он начинал реагировать на определенные события. Например, код процедуры события Button1_Click автоматически выполнялся при нажатии кнопки с именем Button1.

Но, несмотря на эффективность, модель, использованная в прежних версиях VB, была недостаточно гибкой. В частности, в ней было трудно определять новые события, а написать обработчик, который обрабатывает сразу несколько событий, было практически невозможно. В VB .NET удобство и эффективность объединились с богатством возможностей. Обычно используется синтаксис, очень близкий к синтаксису прежних версий VB, при этом VB .NET берет на себя всю «черную работу». Если понадобится сделать что-то нестандартное — VB .NET предоставит и такую возможность. Глава начинается с описания модели обработки событий, похожей на аналогичную модель из предыдущих версий VB (хотя и гораздо более мощной). Далее мы представим новую для VB концепцию делегатов и покажем, как с их помощью в полной мере использовать возможности платформы .NET по обработке событий, а также решать более общие задачи (например, организовать обратный вызов функций).

Обработка событий с точки зрения ООП

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

Но при этом возникает очевидная проблема: каким объектам следует отправлять сообщения? Оповещать о каждом событии все объекты, в настоящий момент существующие в программе? Это было бы слишком неэффективно. Для большийства объектов событие не представляет ни малейшего интереса, а быстродействие станет неприемлемо низким.

Вместо этого VB .NET пытается ограничить число получателей события, для чего используется модель «подписка/публикация». В этой модели объекты-приемники событий регистрируют объекты-источники тех событий, которые представляют для них интерес. На события от одного источника могут подписаться сразу несколько объектов-приемников. О том, что источник инициировал событие, оповещаются только зарегистрированные получатели.

Впрочем, реализовать подобную схему не так просто. Какие сообщения должны передаваться приемнику от источника? Как организовать их отправку? Что должно происходить при получении сообщения? Как говорилось выше, взаимодействие между объектами на базе обмена сообщениями строится на вызове методов класса-приемника. В конечном счете обработка событий строится по тому же принципу, но при этом приходится учитывать ряд дополнительных тонкостей.

Общий смысл происходящего заключается в том, что при возникновении события объект-источник вызывает заранее определенные функции объектов-приемников. Вызываемая функция приемника регистрируется источником события одновременно с регистрацией объекта-приемника. Такая схема называется оповещением посредством обратного вызова (callback notification), потому что источник события вызывает метод приемника по заранее известному ему адресу. На рис. 6.1 показан объект-«начальник» с событием HighRating, при возникновении вызываются разные методы объектов-приемников. Во второй половине этой главы будет рассказано, как это происходит в VB .NET.

Чтобы регистрация прошла успешно, методы объекта-приемника должны иметь строго определенную форму (например, обладать конкретной сигнатурой). По этой причине в некоторых языках (например, в Java) механизм обратного вызова реализуется с применением интерфейсов — это гарантирует наличие метода с правильной сигнатурой.

Рис. 6.1. Схема оповещения посредством обратного вызова

Передача данных функциям, вызываемым в результате событий

Конечно, вы можете определить собственную сигнатуру для методов объекта-приемника, вызываемых источником, однако в .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

Параметры имеют следующий смысл:

• Объектная переменная sender содержит ссылку на объект, то есть кнопку, нажатую пользователем. Следовательно, процедура события располагает информацией об источнике события.
  
• Объектная переменная е содержит объект события, который (по крайней мере теоретически) содержит дополнительную информацию о событии.
  

Традиционно в 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 обладает значительно большим потенциалом, чем массивы управляющих элементов.

Простейшее инициирование событий

Давайте вернемся к простому классу 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, в объектах которого будет содержаться строка предупреждения вместе с данными о попытке повышения заработной платы.

Подключение приемников к источнику

В нашем распоряжении имеется весь код, необходимый для рассылки событий, но пока нет ни одного заинтересованного получателя. Существует несколько способов, которыми класс может сообщить VB .NET о своем желании получать события от другого класса. Простейший способ очень похож на тот, который использовался в VB6: на уровне модуля (или класса) объявляется переменная класса-приемника с ключевым словом WithEvents. Например, если включить в класс следующую строку, не входящую ни в один из членов: Private WithEvents anEmployee As Employee

объекты этого класса становятся потенциальными приемниками событий, инициируемых классом Employee. Обратите особое внимание на некоторые особенности этого объявления:

• Класс источника должен быть указан явно, объявления вида As Object недопустимы.
  
• Объявление располагается на уровне модуля или класса и не содержит ключевого слова New.
  

После включения этой строки в программу объектная переменная anEmpl oyee может использоваться всюду, где вас интересует событие SalarySecurityEvent. Как показано на рис. 6.2, IDE автоматически создает обработчик события с именем, построенным по схеме А_В, для каждой объектной переменной, объявленной с ключевым словом Wi thEvents. Чтобы вызвать автоматически сгенерированный «скелет» события, достаточно выбрать его в раскрывающемся списке, как на рис. 6.2.

Все вместе

А теперь давайте объединим все сказанное на практическом примере. Создайте консольное приложение и включите следующий фрагмент в первый (стартовый) модуль:

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

Рис. 6.2. Автоматически сгенерированный код обработчика события

Теперь выберите в раскрывающемся списке метод anEmployee_SalarySecurityEvent. Исходный текст этого метода приведен ниже (для удобства чтения он разбит на несколько строк, а ключевая секция Handles выделена жирным шрифтом):

Public Sub anEmployee_SalarySecur1tyEvent(ByVal Sender As

Event_Handling_I.EmployeeWithEvents, ByValeAs System.EventArgs) Handles

anEmployee.SalarySecurityEverrt

End Sub

End Module

Обратите внимание на символ подчеркивания, добавленный VB .NET между именем переменной с ключевым словом WithEvents (anEmployee) и именем события (SalarySecurityEvent), — с ним обработчик внешне почти не отличается от процедур событий в VB6.

Также обратите внимание на идентификацию объекта Sender полным именем (в формате пространство_имен. имя_класса). Наличие дополнительных символов подчеркивания в пространстве имен объясняется тем, что пробелы в них не разрешены, поэтому VB .NET автоматически преобразует имя решения «Event Handling 1» в «Event_Handling_l» (рис. 6.3). Наконец, ключевое слово Handles сообщает исполнительной среде, какое событие обрабатывается этой процедурой.

Рис. 6.3. Окно свойств решения с обработкой событий

Чтобы пример стал более интересным, вместо простого вывода в консольное окно 'мы включим в процедуру события команду вызова диалогового окна:

Public Sub anEmployee_SalarySecurityEvent(ByVal Sender As

Event_Handling_I.EmployeeWithEvents. ByVal e As System.EventArgs)

Handles anEmployee.SalarySecurityEvent

MsgBox(Sender.TheName &"had an improper salary raise attempted!")

End Sub

От приемника событий мы переходим к источнику. В класс Employee из главы 4 необходимо внести два изменения, выделенные в следующем листинге жирным шрифтом:

Public Class EmployeeWithEvents

Private m_Name As String

Private m_Salary As Decimal

Private Const LIMIT As Decimal =0.1D

Public Event SalarySecurityEventCByVal Sender As

EmployeeWithEvents,ByVal e As EventArgs)

Public Sub NewCByVal

aName As String. ByVal curSalary As Decimal)

m_Name = aName

m_Salary = curSalary

End Sub Readonly Property TheName() As String

Get

Return m_Name

End Get

End Property Readonly Property Salary() As Decimal s,

Get

Return m_Salary

End Get ' '

End Property

Public Overloads Sub RaiseSalary(ByVal Percent As Decimal)

If Percent > LIMIT'Then

^'Операция запрещена - необходим пароль

RaiseEvent SalarySecurityEventtMe, New System.EventArgs())

Else

m_Sa1ary = (1 + Percent) * m_Salary

End If

End Sub

Public Overloads Sub RaiseSalary(ByVal Percent As Decimal.

ByVal Password As String)

If Password = "special" Then

m_Salary = (1 + Percent) * m_Salary

End If

End Sub

End Class

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

Примерный результат запуска программы показан на рис. 6.4. При нажатии кнопки ОК окно сообщения исчезает, и в консольном окне выводится строка, из которой видно, что зарплата Тома не изменилась.

Переменные WithEvents потребляют системные ресурсы. Как только такая перемен-ная становится ненужной, присвойте ей Nothing.

Рис. 6.4. Окно сообщения, вызываемое при обработке события

Построение классов событий

В предыдущем примере мы воспользовались готовым классом 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

Результат показан на следующем рисунке. Как видно из рисунка, данные о запрошенном росте заработной платы доступны в обработчике события.

Динамическая обработка событий

Основной проблемой синтаксиса 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

Отключение обработчиков событий

Обработчики событий, динамически назначаемые командой AddHandler, отключаются командой RemoveHandler, которой должны передаваться точно такие же аргументы, как и при соответствующем вызове AddHandlеr. Обычно для удаления динамически назначаемых обработчиков хорошо подходит метод Dispose. По этой причине в каждом классе, использующем динамическое назначение обработчиков, рекомендуется реализовать интерфейс IDisposable — это напомнит пользователям класса о необходимости вызова Dispose.

Обработка событий в иерархии наследования

Производный класс может в любой момент инициировать открытые или защищенные события своего базового класса, при этом событие идентифицируется ключевым словом 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

Делегаты

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

Механизм обратного вызова (а следовательно, и события) в VB .NET зависит от особой разновидности объектов .NET, называемых делегатами. Делегат является экземпляром класса System.Delegate. В простейшем случае в делегате инкапсулируется объект и адрес заданной функции или процедуры этого объекта. Такие делегаты идеально подходят для схем обратного вызова вроде той, что используется при обработке событий. Почему? Потому что делегат содержит всю информацию, необходимую для обратного вызова, и может использоваться для вызова нужного метода объекта-приемника.

Но прежде, чем переходить к описанию работы с делегатами, стоит подчеркнуть одно важное обстоятельство. Хотя обработка событий на платформе .NET основана на использовании делегатов, в подавляющем большинстве случаев вам не придется работать непосредственно с делегатами. Команда AddHandl ег предоставляет в ваше распоряжение все необходимое для гибкой обработки событий в VB .NET (впрочем, как вы вскоре увидите, у делегатов есть и другие применения).

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

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

Указатели на функции в VB6.При вызовах функций API часто передается адрес функции для обратного вызова, поэтому в VB6 поддерживался оператор AddressOf. В VB6 адрес функции мог передаваться при любом вызове API. Но что происходило, если список параметров функции, адрес которой передавался при вызове, отличался от предполагаемого? Обычно это приводило к общей ошибке защиты (GPF) и даже к фатальным сбоям с появлением синего экрана.

Таким образом, произвольные указатели на функции обладают принципиальным недостатком: компилятор не может проверить, что такой указатель относится к функции правильного типа. Делегаты представляют собой разновидность указателей на функции, безопасных по отношению к типам. Следуя принципу «доверяй, но проверяй», компилятор автоматически проверяет сигнатуру вызываемой функции — такой вариант работает гораздо надежнее.

Создание делегата

Начнем с создания простейшего делегата, инкапсулирующего объект и «указатель» на процедуру этого объекта. Как показано ниже, синтаксис создания объектов чуть сложнее синтаксиса, используемого при создании простых объектов. Прежде всего нам понадобится класс, содержащий процедуру с определенной сигнатурой:

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 . Delegate¹.

Далее в процедуре 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.

Практический пример: специализированная сортировка

Предыдущие примеры выглядят искусственно и относятся к категории «игрушечных программ». В этом разделе мы покажем, как использовать делегаты при специализированной сортировке — одной из стандартных областей применения функций обратного вызова. Общая идея заключается в том, что один метод сортировки в зависимости от ситуации может использовать разные критерии сортировки. Предположим, у вас имеется массив имен: «Mike Item», «Dave Mendlen», «Alan Carter», «Tony Goodhew», «Ari Bixhorn», «Susan Warren»-.

Если вызвать метод Sort класса Array, сортировка будет произведена по именам. А если вы хотите отсортировать массив по фамилиям?

Возможный подход к решению этой задачи описан в главе 5 — вы можете написать собственную реализацию интерфейса IComparer и передать ее Sort. Применение обратного вызова на базе делегатов выглядит чуть более элегантно и теоретически обладает большей гибкостью, поскольку программист может определить собственные процедуры сортировки, которые в конкретной ситуации работают эффективнее стандартных алгоритмов.

Чтобы массив поддерживал сортировку по именам, следует определить класс с несколькими методами Compare и при помощи делегата связать алгоритм сортировки с нужным методом Compare через механизм обратного вызова. В частности, это позволит динамически изменять критерий сортировки во время работы программы.

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

1. Начать с первого элемента.
   
2. Последовательно просмотреть все остальные элементы. Если очередной элемент окажется меньше текущего первого элемента, поменять их местами.
   
3. Начать со второго элемента, просмотреть все остальные элементы.
   
4. Продолжать до последнего элемента. Основной код волновой сортировки выглядит так:
   

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 и узнает, по какому критерию должно осуществляться сравнение.

Групповые делегаты

В приведенных выше примерах в делегате инкапсулировался адрес одной функции или процедуры. Нередко в делегатах требуется инкапсулировать сразу несколько процедур (инкапсуляция нескольких функций особого смысла не имеет — каким должно быть возвращаемое значение?). Подобные делегаты называются групповыми (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 весьма проста. При каждом использовании сокращенного синтаксиса обработки событий, описанного в первой половине главы, 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 для автоматически сгенерированного делегата.

НОВОСТИ ФОРУМА Рыцари теории эфира

10.11.2021 - 12:37: ПЕРСОНАЛИИ - Personalias -> WHO IS WHO - КТО ЕСТЬ КТО - Карим_Хайдаров. 10.11.2021 - 12:36: СОВЕСТЬ - Conscience -> РАСЧЕЛОВЕЧИВАНИЕ ЧЕЛОВЕКА. КОМУ ЭТО НАДО? - Карим_Хайдаров. 10.11.2021 - 12:36: ВОСПИТАНИЕ, ПРОСВЕЩЕНИЕ, ОБРАЗОВАНИЕ - Upbringing, Inlightening, Education -> Просвещение от д.м.н. Александра Алексеевича Редько - Карим_Хайдаров. 10.11.2021 - 12:35: ЭКОЛОГИЯ - Ecology -> Биологическая безопасность населения - Карим_Хайдаров. 10.11.2021 - 12:34: ВОЙНА, ПОЛИТИКА И НАУКА - War, Politics and Science -> Проблема государственного терроризма - Карим_Хайдаров. 10.11.2021 - 12:34: ВОЙНА, ПОЛИТИКА И НАУКА - War, Politics and Science -> ПРАВОСУДИЯ.НЕТ - Карим_Хайдаров. 10.11.2021 - 12:34: ВОСПИТАНИЕ, ПРОСВЕЩЕНИЕ, ОБРАЗОВАНИЕ - Upbringing, Inlightening, Education -> Просвещение от Вадима Глогера, США - Карим_Хайдаров. 10.11.2021 - 09:18: НОВЫЕ ТЕХНОЛОГИИ - New Technologies -> Волновая генетика Петра Гаряева, 5G-контроль и управление - Карим_Хайдаров. 10.11.2021 - 09:18: ЭКОЛОГИЯ - Ecology -> ЭКОЛОГИЯ ДЛЯ ВСЕХ - Карим_Хайдаров. 10.11.2021 - 09:16: ЭКОЛОГИЯ - Ecology -> ПРОБЛЕМЫ МЕДИЦИНЫ - Карим_Хайдаров. 10.11.2021 - 09:15: ВОСПИТАНИЕ, ПРОСВЕЩЕНИЕ, ОБРАЗОВАНИЕ - Upbringing, Inlightening, Education -> Просвещение от Екатерины Коваленко - Карим_Хайдаров. 10.11.2021 - 09:13: ВОСПИТАНИЕ, ПРОСВЕЩЕНИЕ, ОБРАЗОВАНИЕ - Upbringing, Inlightening, Education -> Просвещение от Вильгельма Варкентина - Карим_Хайдаров.