Классы и объекты

Синтаксис Let, Get и Set

Оператор Property Let используется для установки значения терминального свойства и имеет следующий синтаксис:

[Public | Private | Friend] [Static] Property Let имя-свойства
	([список-параметров,] значение)
	[Операторы]
	[Exit Property]
	[Операторы]
End Property

Оператор Property Set используется для установки значения свойства - участника (объекта) и имеет следующий синтаксис:

[Public | Private | Friend] [Static] Property Set имя-свойства
	([список-параметров,] ссылка)
	[Операторы]
	[Exit Property]
	[Операторы]
End Property

Оператор Property Get используется для получения значения свойства и имеет следующий синтаксис:

[Public | Private | Friend] [Static] Property Get имя-свойства
	[(список-параметров)] [As Type]
	[Операторы]
	[Exit Property]
	[Операторы]
	[имя-свойства = выражение] 
End Property

Рассмотрим детали синтаксиса:

Классы, как упаковка

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

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

'Класс Plan
'Свойство класса
Private CurMonth As Integer
'Закрытый массив, играющий служебную роль
Private Месяцы(1 To 12) As String

Private Sub Class_Initialize()
	CurMonth = Month(Now)

	Месяцы(1) = "Январь": Месяцы(2) = "Февраль": Месяцы(3) = "Март"
	Месяцы(4) = "Апрель": Месяцы(5) = "Май": Месяцы(6) = "Июнь"
	Месяцы(7) = "Июль": Месяцы(8) = "Август": Месяцы(9) = "Сентябрь"
	Месяцы(10) = "Октябрь": Месяцы(11) = "Ноябрь": Месяцы(12) = "Декабрь"
End Sub

Public Property Get ТекущийМесяц() As String
    ТекущийМесяц = Месяцы(CurMonth)
End Property

Public Property Let ТекущийМесяц(ByVal NewValue As String)
Dim i As Byte
i = 1
Do While i <= 12
    If Месяцы(i) = NewValue Then
        CurMonth = i
        Exit Do
    End If
    i = i + 1
 Loop
If i = 13 Then  'Неверно задан месяц
    CurMonth = Month(Now)
End If
End Property

Обратите внимание, работу с закрытым свойством CurMonth обеспечивают процедуры - свойства Property Let ТекущийМесяц и Property Get ТекущийМесяц. С их помощью можно читать и изменять значение свойства CurMonth. Одновременно Let и Get занимаются преобразованием данных, что является распространенной практикой. Пример этот интересен и с позиций построения конструктора по умолчанию, который выполняет все необходимые внутренние инициализации, в данном случае, задавая значение массиву Месяцы.

Приведем еще процедуру, которая работает с данными этого класса:

Public Sub WorkWithPlan()
 Dim MyPlan As New Plan
 Debug.Print MyPlan.ТекущийМесяц
 MyPlan.ТекущийМесяц = "Апрель"
 Debug.Print MyPlan.ТекущийМесяц
 MyPlan.ТекущийМесяц = "Янв."
 Debug.Print MyPlan.ТекущийМесяц

End Sub

В результате ее работы, (процедура запускалась в марте месяце) напечатаны значения:

Март
Апрель
Март

Задумаемся над сутью решаемой задачи, - нам хочется при обращении к свойству класса получать значение текущего месяца. Но ведь текущий месяц, он и есть текущий, и пользователь не должен изменять его значение. Так что первое, что следовало бы сделать, это воспользоваться стратегией Read- only и не разрешать изменять значение свойства. Поэтому исключим Property Let из нашего класса. Но в этом примере есть куда более интересная особенность. Исключив Property Let, мы понимаем, что теперь теряет смысл хранение самого свойства CurMonth. Его значение мы можем (и должны по смыслу свойства) получать динамически, обращаясь к системной процедуре Month(Now). Удалим из класса и переменную CurMonth. Наш новый класс PlanNew стал проще:

'Класс PlanNew
'Закрытый массив, играющий служебную роль
Private Месяцы(1 To 12) As String

