Картинка: Designed by vectorjuice / Freepik
Кому будет полезна статья, по мнению автора:
начинающим программистам на языке VBA и тем, кто не работал ранее с оператором Type. Если вы используете этот оператор постоянно, можно сравнить свой вариант применения и вариант автора.
Большинство пользователей VBA прекрасно знают такую штуку как Type, он же User Defined Type (UDT). Кто-то, как я, использует его на повседневной основе. Кто-то, возможно, о нем слышал, но не мог понять как его применить.
Лично я помню, как не так давно смотрел на этот Type и пытался понять зачем он мне нужен, ведь он просто хранит в себе переменные, которые можно с тем же успехом объявить в функции/процедуре или на уровне модуля?
В этой статье я хотел бы показать на примере как можно использовать Type. Мы разберем некоторые его особенности, и возможно кто-нибудь из читателей найдет для себя один из примеров крайне интересным (а может быть даже будет использовать в своих проектах). Поехали!
Вычисляем ошибки, чтобы их не допускать
Что же, для начала давайте обратимся к официальной документации:
(вольный перевод автора)
Оператор Type – используется на уровне модуля для объявления пользовательского типа данных, содержащего один или несколько элементов.Type можно использовать только на уровне модуля. После объявления пользовательского типа вы можете объявить переменную этого типа в любом месте в пределах области видимости. Для объявления переменной пользовательского типа используйте Dim, Private, Public, ReDim или Static... Номера и метки строк не допускаются внутри блоков Type...End Type.
Итак, исходя из документации мы можем выделить два основных момента:
Оператор Type используется только на уровне модуля. Это значит, что его нельзя объявлять в процедурах/функциях/методах/свойствах.
Номера и метки строк не допускаются внутри блоков.
Давайте протестируем оба утверждения:
В первом случае получаем ошибку компиляции "Недопустимая внутренняя процедура",
во втором так же ошибка компиляции "Оператор (заявление/утверждение) недопустим внутри блока Type".
Не описано в официальной документации то, что объявленный в Class модуле Type может быть только Private, иначе мы снова получим ошибку компиляции, в этот раз "Нельзя объявлять публичный пользовательский тип в объектном модуле":
Компилятор перестает ругаться только в случае Private Type в Class модуле, но здесь нужно помнить, что возвращать такой UDT можно только Private функцией, иначе:
мы снова получим ошибку компиляции, теперь это "Private перечисления и пользовательские типы, не могут использоваться в качестве параметров или возвращаемых типов для Public процедур, членов данных или полей пользовательских типов".
Кстати, как и обозначено в описании ошибки, в модуле класса нельзя создавать публичные поля или использовать параметры для публичных методов с приватным типом UDT. Ну оно и логично.
Постановка задачи
Итак, если я не ошибаюсь, с ошибками мы разобрались. Перейдем к использованию.
Давайте представим, что наша задача – почтовая рассылка по определенному скрипту. Во время выполнения макроса мы получаем информацию об email-адресе получателя, адресате копии письма и его теме, после чего все эти данные нам нужно передать в отдельную функцию, которая занимается созданием письма и его отправкой или сохранением в черновики.
Решаем без UDT
Для начала разберемся с обычным модулем. Использование UDT в Class модуле будет во второй части.
Как можно решить эту задачу стандартными средствами?
Что ж, первое что мы делаем – объявляем переменные, которые будут содержать адрес получателя и адрес адресата копии (простите за тавтологию), а так же тему письма, после чего присваиваем напрямую значения, чтобы не усложнять пример, и отправляем их как аргументы в функцию CreateLetter:
Sub Mailing()
Dim AddressTo As String: AddressTo = "exampleTo@test.vba"
Dim AddressCC As String: AddressCC = "exampleCC@test.vba"
Dim Subject As String: Subject = "Тема письма"
CreateLetter AddressTo, AddressCC, Subject
End SubДалее, пропишем функцию, которая создаст и отправит или сохранит письмо (это значение сделаем необязательным, по умолчанию установим в False):
Sub CreateLetter(ByVal AddressTo As String, _
ByVal AddressCC As String, _
ByVal Subject As String, _
Optional ByVal Submit As Boolean = False)
Dim Outlook As Object
Set Outlook = CreateObject("Outlook.Application")
With Outlook.CreateItem(olMailItem)
.To = AddressTo
.CC = AddressCC
.Subject = Subject
If Submit Then .Send
End With
End SubИтак, в целом все нормально. У нас есть данные, мы передаем их в функцию, функция их использует.
Но это всего лишь два адреса и тема.
А теперь представим, что нам нужно передавать еще текст тела письма и вложение.
А еще в параметрах можно указать нужно ли удалять письмо после отправки (свойство DeleteAfterSubmit), или указать нужно ли отметить неотправленное письмо (черновик) как прочитанное (свойство UnRead).
А еще, возможно нам потребуется создавать письмо из другой процедуры и тогда снова придется перечислять все переменные в объявлении и передавать их все в функцию.
И многое, многое другое...
Представьте на секунду насколько сильно разрастутся параметры функции.
Плюс, копия в письме может быть не всегда, как и вложение. Тогда придется делать все параметры Optional? Или прописать ParamArray? Это все не наглядно и может вызвать ошибки, в случае не верной передачи параметров.
Код становится менее читаемым и сумбурным, согласитесь. На таком небольшом примере все ок, ничего особо критичного. Но в реальном проекте это может стать большой проблемой.
Гораздо более лаконичное решение, как вы уже поняли, использовать UDT.
Решаем с UDT
Для решения нам потребуется объявить Type на уровне модуля и поместить в него все наши переменные. Давайте назовем его TLetter:
Type TLetter
AddressTo As String
AddressCC As String
Subject As String
End TypeДалее, в процедуре Mailing создадим переменную Letter типа TLetter:
Sub Mailing()
Dim Letter As TLetter
Dim AddressTo As String: AddressTo = "exampleTo@test.vba"
Dim AddressCC As String: AddressCC = "exampleCC@test.vba"
Dim Subject As String: Subject = "Тема письма"
CreateLetter AddressTo, AddressCC, Subject
End SubТеперь, всем полям нашего типа присваиваем необходимые значения. Сделать это можно написав имя переменной Letters и далее через точку выбрать нужное поле:
Sub Mailing()
Dim Letter As TLetter
Letter.AddressTo = "exampleTo@test.vba"
Letter.AddressCC = "exampleCC@test.vba"
Letter.Subject = "Тема письма"
CreateLetter Letter
End SubНичего вам это не напоминает??
Если вы сказали "да это же как объект" – то вы совершенно правы. Взаимодействие с Type очень похоже на взаимодействие с объектами. Только мы объявляем его без ключевых слов New и Set, как в случае с объектами, а так же не сможем поместить в него функции/процедуры. Я бы даже назвал этот блок, скорее, своего рода, структурой.
Все что нам осталось сделать – заменить в процедуре CreateLetter три старых параметра на один новый и переписать присваивание параметров:
Sub CreateLetter(ByRef Letter As TLetter, _
Optional ByVal Submit As Boolean = False)
Dim Outlook As Object
Set Outlook = CreateObject("Outlook.Application")
With Outlook.CreateItem(olMailItem)
.To = Letter.AddressTo
.CC = Letter.AddressCC
.Subject = Letter.Subject
If Submit Then .Send
End With
End SubКстати, в блоке Ошибки я забыл упомянуть еще одну небольшую особенность – UDT в параметры можно передавать только
ByRef.
Так лучше, верно?
Не совсем. Давайте уберем последний опциональный параметр Submit из функции и пропишем его в нашей структуре как поле:
Option Explicit
Type TLetter
AddressTo As String
AddressCC As String
Subject As String
Submit As Boolean ' Переносим параметр в структуру.
End Type
Sub Mailing()
Dim Letter As TLetter
Letter.AddressTo = "exampleTo@test.vba"
Letter.AddressCC = "exampleCC@test.vba"
Letter.Subject = "Тема письма"
CreateLetter Letter
End Sub
Sub CreateLetter(ByRef Letter As TLetter)
Dim Outlook As Object
Set Outlook = CreateObject("Outlook.Application")
With Outlook.CreateItem(olMailItem)
.To = Letter.AddressTo
.CC = Letter.AddressCC
.Subject = Letter.Subject
If Letter.Submit Then .Send ' Передаем поле из структуры.
End With
End Sub
Вот теперь действительно лучше.
Обратите внимание, мы не присваиваем полю Submit значение в процедуре Mailing. Не присвоенное значение по умолчанию останется False:
Думаю не нужно объяснять, что расширять этот тип можно сколько угодно, при этом использовать все его поля нет необходимости. Вы можете оставлять их пустыми и уже в функции прописывать валидацию для пустых полей, если в этом есть потребность.
Расширяем возможности
Итак, мы научились складывать несколько связанных переменных в одну и использовать их в качестве аргумента функции.
Но что если нам нужно очень много таких переменных и при этом они связаны между собой в своего рода блоки, а эти блоки можно связать в одну единую переменную?
Давайте добавим новые вводные в задачу и рассмотрим на примере.
Допустим в функцию CreateLetter нам нужно дополнительно передавать параметр UnRead, а так же тело письма.
Для начала разделим все наши вводные на несколько блоков:
Блок адресатов: получатель, копия.
Блок письма: тема и тело.
Блок параметров: отправлять или нет, помечать как прочитанное или нет.
Итого получаем три блока по две переменных в каждом.
Как это реализовать? Очень просто.
Для начала, под каждый блок создаем свой UDT:
Option Explicit
' Блок адресатов
Type TRecipient
To As String
CC As String
End Type
' Блок письма
Type TMain
Subject As String
Body As String
End Type
' Блок параметров
Type TParameter
Submit As Boolean
UnRead As Boolean
End TypeПосле чего снова создаем UDT TLetter, а уже в нем объявляем три переменных с ранее созданными блоками:
Type TLetter
Recipient As TRecipient
Main As TMain
Parameter As TParameter
End TypeДа, так можно было. ?
Дальше, что называется, следите за руками.
В процедуре Mailing через уже знакомую переменную Letter присваиваем значения переменнным блока адресатов и блока письма:
Sub Mailing()
Dim Letter As TLetter
Letter.Recipient.To = "exampleTo@test.vba"
Letter.Recipient.CC = "exampleCC@test.vba"
Letter.Main.Subject = "Тема письма"
Letter.Main.Body = "Тело письма"
CreateLetter Letter
End SubНемного корректируем функцию CreateLetter и добавляем новые параметры для создаваемого элемента письма (не функции):
Sub CreateLetter(ByRef Letter As TLetter)
Dim Outlook As Object
Set Outlook = CreateObject("Outlook.Application")
With Outlook.CreateItem(olMailItem)
.To = Letter.Recipient.To
.CC = Letter.Recipient.CC
.Subject = Letter.Main.Subject
.Body = Letter.Main.Body
.UnRead = Letter.Parameter.UnRead
If Letter.Parameter.Submit Then .Send
End With
End SubИ все! Да, так просто.
В реальных задачах меня такая гибкость очень сильно выручала, выручает и, уверен, еще будет выручать.
Что в итоге
В итоге, мы имеем очень удобный и гибкий инструмент для хранения некой связанной структуры данных.
Так же, этот инструмент помогает нам защитить код от ошибок на моменте его написания, потому что передать непонятно что в функцию будет сильно сложнее, чем если бы мы использовали обычные типы.
Код, благодаря такому подходу, становится, во-первых, более читаемым, и во-вторых, более гибким и расширяемым. С таким кодом гораздо приятнее работать.
А ведь это важные вещи, к которым мы все стремимся при написании кода.
Это не все, что я хотел рассказать про Type. В следующей статье рассмотрим еще один пример использования UDT в модуле, а так же увидим как его применять в Class модуле.
Спасибо, что прочитали до конца.
А как вы используете Type? Пишите в комментариях!
А также, подписывайтесь на мой телеграмм.
