Картинка: Designed by vectorjuice / Freepik

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

Большинство пользователей VBA прекрасно знают такую штуку как Type, он же User Defined Type (UDT). Кто-то, как я, использует его на повседневной основе. Кто-то, возможно, о нем слышал, но не мог понять как его применить.

Лично я помню, как не так давно смотрел на этот Type и пытался понять зачем он мне нужен, ведь он просто хранит в себе переменные, которые можно с тем же успехом объявить в функции/процедуре или на уровне модуля?

В этой статье я хотел бы показать на примере как можно использовать Type. Мы разберем некоторые его особенности, и возможно кто-нибудь из читателей найдет для себя один из примеров крайне интересным (а может быть даже будет использовать в своих проектах). Поехали!

Вычисляем ошибки, чтобы их не допускать

Что же, для начала давайте обратимся к официальной документации:

(вольный перевод автора)
Оператор Type – используется на уровне модуля для объявления пользовательского типа данных, содержащего один или несколько элементов.Type можно использовать только на уровне модуля. После объявления пользовательского типа вы можете объявить переменную этого типа в любом месте в пределах области видимости. Для объявления переменной пользовательского типа используйте Dim, Private, Public, ReDim или Static... Номера и метки строк не допускаются внутри блоков Type...End Type.

Итак, исходя из документации мы можем выделить два основных момента:

1. Оператор Type используется только на уровне модуля. Это значит, что его нельзя объявлять в процедурах/функциях/методах/свойствах.

2. Номера и метки строк не допускаются внутри блоков.

Давайте протестируем оба утверждения:

В первом случае получаем ошибку компиляции "Недопустимая внутренняя процедура",

во втором так же ошибка компиляции "Оператор (заявление/утверждение) недопустим внутри блока 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, а так же тело письма.

Для начала разделим все наши вводные на несколько блоков:

1. Блок адресатов: получатель, копия.

2. Блок письма: тема и тело.

3. Блок параметров: отправлять или нет, помечать как прочитанное или нет.

Итого получаем три блока по две переменных в каждом.
Как это реализовать? Очень просто.

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