Private Sub Class_Initialize()
Месяцы(1) = "Январь": Месяцы(2) = "Февраль": Месяцы(3) = "Март"
Месяцы(4) = "Апрель": Месяцы(5) = "Май": Месяцы(6) = "Июнь"
Месяцы(7) = "Июль": Месяцы(8) = "Август": Месяцы(9) = "Сентябрь"
Месяцы(10) = "Октябрь": Месяцы(11) = "Ноябрь": Месяцы(12) = "Декабрь"
End Sub

Public Property Get ТекущийМесяц() As String
    ТекущийМесяц = Месяцы(Month(Now))
End Property

Свойство ТекущийМесяц теперь имеет статус Read- only. Но главная суть не в этом. Теперь отчетливо видна настоящая роль класса PlanNew, - он является красивой упаковкой вызова служебных функций Month(Now). Стоило ли создавать класс для этой цели? Не проще ли просто написать стандартную процедуру или вообще все делать самому, обращаясь к служебной функции и затем преобразуя номер месяца в его название? Для одной функции, как в нашем примере, вероятно, не стоит создавать класс, но для десятка функций это вполне целесообразно. Эта техника с особым успехом используется, когда нужно упаковать обращение к Win API функциям. Так что, подводя итог, отметим, что иногда классы используются как упаковка, расширяющая стандартные возможности и особую роль в этом процессе играют процедуры - свойства.

Семейство классов и процедуры - свойства

Когда создается семейство классов, без свойств - участников не обойтись. В классах семейства, основанных на механизме встраивания, обязательно есть свойства, представляющие собой объекты. Эти свойства, как и терминальные, обычно, закрываются и для работы с ними используются процедуры - свойства Property Set и Property Get. Иногда приходится передавать и дополнительные параметры при работе с ними. Рассмотрим типичный пример. Ранее мы построили класс " Личность ", теперь построим класс " Группа ", содержащий группу личностей. При построении этого класса ограничимся минимальными средствами, необходимыми для демонстрации работы со свойствами:

'Класс Группа Личностей
Const РазмерГруппы As Byte = 25
'Свойства
Private Group(1 To РазмерГруппы) As Личность

'Процедуры-свойства
Public Property Get ЧленГруппы(num As Byte) As Личность
    'Если номер корректен
    If (num >= 1) And (num <= РазмерГруппы) Then
        'Если существует в группе личность с таким номером
        If Not (Group(num) Is Nothing) Then
            Set ЧленГруппы = Group(num)
        Else: MsgBox ("В группе нет человека с номером "  num)
        End If
    Else: MsgBox ("Некорректно задан номер в группе - "  num)
    End If
End Property

Public Property Set ЧленГруппы(num As Byte, NewValue As Личность)
 'Если номер корректен
    If (num >= 1) And (num <= РазмерГруппы) Then
        'Если в группе нет личности с таким номером, то она создается
        If Group(num) Is Nothing Then
           Set Group(num) = NewValue
        Else: MsgBox ("В группе уже есть человек с номером "  num)
        End If
    Else: MsgBox ("Некорректно задан номер в группе - "  num)
    End If
End Property

Public Sub Сведения()
    Dim i As Byte
    For i = 1 To РазмерГруппы
        If Not (Group(i) Is Nothing) Then
            Group(i).PrintPerson
        End If
    Next i
End Sub

Массив объектов класса " Личность " является закрытым свойством класса " Группа ". Процедуры - свойства Property Get ЧленГруппы и Property Set ЧленГруппы обеспечивают доступ к элементам этого массива. Индекс элемента является дополнительным параметром. Заметьте, процедура Set имеет статус Write-once, - если элемент с заданным номером уже определен в группе, то он не переопределяется. При создании этих процедур, нам, конечно же, пришлось модифицировать стандартные заготовки Let и Get. Для полноты картины приведем процедуру, в которой показано, как работать с группой:

Public Sub WorkWithGroup()
  	Dim UserOne As New Личность
    Dim UserTwo As New Личность
    Dim UserThree As New Личность
    Dim Знакомые As New Группа  
 Dim NewUser As New Личность
    'Личности
    UserOne.InitPerson FN:="Петр", LN:="Петров", DoB:=#1/23/1968#
    UserTwo.InitPerson FN:="Анна", LN:="Козлова", DoB:=#7/21/1968#
    UserThree.InitPerson FN:="Анна", LN:="Керн", DoB:=#5/17/1803#
    'Группа
    Set Знакомые.ЧленГруппы(1) = UserOne
    Set Знакомые.ЧленГруппы(2) = UserTwo
    Set Знакомые.ЧленГруппы(1) = UserThree
    Set Знакомые.ЧленГруппы(3) = UserThree
    Set NewUser = Знакомые.ЧленГруппы(7)
    Set NewUser = Знакомые.ЧленГруппы(3)
    Знакомые.Сведения

End Sub

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

Петр         Петров        родился       23.01.68 
Анна         Козлова       родилась      21.07.68 
Анна         Петровна      Керн          родилась      17.05.1803

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

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

Методы

Не будем повторяться. О методах было сказано уже достаточно. Любая процедура ( Sub ) или функция ( Function ), описанная в разделе методов класса, является его методом. Напомним синтаксис методов класса:

[Private | Public | Friend] [Static] Sub name [(arglist)] 
[statements]
[Exit Sub]
[statements]
End Sub
[Public | Private | Friend] [Static] Function name [(arglist)] [As type]
[statements]
[name = expression]
[Exit Function] 
[statements]
[name = expression]
End Function

Роль всех ключевых слов в этих определениях уже пояснялась, чуть позже мы подробнее скажем о спецификаторе Friend, который могут иметь методы класса. Сейчас же отметим, что почти каждый класс, независимо от его специфики имеет некоторый "джентльменский" набор методов. В него входит:

Вернемся к проектированию класса Rational. Большую часть джентльменского его набора мы уже определили. Специфика этого класса определяется операциями над рациональными числами. Ограничимся четырьмя основными операциями - сложением, вычитанием, умножением и делением. Добавим к ним еще и метод печати дробей. Вот тексты этих методов, заканчивающих определение нашего класса:

Public Function Plus(a As Rational) As Rational
    Dim d As Integer, u As Integer, v As Integer
    Dim R As New Rational
   
	u = m * a.Знаменатель + n * a.Числитель
    v = n * a.Знаменатель
    d = nod(u, v)
    R.Числитель = u \ d
    R.Знаменатель = v \ d
    Set Plus = R
End Function

Public Function Minus(a As Rational) As Rational
    Dim d As Integer, u As Integer, v As Integer
    Dim R As New Rational
    
	u = m * a.Знаменатель - n * a.Числитель
    v = n * a.Знаменатель
    d = nod(u, v)
    R.Числитель = u \ d
    R.Знаменатель = v \ d
    Set Minus = R
End Function

Public Function Mult(a As Rational) As Rational
    Dim d As Integer, u As Integer, v As Integer
    Dim R As New Rational
   
	u = m * a.Числитель
    v = n * a.Знаменатель
    d = nod(u, v)
    R.Числитель = u \ d
    R.Знаменатель = v \ d
    Set Mult = R
End Function

Public Function Divide(a As Rational) As Rational
    Dim d As Integer, u As Integer, v As Integer
    Dim R As New Rational
    u = m * a.Знаменатель
    v = n * a.Числитель
    If v = 0 Then
        MsgBox ("деление на нуль невозможно")
    Else
        d = nod(u, v)
        R.Числитель = u \ d
        R.Знаменатель = v \ d
        Set Divide = R
    End If
End Function

Public Sub PrintRational()
    Debug.Print (m  "/"  n)
End Sub

Приведем процедуру, которая работает с рациональными числами:

Public Sub WorkWithRational()
Dim a As New Rational, b As New Rational, c As New Rational
    
    a.CreateRational 5, 7
    b.CreateRational -12, -18
    Set c = a.Plus(b)
    c.PrintRational
    Set a = c.Minus(b)
    a.PrintRational
    Set c = a.Mult(b)
    c.PrintRational
    Set b = c.Divide(a)
    b.PrintRational
End Sub

При ее запуске получены следующие результаты:

29/21
5/7
10/21
2/3

Friend методы

Методы класса, в том числе процедуры - свойства Get, Let и Set могут иметь описатель Friend наряду с описателями Public и Private. Каждый из них задает свою область видимости метода, область программы, где метод доступен для вызова. Напомним, Private делает метод видимым только внутри класса, Public - делает метод доступным и область действия может распространяться не только на тот проект, в котором определен данный класс, но и на другие проекты. Чтобы управлять этим процессом, расширяя или сужая область видимости Public объектов, применяют специальные спецификаторы, например, опцию Option Private, которая закрывает модуль от других проектов. Методы с описателем Friend называют дружественными . Описатель Friend, действуя только на один метод, распространяет его область видимости на проект, в котором описан класс с Friend методом. Но для других проектов дружественные методы не доступны, даже в том случае, когда там доступны Public методы. Так что метод дружит только со своим проектом и не более. Кто программировал на С++ и других языках, где есть наследование классов, знаком с дружественными методами, - там они дружат с классами - потомками родительского класса, в котором задан Friend метод. Вне семейства классов дружественные методы не доступны. На VBA роль семейства играет проект.

События

В мире объектов время от времени происходят события. Причиной их могут быть действия пользователя или реакция системы на ранее происшедшие события. При возникновении события, объекту с ним связанному, система посылает сообщение, при получении которого вызывается специальный метод - обработчик события. Эти методы, вызываемые специальным образом, и называются событиями. Итак, каждый класс имеет свойства, методы и события. Все объекты - экземпляры класса имеют одинаковый набор свойств, методов и событий, заданных определением класса. Методы у всех экземпляров класса одинаковы. Но, заметьте, обработчики событий у каждого экземпляра собственные! Впрочем, это же касается и значений свойств, - каждый экземпляр уникален. Все командные кнопки имеют метод Delete, который всегда выполняется одинаково, удаляя кнопку. Но щелчок по каждой кнопке, вызывающий событие Click, приводит к совершенно разным результатам. В этом сила событий, - поведение объектов становится уникальным.

VBA позволяет работать с объектами Office 2000, которым несть числа, и собственными объектами, классы которых мы умеем определять. Большинство из объектов Office 2000 не имеет событий, например, прославленный объект Range имеет множество свойств и методов, но ни одно из событий с ним не связывается. С другой стороны все объекты, предназначенные для организации интерфейса с пользователем, - формы, кнопки, списки и прочие объекты обладают набором событий. Но не только интерфейсные объекты имеют события. Объекты, задающие документы Word и Excel, страницы рабочих книг Excel, объекты Application также имеют встроенный набор событий. Для большинства из них мы подробно рассмотрели, как создаются обработчики событий для конкретных экземпляров. Напомним, есть специальный тип модулей, связанных с объектами, имеющими события, - сюда относятся модули форм, документов и другие. В окне кода этого модуля можно выбрать конкретный объект, выбрать для него возможное событие, построить заготовку обработчика события и наполнить затем ее содержанием. Подробнее об этом сказано в предыдущей лекции, посвященной модулям. Нам осталось рассмотреть две серьезные задачи:

К решению этих двух важных задач мы сейчас и приступим.

Классы, объекты With Events и обработчики событий

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

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

Модуль класса с объектом WithEvents

Модуль, в котором будут появляться обработчики событий объекта Excel.Application, синтаксически является модулем класса, который нужно создать. Этот класс очень прост по своей структуре и при создании он содержит единственное закрытое свойство - соответствующий объект Application, объявленный со спецификатором WithEvents. Так что в нашем примере все описание создаваемого класса, который назовем, например, ExcelWithEvents сводится к одной содержательной строке:

Option Explicit
'Класс ExcelWithEvents
Public WithEvents xlApp As Excel.Application

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

Мы ограничились созданием двух обработчиков события NewWorkbook и OpenWorkbook. Вот их текст:

Private Sub xlApp_NewWorkbook(ByVal Wb As Excel.Workbook)
    MsgBox("Рад, что вы открыли книгу "  Wb.Name)
End Sub 

Private Sub xlApp_WorkbookOpen(ByVal Wb As Excel.Workbook)
    MsgBox ("Рад, что вы открыли книгу "  Wb.Name)
End Sub

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

Объект WithEvents

Вторая проблема решается также довольно просто. Но здесь есть одна тонкость, которую следует понимать. Реально создаются два объекта, мы называем их двойниками. Один из них это обычный объект Excel.Application, другой - объект Excel.ApplicationWithEvents из класса ExcelWithEvents. Эти два объекта должны быть связаны одной ссылкой. Вот процедура, которая в нашем примере вызывается в документе Word в тот момент, когда пользователь решит начать работу с книгами Excel:

Public Sub CreateExApp()
    Const PathToMyDir = "e:\O2000\CD2000\Ch4\"
    'Чистый Excel
        Dim MyEx As New Excel.Application
    'Excel With Events
        Dim MyExWithEv As New ExcelWithEvents
    'Связывание
    Set MyExWithEv.xlApp = MyEx
    'Добавляем новую книгу и открываем существующую
    'Обработчики событий New и Open работают!
    With MyEx
       .Visible = True
       .Workbooks.Add 1
       .Workbooks.Add PathToMyDir  "BookOne"
    End With
End Sub

Поверьте, обработчики событий действительно вызывались, как при создании новой книги, так и открытии книги, основанной на существующем шаблоне. Осталось сказать несколько слов о том, как это все могло выглядеть, если всю эту процедуру осуществлять в самом Excel. Обратите внимание, в нашем примере Excel Application с событиями появляется до того, как открыта какая либо из его книг. Если же работать в Excel, то описание объекта с событиями и связывание необходимо поместить в первую из открываемых книг. Мы проделали эту работу и в проекте книги BookOne создали класс ExcelWithEvents, а в одном из стандартных модулей создали процедуру:

Public Sub ConnectingWithEvents()
    Const PathToMyDir = "e:\O2000\CD2000\Ch4\"
    'Excel With Events
        Dim MyExWithEv As New ExcelWithEvents
    'Связывание
    Set MyExWithEv.xlApp = Excel.Application
    'Добавляем новую книгу и открываем существующую
    'Обработчики событий New и Open работают!
    With Application
       .Visible = True
       .Workbooks.Add 1
       .Workbooks.Add PathToMyDir  "BookTwo"
    End With

End Sub

Как видите, эта процедура отличается от процедуры CreateExApp лишь незначительными деталями. Возникает вопрос, как и когда запускать эту процедуру. Можно это делать по-разному, например, вызывать ее в обработчике события Click командной кнопки, можно вызывать ее в обработчике события OpenDocument. В последнем случае, обработчики событий объекта Application будут выполняться для всех книг, сразу после открытия книги BookOne.

События собственных классов

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

Как создать класс с событиями

Первый вопрос, который необходимо решить при создании класса с событиями, лежит вне программирования, прежде всего, нужно решить, каким должен быть набор событий у объектов класса. Если с объектом связан некоторый графический образ, то ситуация более или менее стандартна, всегда разумно иметь события Click, Move, Resize и другие, типичные для графических объектов. Эти события будут возникать, когда пользователь будет работать с графическим образом, выполняя над ним те или иные типичные действия. Во многих случаях, наши объекты могут и не иметь графического образа, но и для них не менее полезно определить события. Общие рекомендации давать трудно, поэтому обратимся к примеру и рассмотрим ранее созданный класс Личность. Какие события разумно было бы определить для объектов этого класса? Учитывая, что свойств у объектов класса не так много, число разумных событий также не велико. Давайте определим два события - ИзменениеФамилии и ДеньРождения. Первое из этих событий возникает в ответ на изменение значения свойства Фамилия, второе, - когда текущая дата отличается от даты дня рождения Личности не более чем на сутки.

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

Option Explicit
'Класс Личность
'События класса
Public Event ИзменениеФамилии(Fam As String, NewFam As String)
Public Event ДеньРождения(Dat As Date)

'Далее следует уже знакомое определение свойств и методов класса
'Смотри раздел "Создание класса Личность" этой лекции

Итак, чтобы создать класс с событиями просто добавьте список этих событий в объявление класса!

Как зажигаются события

Чтобы событие, связанное с объектом возникло, его нужно зажечь или возбудить ( Raise ). Зажигается событие специальной процедурой RaiseEvent, имеющей следующий синтаксис:

Sub RaiseEvent имя_события (параметры)

Эта процедура не только возбуждает событие, но и передает некоторые параметры, которые могут быть использованы в обработчике события. Что стоит за терминами "зажечь" ("возбудить") событие? При выполнении этой процедуры операционной системе посылается уведомление о том, что та должна послать объекту сообщение о возникновении события с указанным именем, в ответ на получение которого будет вызван обработчик этого события. Так что при выполнении этой процедуры плавный ход выполнения программы прерывается, происходит обмен сообщениями, вызов обработчика события и только по его завершении будет продолжено выполнение операторов, стоящих после вызова RaiseEvent.

Процедура RaiseEvent должна выполняться в одном из методов класса с событиями. Правильное определение ее места, это также одна из задач, которую нужно решить при проектировании класса, возможно, придется создавать специальный метод для этой цели. Обратимся к нашему примеру, когда и где нужно зажечь событие ИзменениеФамилии. Здесь ответ очевиден, - всякий раз, когда у объекта изменяется значение свойства Фамилия, должно возникать это событие. Но изменять значение для Private свойства следует единственным образом, - вызовом Property Let ВашаФамилия. Поэтому эта процедура именно то место, где должно возбуждаться событие. А в процедуре разумно поставить вызов RaiseEvent непосредственно перед оператором, изменяющим фамилию. Вот как выглядит эта процедура:

Public Property Let ВашаФамилия(ByVal NewValue As String)
    'Зажигает событие ИзменениеФамилии
    RaiseEvent ИзменениеФамилии(Фамилия, NewValue)
    Фамилия = NewValue
End Property

Заметьте, мы передаем обработчику два параметра, старую и новую фамилию. Важно понимать, что можно не только передавать обработчику данные, но и получать информацию от него. Добавим еще один параметр Permission нашему событию, так чтобы обработчик события, проверив допустимость изменения фамилии, мог вернуть разрешение на изменение. Новый вариант события теперь выглядит так:

Public Event ИзменениеФамилии(Fam As String, NewFam As String, _
            Permission As Boolean)

Соответственно изменится и процедура - свойство Property Let. Вот другой, более разумный вариант этой процедуры:

Public Property Let ВашаФамилия(ByVal NewValue As String)
    'Зажигает событие ИзменениеФамилии
    Dim Permission As Boolean 'Разрешение на изменение фамилии
    Permission = True
    RaiseEvent ИзменениеФамилии(Фамилия, NewValue, Permission)
    'Обработчик события может запретить изменение фамилии
    If Permission Then Фамилия = NewValue
End Property

Менее ясно, где и когда следует зажигать событие ДеньРождения. Мы решили возбуждать это событие в тот момент, когда пользователь интересуется датой рождения объекта, и вставили соответствующую проверку в Property Get ВашаДатаРождения процедуру:

Public Property Get ВашаДатаРождения() As Date
    'Зажигает событие ДеньРождения
    'в зависимости от значения текущей даты
    If (Month(Now) = Month(ДатаРождения)) And _
        (Abs(Day(Now) - Day(ДатаРождения)) <= 1) Then
        RaiseEvent ДеньРождения(ДатаРождения)
    End If
    ВашаДатаРождения = ДатаРождения
End Property

Здесь событие возбуждается при выполнении некоторого условия, - текущая дата отличается от даты дня рождения не более чем на сутки. Дата рождения передается обработчику события, а тот, в свою очередь, может организовать уведомление и поздравление объекта с днем рождения, как это делает, например, Outlook для контактов из списка контактов.

Заметьте, процедура - свойство Property Get, в которой мы разместили оператор RaiseEvent, возбуждающий событие, - это не единственно возможное место для такого оператора. Вообще, одно и то же событие может возбуждаться в разных местах. В данном случае, может быть, имело смысл написать еще и специальный метод для возбуждения события, который вызывался бы пользователем в нужный момент.

Где и как следует создавать обработчики событий для экземпляров класса

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

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

Модуль, в котором можно объявлять объекты With Events может быть либо модулем класса, либо модулем формы, но, заметьте, это не может быть стандартный модуль. В большинстве случаев предпочтение отдается модулю класса. Позже мы остановимся подробнее на ситуации, когда объекты с событиями объявляются в модуле формы. Предположим, что для решения некоторой задачи, нам потребовалось работать с двумя конкретными объектами класса Личность, - нашим старым приятелем и знакомой молодой девушкой. Для решения задачи создадим класс, который назовем " Личности " и поместим туда объявление двух объектов MyFriendOne и MyFriendTwo. Объекты объявлены со спецификатором WithEvents, указывающим на то, что они должны реагировать на события. Как только эти объявления появятся в разделе объявлений класса, сами объекты появятся в окне кода в списке объектов. Теперь, выбрав объект из списка, можно открыть список возможных событий объекта и создать вначале заготовку обработчика событий, а потом наполнить ее содержанием.

Заметьте, эта технология работы нам уже хорошо знакома. Она использовалась при создании объектов Application With Events. Теперь становится понятным, что тогда шла речь о частном случае. Помните, при создании класса ExcelWithEvents, говоря о его структуре, мы обращали внимание на то, что в классе объявлен всего лишь один объект с событиями. Теперь становится понятным, это отражало специфику частного случая, - приложение, обычно, существует в единственном экземпляре. Личностей же, реагирующих на события, может быть много, - для каждой из них нужно задать свой экземпляр объекта в классе, чтобы была возможность написать индивидуальный обработчик события. Взгляните на реализацию класса Личности:

Option Explicit
Private WithEvents myFriendOne As Личность
Private WithEvents myFriendTwo As Личность

Private Sub myFriendOne_ДеньРождения(Dat As Date)
    BirthDay (Dat)
End Sub

Private Sub myFriendOne_ИзменениеФамилии(Fam As String, _
    NewFam As String, Permission As Boolean)
    MsgBox ("Изменение фамилии "  Fam  " на "  NewFam  Chr(13) _
         "не разрешается.")
  Permission = False
End Sub

Private Sub myFriendTwo_ДеньРождения(Dat As Date)
    BirthDay (Dat)
End Sub

Private Sub myFriendTwo_ИзменениеФамилии(Fam As String, _
    NewFam As String, Permission As Boolean)
    MsgBox ("Поздравляю с замужеством, дорогая "  _
      Fam  "-"  NewFam  "!")
    Permission = True
End Sub

Public Sub BirthDay(Dat As Date)
Debug.Print Dat, "-", Now
 Select Case Day(Dat)
        Case Day(Now)
            MsgBox ("Сегодня День Рождения!")
        Case Is < Day(Now)
            MsgBox ("Вчера был День Рождения!")
        Case Else
            MsgBox ("Завтра День Рождения!")
    End Select

End Sub 

Public Sub Connect()
    Set myFriendOne = FriendOne
    Set myFriendTwo = FriendTwo
End Sub

Как видите, в этом классе два Private объекта, реагирующих на события, и для каждого из них написаны по два обработчика событий класса. Сейчас не суть важно, что делают эти обработчики. В одном случае обработчик события ИзменениеФамилии разрешает это изменение, в другом - нет, и выдает по этому поводу, естественно, разные сообщения. Обработчики события ДеньРождения выполняют одну и ту же задачу, поэтому они вызывают общую процедуру работы. Это, хотя и интересные, но все-таки детали. Более важную для понимания играет роль процедура, названная Connect.

Связывание объектов

Особенностью рассматриваемой технологии работы с объектами, реагирующими на события, является то, что существует пара объектов - двойников. Один из них, реальный объект, объявляется как объект без событий, другой, его двойник, объявляется в специальном классе с описателем With Events. Для двойника создаются обработчики событий, но, чтобы все это заработало нужным образом, эту пару объектов нужно связать законными узами брака. Так мы поступали при работе с объектами Excel.Application и Excel.Application WithEvents. Также мы поступили в процедуре Connect с двумя парами объектов - двойников: MyFriendOne - FriendOne и MyFriendTwo - FriendTwo.

Реальные объекты и инициирование событий

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

Для класса Личность мы уже описали методы, зажигающие события. Поэтому нам осталось только привести описание стандартного модуля Примеры, в котором ведется работа с двумя объектами, названными FriendOne и FriendTwo:

Option Explicit
'Модуль Примеры
Public FriendOne As New Личность
Public FriendTwo As New Личность
Public FOne As New Личности

Public Sub Знакомство()
'Вызывается конструктор с параметрами
'и происходит знакомство с объектами
FriendOne.InitPerson FN:="Станислав", LN:="Федотов", _
    DOB:="21.05.39"
FriendTwo.InitPerson FN:="Катя", LN:="Павлова", _
    DOB:="22.03.79"
FriendOne.PrintPerson
FriendTwo.PrintPerson
FriendOne.SayWhoIs
FriendTwo.SayWhoIs
'Связывание с двойниками.
'Теперь объекты могут реагировать на события!
FOne.Connect
End Sub

Public Sub CallEvents()
    Dim DOB As Date
   
 'Вызов методов приведет к возникновению событий!
    'При замене фамилии возникнет событие ИзменениеФамилии
    'Заметьте, не всегда фамилия будет изменена!
    FriendOne.ВашаФамилия = "Фидотов"
    FriendTwo.ВашаФамилия = "Волконская"

    'При попытке узнать дату рождения
    'может быть вызван обработчик события ДеньРождения.
    DOB = FriendOne.ВашаДатаРождения
    DOB = FriendTwo.ВашаДатаРождения
   FriendOne.PrintPerson
   FriendTwo.PrintPerson
End Sub

В этом модуле объявлены два объекта класса Личность и один объект класса Личности. Две процедуры - Знакомство и CallEvents вызываются в ответ на щелчки командных кнопок в соответствующих обработчиках событий. Первой должна вызываться процедура Знакомство, где объекты FriendOne и FriendTwo получают "нормальные" значения и происходит Знакомство с ними. Важно, что здесь же происходит связывание этих объектов с их двойниками. Обратите внимание, нам понадобился объект FOne класса Личности, чтобы вызвать его метод Connect и связать эти пары объектов. В процессе работы этих модулей будет вестись диалог с пользователем. На следующих рисунках показаны сообщения, выдаваемые обработчиками событий ИзменениеФамилии и ДеньРождения.

Приведем еще результаты отладочной печати:

Станислав             Федотов       родился       21.05.39 
Катя                  Павлова       родилась      22.03.79 
22.03.79      -       22.03.99 13:14:01 
Станислав             Федотов       родился       21.05.39 
Катя                  Волконская    родилась      22.03.79

Итоги

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

Одно из возможных применений этой технологии работы состоит в том, что классы с событиями могут выступать как упаковка для элементов управления. Цель такого класса состоит в расширении свойств элемента управления и, в частности, в добавлении новых событий, на которые мог бы реагировать этот элемент управления. Надеемся, что данное описание позволит Вам самостоятельно построить такое приложение. Заметим только, что в таких случаях используется модуль формы, для объявления объектов WithEvents и создания обработчиков событий этих объектов.