Как загрузить класс в excel

Макросы – это полноценная программа, просто она выполняется на базе другого приложения. Следовательно, все принципы программирования соблюдаются. А все языки программирования разделяются на две категории: процедурные и объектно-ориентированные.

Макросы разрабатываются на базе языка VBA, который является скорее процедурным с возможностью обращения к отдельным объектам. Недостатком такого подхода есть то, что одна процедура не связана тесно с другой. 

Объектно-ориентированный подход имеет некоторые принципиальные отличия от процедурного. Сейчас этот тип программирования является наиболее популярным. Поэтому его нужно рассмотреть более детально применительно к макросам Excel.

Общие сведения и определения

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

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

Выражаясь проще, класс – это шаблон, по которому генерируется объект.

Структура класса:

1. Поле. Это такой элемент класса, в котором непосредственно содержатся данные.
2. Свойство. Это составная часть класса, в которой также хранятся данные, которые в дальнейшем могут быть обработаны.
3. Метод. По сути та же процедура или функция, просто в рамках класса. Методы – одно из главных понятий любого объектно-ориентированного языка программирования. 
4. Событие. Это ситуация, при которой активируется метод. Это может быть изменение содержимого ячеек или выполнение другого метода. 

VBA не является полноценным объектно-ориентированным языком программирования, поскольку в нем есть только два принципа:

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

Как создать класс в VBA

Переходим к практическим аспектам использования классов в языке программирования VBA. Чтобы создать класс, в редакторе нужно нажать на пункт «Class Module», который можно найти в меню «Insert». Далее нужно классу дать определенное имя. Это можно сделать только одним способом – изменить имя, сгенерированное автоматически.

VBA предусматривает возможность спрятать класс от другой книги, если она ссылается на эту. За эту возможность отвечает свойство Instancing. Если его значение выставлено на Private, то этот класс будет обнаруживаться только той книгой, в которой макрос открыт. Если такой макрос открыт на нескольких документах, то класс будет доступен только той книге, к которой он привязан. Если же установить параметр PublicNotCreateable, то класс будет обнаруживаться в том случае, если он создан в книге, но все равно не будет доступен для других книг. 

Способы создания экземпляра класса

Итак, под классом подразумевается описание объекта, но не сам объект. Чтобы на основе класса его создать, необходимо воспользоваться одним из доступных способов. 

Способ №1

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

Private Sub TestClass()  

Dim cl As ExampleClass   

Set cl = New ExampleClass End Sub 

Способ №2

Dim cl As ExampleClass   

Private Sub TestClass()   

Set cl = New ExampleClass End Sub 

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

Способ №3

Dim cl WithEvents As ExampleClass   

Private Sub TestClass()   

Set cl = New ExampleClass End Sub

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

Способ №4

Private Sub TestClass()   

Dim cl As New ExampleClass   

End Sub

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

Как удалить экземпляр класса?

Хорошая привычка – очистить выделенную память, если этот объект уже не нужен. Это позволит значительно увеличить быстродействие макроса. Особенно это важно, если он будет использоваться на слабом компьютере. 

Чтобы это сделать, нужно воспользоваться следующей строкой кода.

Set cl = Nothing

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

Как создать поля класса

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

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

Но отличаются другим – невозможно указать значение, которое будет отображаться в поле по умолчанию, а также невозможно запретить средствами VBA его редактирование. Информация в поле хранится до того момента, как она не будет перезаписана или же пока существует соответствующая переменная. 

Чтобы создать поле, необходимо выполнить такой код.

Dim sBody As String 

Также можно воспользоваться таким вариантом кода, который выдает тот же результат.

Private sBody As String 

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

Public Head As String   

После этих манипуляций становится возможным использование свойства Head у объекта. С ним можно выполнять разные операции, включая запись:

cl.Head = «FHead»   

и чтение

Debug.Print cl.Head  

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

Процесс определения свойств класса

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

Для чтения данных используется функция Property Get, а для записи – Property Let. Конечно, языком предусмотрена еще и третья конструкция –– Property Set, но на практике она используется редко из-за того, что ссылку на другой объект (а именно для этого и нужна указанная функция) можно записать и с помощью процедуры Property Let.

Давайте детальнее опишем синтаксис всех описанных функций. Итак, вот скриншот, описывающий синтаксис функции Property Get.

А вот таблица, в которой детально описываются элементы свойств класса.

При чтении свойства класса нужно учитывать такие нюансы:

1. С помощью элемента Exit Property осуществляется выход из метода. Допустимо использование сразу нескольких подобных элементов в рамках одного метода. Это может быть полезным, например, если используются циклы и условные операторы. 
2. Несмотря на то, что сама функция Property Get может содержать неограниченное количество процедур внутри, она сама не может быть составной частью других функций.

Теперь давайте более подробно рассмотрим синтаксис функции Property Let. Он виден на этом скриншоте.

Этой функции касаются все замечания, рассмотренные выше.

Ну и наконец, как выглядит синтаксис функции Property Set. Несмотря на то, что она считается бесполезной, знать, как с ней работать нужно хотя бы потому, что другой человек может использовать именно ее. И нужно уметь читать чужой код. Сам синтаксис приводится на этом скриншоте.

Пример создания свойства в модуле класса

А теперь давайте детальнее рассмотрим некоторые практические примеры. Будем приводить фрагменты кода с краткими пояснениями.

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

Теперь давайте взглянем немного на другой фрагмент кода.

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

В этом примере свойство не может быть отредактировано, и в нем содержится постоянное значение (константа). Ее можно открыть только из модуля, который находится в данном объекте. Если мы попробуем использовать конструкцию Public Const sHeight As Single = 2, то у нас ничего не получится.

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

Методы класса

В рамках класса можно создавать как процедуры, так и функции. Все они суммарно называются методами, но лишь при одном условии. Чтобы функция считалась методом, она должна быть открыта для других классов. Если же не требуется таких прав для подпрограмм, то нужно обязательно их делать приватными. Это обязательное правило, которое соответствует принципу инкапсуляции. 

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

События класса

Внутри каждого класса содержится уже несколько событий:

1. Class_Initialize. Событие, которое осуществляется в момент создания класса. Здесь можно легко настроить значения переменных и свойств, которые будут использоваться всегда, если не указано обратное. 
2. Class_Terminate. Это событие происходит, когда объект удаляется. Это происходит в двух случаях. Первый – деинициализация объекта. Второй – прекращение работы той процедуры, в рамках которой был объявлен класс.

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

Само же событие указывается в рамках самого модуля. 

Синтаксис конструкции, с помощью которой происходит объявление события, следующий.

Выводы

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

Председатель Мао

Классовая борьба, одни классы побеждают, другие исключаются. Такова история

Краткое руководство по VBA Class Module

Введение

Class Module VBA позволяют пользователю создавать свои собственные объекты. Если вы не знакомы с объектами, я настоятельно рекомендую вам сначала ознакомиться с моей статьей Все об объектах VBA Objects.

В таких языках, как C # и Java, классы используются для создания объектов. Class Module являются VBA-эквивалентом этих классов. Основное отличие состоит в том, что Class Module VBA имеют очень ограниченный тип наследования * по сравнению с классами на других языках. В VBA наследование работает аналогично интерфейсам ** в C # Java.

В VBA у нас есть встроенные объекты, такие как Collection, Workbook, Worksheet и так далее. Целью Class Module VBA является предоставление нам возможности создавать собственные объекты.

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

*Наследование использует существующий класс для создания нового класса.
**Интерфейсы — это форма наследования, которая заставляет класс реализовывать специфические процедуры или свойства.

Почему мы используем объекты

Использование объектов позволяет нам создавать наши приложения так же, как мы используем строительные блоки.

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

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

Если вам все еще неясно, не волнуйтесь. В остальной части этой статьи мы разберем все это на простые термины.

Преимущества использования объектов

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

1. Это позволяет нам создавать приложения по одному блоку за раз.
2. Намного проще протестировать отдельные части приложения.
3. Обновление кода не вызовет проблем в других частях приложения.
4. Легко добавлять объекты между приложениями.

Недостатки использования объектов

У большинства вещей в жизни есть свои плюсы и минусы. Использование Class Module VBA ничем не отличается. Ниже приведены недостатки использования Class Module для создания объектов.

1. Первоначально для создания приложений требуется больше времени *.
2. Не всегда легко четко определить, что такое объект.
3. Люди, плохо знакомые с классами и предметами, могут сначала найти их трудными для понимания.

*Если вы создаете приложение с использованием объектов, на его создание уйдет больше времени, поскольку вам придется тратить больше времени на планирование и проектирование. Однако в долгосрочной перспективе это сэкономит вам огромное количество времени. Вашим кодом будет легче управлять, обновлять и использовать повторно.

Создание простого Class Module

Давайте рассмотрим очень простой пример создания Class Module и использования его в нашем коде.

Чтобы создать Class Module, мы щелкаем правой кнопкой мыши в окне Project и затем выбираем Insert и Class Module.

Наш новый класс называется Class1. Мы можем изменить имя в окне свойств, как показано на следующем скриншоте.

Давайте изменим имя модуля класса на clsCustomer. Затем мы добавим переменную в Class Module следующим образом.

Теперь мы можем использовать этот Class Module в любом модуле (стандартном или классе) в нашей рабочей книге. Например:

' Создать объект из Class Module
Dim oCustomer As New clsCustomer

' Установите имя клиента
oCustomer.Name = "Иван"

' Напечатайте имя в Immediate Window(Ctrl + G)
Debug.Print oCustomer.Name

Class Module против Объектов

Люди, которые плохо знакомы с использованием классов и модулей классов VBA, часто путаются между тем, что такое класс и что является объектом.

Давайте посмотрим на пример из реального мира. Думайте о предмете массового производства как кофейная кружка. Дизайн кружки создается в первую очередь. Затем тысячи кофейных кружек создаются из этого дизайна.

Это похоже на работу Class Module и объектов.

Class Module можно рассматривать как дизайн.

Объект можно рассматривать как элемент, созданный из дизайна.

Ключевое слово New в VBA — это то, что мы используем для создания объекта из Class Module. Например:

' Создание объектов с использованием New
Dim oItem As New Class1
Dim oCustomer1 As New clsCustomer
Dim coll As New Collection

Примечание. Мы не используем New для таких элементов, как Workbooks и Worksheets. См. Когда New не требуется для получения дополнительной информации.

Class Module VBA против обычных модулей VBA

Написание кода в Class Module почти такое же, как написание кода в обычном модуле. Мы можем использовать тот же код, который мы используем в обычных модулях. То, как этот код используется, сильно отличается.

Давайте посмотрим на два основных различия между классом и обычным модулем. Это часто вызывает путаницу у новых пользователей.

Разница 1 — Как используются модули

Если вы хотите использовать подпрограмму / функцию и т.д. Из
Class Module, вы должны сначала создать объект.

Например, представьте, что у нас есть два идентичных Sub PrintCustomer. Один находится в Class Module, а другой — в обычном модуле…

' CLASS MODULE Код - clsCustomer
Public Sub PrintCustomer()
    Debug.Print "Пример вывода"
End Sub

' Код обычного модуля 
Public Sub PrintCustomer()
    Debug.Print "Пример вывода"
End Sub

Вы заметите, что коды абсолютно одинаковые.

Чтобы использовать подпрограмму PrintCustomer из Class Module, вы должны сначала создать объект этого типа

' Другой модуль
Sub UseCustomer()

    Dim oCust As New clsCustomer
    oCust.PrintCustomer

End Sub

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

' Другой модуль
Sub UseCustomer()

    PrintCustomer

End Sub

Разница 2 — Количество копий

Когда вы создаете переменную в обычном модуле, существует только одна ее копия. Для Class Module существует одна копия переменной для каждого создаваемого вами объекта.

Например, представьте, что мы создаем переменную StudentName как в классе, так и в обычном модуле.

' Обычный модуль
Public StudentName As String

' CLASS MODULE
Public StudentName As String

Для обычной переменной модуля в нашем приложении будет только одна копия этой переменной.

Для Class Module новая копия переменной StudentName создается каждый раз, когда создается новый объект.

Dim student1 As New clsStudent
Dim student2 As New clsStudent

student1.StudentName = "Петр"
student2.StudentName = "Василий"

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

Части Class Module

В Class Module есть четыре разных предмета. Это:

1. Методы — функции / подводные лодки.
2. Переменные-члены — переменные.
3. Свойства — типы функций / подпрограмм, которые ведут себя как переменные.
4. События — подводные лодки, которые запускаются событием

Вы можете видеть, что они все или функции, подпрограммы или переменные.

Давайте кратко рассмотрим некоторые примеры, прежде чем разбираться с ними по очереди.

' CLASS MODULE Код

' Переменная
Private dBalance As Double

' Свойства
Property Get Balance() As Double
    Balance = dBalance
End Property

Property Let Balance(dValue As Double)
    dBalance = dValue 
End Property

' Событие - срабатывает при создании класса
Private Sub Class_Initialize()
    dBalance = 100
End Sub

' Методы
Public Sub Withdraw(dAmount As Double)
    dBalance = dBalance - dAmount
End Sub

Public Sub Deposit(dAmount As Double)
    dBalance = dBalance + dAmount
End Sub

Теперь, когда мы увидели примеры, давайте рассмотрим каждый из них по очереди.

Методы Class Module

Методы относятся к процедурам класса. В VBA есть процедуры и функции. Как и переменные-члены, они могут быть Public или Private.

Давайте посмотрим на пример:

' CLASS MODULE Код

' Имя класса: clsSimple

' Публичные процедуры могут быть вызваны извне объекта
Public Sub PrintText(sText As String)
    Debug.Print sText
End Sub

Public Function Calculate(dAmount As Double) As Double
    Calculate = dAmount - GetDeduction
End Function

' частные процедуры могут быть вызваны только из Class Module
Private Function GetDeduction() As Double
    GetDeduction = 2.78
End Function

Мы можем использовать Class Module clsSimple следующим образом

Sub ClassMembers()
    
    Dim oSimple As New clsSimple
    
    oSimple.PrintText "Hello"
     
    Dim dTotal As Double
    dTotal = oSimple.Calculate(22.44)
     
    Debug.Print dTotal

End Sub

Переменные-члены Class Module

Переменная-член очень похожа на обычную переменную, которую мы используем в VBA. Разница в том, что мы используем Public или Private вместо Dim.

' CLASS MODULE Код

Private Balance As Double
Public AccountID As String

Примечание: Dim и Private делают одно и то же, но соглашение заключается в том, чтобы использовать Dim в sub / functions и использовать Private за пределами sub / functions.

Ключевое слово Public означает, что переменная может быть доступна вне Class Module. Например:

Dim oAccount As New clsAccount

' Действительный - AccountID открыт
oAccount.AccountID = "499789"

' Ошибка - Баланс является частным
oAccount.Balance = 678.90

В приведенном выше примере мы не можем получить доступ к Балансу, потому что он объявлен, как Частный. Мы можем использовать только приватную переменную внутри Class Module. Мы можем использовать функцию / подпрограмму в Class Module, например:

' CLASS MODULE Код
Private Balance As Double

Public Sub SetBalance()
    Balance = 100
    Debug.Print Balance
End Sub

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

Чтобы пользователь не общался напрямую с нашими переменными-членами, мы используем Свойства.

Свойства Class Module

1. Get — возвращает объект или значение из класса
2. Let — устанавливает значение в классе
3. Set — устанавливает объект в классе

Формат свойств VBA

Обычный формат для свойств выглядит следующим образом:

Public Property Get () As Type
End Property

Public Property Let (varname As Type )
End Property

Public Property Set (varname As Type )
End Property

Мы уже видели, что свойство это просто тип sub. Назначение свойства — позволить вызывающей стороне получать и устанавливать значения.

Почему мы используем свойства

Почему мы не можем просто сделать переменные общедоступными и использовать их напрямую?

Давайте объясним с некоторыми примерами. Представьте, что у нас есть класс, который ведет список стран. Мы могли бы сохранить список в виде массива:

' Использовать массив для хранения стран
Public arrCountries As Variant

' Установить размер массива при инициализации класса
Private Sub Class_Initialize()
    ReDim arrCountries(1 To 1000)
End Sub

Когда пользователь хочет получить количество стран в списке, он может сделать это:

' Код обычного модуля
Dim oCountry As New clsCountry

' Получить количество элементов
NumCountries = UBound(oCountry.arrCountries) + 1

С приведенным выше кодом есть две основные проблемы

1. Чтобы узнать количество стран, вам необходимо знать, как хранится список, например, Массив.
2. Если мы изменим массив на коллекцию, нам нужно будет изменить весь код, который напрямую ссылается на массив

Для решения этих проблем мы можем создать функцию, возвращающую количество стран:

' CLASS MODULE Код - clsCountryList
' Массив
Private arrCountries() As String

Public Function Count() As Long
    Count = UBound(arrCountries) + 1
End Function

Затем мы используем это так

' Код модуля
Dim oCountries As New clsCountries

Debug.Print "Количество стран " & oCountries.Count

Этот код решает две проблемы, которые мы перечислили выше. Мы можем изменить наш массив на коллекцию, и код вызывающего абонента все равно будет работать. Например:

' CLASS MODULE Код
' Коллекция
Private collCountries() As Collection

Public Function Count() As Long
    Count = collCountries.Count
End Function

Вызывающий не замечает, как хранятся страны. Все, что нужно знать вызывающему — это то, что функция Count будет возвращать количество стран.

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

Использование свойства вместо Function/Sub

Вместо создания функции Count мы можем создать свойство Count. Как вы можете видеть ниже, они очень похожи:

' Замени это 
Public Function Count() As Long
    Count = UBound(arrCountries) + 1
End Function

' На это
Property Get Count() As Long
    Count = UBound(arrCountries) + 1
End Function

В этом сценарии нет большой разницы между использованием свойства и использованием функции. Тем не менее, есть различия. Обычно мы создаем свойство Get и Let так:

' CLASS MODULE Код - clsAccount
Private dTotalCost As Double

Property Get TotalCost() As Long
     TotalCost= dTotalCost 
End Property

Property Let TotalCost(dValue As Long) 
     dTotalCost = dValue 
End Property

Использование Let позволяет нам рассматривать свойство, как переменную. Таким образом, мы можем сделать это:

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

oAccount.TotalCost = 6
dValue = oAccount.TotalCost 

Если мы использовали функцию и подпрограмму, то мы не можем получить поведение переменной. Вместо этого мы должны вызвать две разные процедуры, например:

oAccount.SetTotalCost 6
dValue = oAccount.GetTotalCost

Вы также можете видеть, что когда мы использовали Let, мы можем присвоить значение, как переменную. Когда мы используем SetTotalCost, мы должны были передать его в качестве параметра.

О Свойствах в двух словах

1. Свойство скрывает детали реализации от вызывающей стороны.
2. Свойство позволяет нам обеспечивать то же поведение, что и переменная.

Типы свойств VBA

Есть три типа свойств. Мы уже видели Get и Let. Но мы еще не рассмотрели Set.

Set похож на Let, но он используется для объекта (подробнее об этом см. Назначение объектов VBA).

Первоначально в Visual Basic ключевое слово Let использовалось для назначения переменной. На самом деле, мы можем использовать его, как захотим.

' Эти строки эквивалентны
Let a = 7
a = 7

Поэтому мы используем Let, чтобы присвоить значение переменной, и мы используем Set, чтобы назначить объект переменной объекта.

' Используем Let
Dim a As Long
Let a = 7

' Используем Set
Dim coll1 As Collection, coll2 As Collection
Set coll1 = New Collection
Set coll2 = coll1

• Let используется для присвоения значения базовому типу переменной.
• Set используется для назначения объекта переменной объекта

В следующем примере мы используем свойства Get и Let для строковой переменной

' CLASS MODULE Код

' Свойства SET/LET для переменной
Private m_sName As String

' свойства Get/Let
Property Get Name() As String
    Name = m_sName
End Property

Property Let Name(sName As String)
    m_sName = sName
End Property

Затем мы можем использовать свойства Name так:

Sub TestLetSet()

    Dim sName As String    
    Dim coll As New Collection
    Dim oCurrency As New clsCurrency
    
    ' Свойство Let 
    oCurrency.Name = "USD"
    
    ' Свойство Get 
    sName = oCurrency.Name

End Sub

В следующем примере мы используем свойства Get и Set для переменной объекта

' CLASS MODULE Код

Private m_collPrices As Collection

' Свойства Get/Set 
Property Get Prices() As Collection
    Set Prices = m_collPrices 
End Property

Property Set Prices(collPrices As Collection)
    Set m_collPrices = collPrices
End Property

Затем мы можем использовать свойства так:

Sub TestLetSet()
    
    Dim coll1 As New Collection
    Dim oCurrency As New clsCurrency
    
    ' Свойство Set 
    Set oCurrency.Prices = coll1

    ' Свойство Get 
    Dim coll2 As Collection 
    Set Coll2 = oCurrency.Prices
    
End Sub

Мы используем свойство Get, чтобы вернуть значения для обоих элементов. Обратите внимание, что даже если мы используем свойство Get для возврата коллекции, нам все равно нужно использовать ключевое слово Set для его назначения.

События Class Module

Class Module имеет два события:

1. Инициализировать — происходит при создании нового объекта класса.
2. Завершить — происходит, когда объект класса удален.

В объектно-ориентированных языках, таких как C ++, эти события называются Конструктором и Деструктором. В большинстве языков вы можете передавать параметры конструктору, но не в VBA. Мы можем использовать Class Factory, чтобы обойти эту проблему, как показано ниже.

Инициализация

Давайте создадим очень простой Class Module с именем clsSimple с событиями Initialize и Terminate.

' CLASS MODULE Код
Private Sub Class_Initialize()
    MsgBox "Класс инициализируется"
End Sub

Private Sub Class_Terminate()
    MsgBox "Класс прекращается"
End Sub

Public Sub PrintHello()
    Debug.Print "Привет"
End Sub

В следующем примере мы используем Dim и New для создания объекта.

В этом случае oSimple не создается, пока мы не ссылаемся на него в первый раз, например:

Sub ClassEventsInit2()

    Dim oSimple As New clsSimple
    
    ' Инициализация происходит здесь
    oSimple.PrintHello

End Sub

Когда мы используем Set и New вместе, поведение отличается. В этом случае объект создается при использовании Set, например:

Sub ClassEventsInit()

    Dim oSimple As clsSimple
    
    ' Инициализация происходит здесь
    Set oSimple = New clsSimple
    
    oSimple.PrintHello
   
End Sub

Примечание: Для получения дополнительной информации о различиях между использованием New с Dim и использованием New с Set см. Тонкие различия Dim и Set

Как я уже говорил ранее, вы не можете передать параметр в Initialize. Если вам нужно сделать это, вам нужна функция, чтобы сначала создать объект.

' CLASS MODULE - clsSimple
Public Sub Init(Price As Double) 

End Sub 

' обычный модуль
Public Sub Test()

    ' использование функции CreateSimpleObject 
    Dim oSimple As clsSimple
    Set oSimple = CreateSimpleObject(199.99)

End Sub

Public Function CreateSimpleObject(Price As Double) As clsSimple

    Dim oSimple As New clsSimple
    oSimple.Init Price

    Set CreateSimpleObject = oSimple

End Function 

Мы расширим CreateSimpleObject в Примере 2, чтобы создать фабрику классов.

Завершение

Событие Terminate наступает при удалении класса. Это происходит, когда мы устанавливаем значение Nothing.

Sub ClassEventsTerm()

    Dim oSimple As clsSimple
    Set oSimple = New clsSimple
    
    ' Завершение происходит здесь
    Set oSimple = Nothing
   
End Sub

Если мы не установим объект в Nothing, VBA автоматически удалит его, когда он выйдет из области видимости.

Это означает, что если мы создадим объект в процедуре, когда эта процедура завершится, VBA удалит все созданные объекты.

Sub ClassEventsTerm2()

    Dim oSimple As New clsSimple
    
    ' Инициализация происходит здесь
    oSimple.PrintHello

   ' oSimple удаляется, когда мы выходим из этого Sub-вызова Terminate
End Sub

Class Module. Пример 1

В этом примере мы рассмотрим очень распространенное использование Class Module.

Представьте, что у нас есть следующие данные:

Мы хотим читать альбомы по разным годам, а затем создавать различные отчеты.

Мы могли бы использовать для этого 2D-массив или коллекцию коллекций, например:

For i = 2 To rg.Rows.Count
    
    Year = rg.Cells(i, 3)
    If startYear <= Year And endYear >= Year Then
        
        ' Создать новую коллекцию для каждой строки
        Set rowColl = New Collect
 
        ' Добавить исполнителя 
        rowColl.Add rg.Cells(i, 1).Value
        ' Добавить заголовок
        rowColl.Add rg.Cells(i, 2).Value
        
        ' и так далее

        ' Добавить коллекцию строк в основную коллекцию
        coll.Add rowColl

    End If
    
Next i

Как вы можете себе представить, этот код очень быстро запутался.

К счастью для нас, у нас есть Class Module VBA, чтобы сделать нашу жизнь проще. Мы можем создать Class Module для хранения элементов.

' clsAlbum class module
Private m_sArtist As String
Private m_sTitle As String
Private m_sYear As String
Private m_sGenre As String
Private m_sSales As String

' Свойства
Public Property Get Artist() As String
    Artist = m_sArtist
End Property
Public Property Let Artist(ByVal sArtist As String)
    m_sArtist = sArtist
End Property

' и т.д.

Каждый раз, когда мы хотим добавить запись, мы можем сделать это следующим образом:

' Объявить переменную
Dim oAlbum As clsAlbum

' Создать новый альбом
Set oAlbum = New clsAlbum

' Добавить детали
oAlbum.Artist = rg.Cells(i, 1)
oAlbum.Title = rg.Cells(i, 2)
oAlbum.Year = rg.Cells(i, 3)
oAlbum.Genre = rg.Cells(i, 4)
oAlbum.Sales = rg.Cells(i, 5)

' Добавить объект альбома в коллекцию
coll.Add oAlbum

Как видите, это делает наш код более читабельным. Понятно, для чего используются Artist, Title и т.д.

Затем мы можем легко использовать эти данные для создания отчетов, записи в файлы и т.д.

Sub PrintAlbum(coll As Collection)
    
    Dim oAlbum As clsAlbum

    For Each oAlbum In coll
        ' Распечатайте название и исполнителя для каждого альбома
        Debug.Print oAlbum.Title, oAlbum.Artist
    Next
    
End Sub

Ниже приведен полный код для этого примера

Sub CreateReport()

    Dim coll As Collection
    ' читать данные
    Set coll = ReadAlbums(1990, 2001)
    
    ' Распечатать информацию об альбоме
    PrintAlbum coll

    ' Распечатать общий объем продаж
    PrintTotalSales coll
    
End Sub

Function ReadAlbums(startYear As Long, endYear As Long) _
              As Collection
    
    Dim rg As Range
    Set rg = Sheet1.Range("A1").CurrentRegion
    
    ' Создать коллекцию для хранения альбомов
    Dim coll As New Collection
    Dim oAlbum As clsAlbum
    
    Dim i As Long, Year As Long
    For i = 2 To rg.Rows.Count
        
        Year = rg.Cells(i, 3)
        If startYear <= Year And endYear >= Year Then
            ' Создать новый альбом
            Set oAlbum = New clsAlbum
            ' Добавить детали
            oAlbum.Artist = rg.Cells(i, 1)
            oAlbum.Title = rg.Cells(i, 2)
            oAlbum.Year = Year
            oAlbum.Genre = rg.Cells(i, 4)
            oAlbum.sales = rg.Cells(i, 5)
            ' Добавить объект альбома в коллекцию
            coll.Add oAlbum
        End If
        
    Next i
    
    Set ReadAlbums = coll
    
End Function

Sub PrintAlbum(coll As Collection)
    
    Dim oAlbum As clsAlbum
    For Each oAlbum In coll
        Debug.Print oAlbum.Title, oAlbum.Artist
    Next
    
End Sub

Sub PrintTotalSales(coll As Collection)
    
    Dim oAlbum As clsAlbum, sales As Double
    For Each oAlbum In coll
        sales = sales + oAlbum.sales
    Next
    
    Debug.Print "Общее количество продаж составляет " & sales
    
End Sub

Class Module. Пример 2

В этом примере мы пойдем дальше. Мы собираемся взглянуть на некоторые хитрые приемы при использовании объектов.

Представьте, что у вас есть список продуктов, как на картинке ниже.

Продукты имеют разные поля, поэтому нам нужно использовать разные модули классов для каждого типа продуктов. Один тип для строки Книги, один тип для строки Фильмы.

Сначала мы создадим наши модули классов. Они очень похожи для обоих типов продуктов.

' CLASS MODULE - clsBook
' Переменные
Private m_Title As String
Private m_Year As Long

' Свойства
Property Get ItemType() As String
    ItemType = "Book"
End Property
Property Get Title() As String
    Title = m_Title
End Property
Property Get Year() As Long
    Year = m_Year
End Property

' Методы
Public Sub Init(rg As Range)
    m_Title = rg.Cells(1, 2)
    m_Year = CLng(rg.Cells(1, 4))
End Sub

Public Sub PrintToImmediate()
    Debug.Print ItemType, m_Title, m_Year
End Sub

' CLASS MODULE - clsFilm
' Переменные
Private m_Title As String
Private m_Year As Long

' Свойства
Property Get ItemType() As String
    ItemType = "Film"
End Property
Property Get Title() As String
    Title = m_Title
End Property
Property Get Year() As Long
    Year = m_Year
End Property

' Методы
Sub Init(rg As Range)
    m_Title = rg.Cells(1, 2)
    m_Year = CLng(rg.Cells(1, 5))
End Sub

Public Sub PrintToImmediate()
    Debug.Print ItemType, m_Title, m_Year
End Sub

Как видите, единственная реальная разница — это инициализация.

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

' Для каждого типа требуется одна переменная
Dim oBook As clsBook
Dim oFilm As clsFilm

' Если Книга сделать это
Set oBook = New clsBook

' Если фильм сделать это
Set oFilm = New clsFilm

Если бы у нас было много разных типов, это было бы действительно очень грязно. Хорошей новостью является то, что нам нужно использовать только одну переменную!

В VBA мы можем объявить переменную как вариант. Когда мы используем Variant, мы, по сути, говорим: «Мы определим тип переменной во время выполнения кода».

Это очень полезно при работе с объектами и позволяет нам избежать использования одной переменной, например:

' Требуется только одна переменная
Dim oItem As Variant

' Если книга, указать тип clsBook
Set oItem = New clsBook

' Если фильм, указать тип clsFilm
Set oItem = New clsFilm

Это действительно полезно, так как нам нужна только одна переменная, независимо от того, сколько у нас объектов.

Второе преимущество использования Variant заключается в следующем. Если у каждого Class Module есть подпрограмма / функция с одинаковым именем и параметрами, мы можем использовать одну и ту же переменную для ее вызова.

Представьте, что в clsBook есть функция InitBook, а в clsFilm есть функция InitFilm. Нам нужно сделать это:

' Если clsBook
If Type = "Book" Then
    oItem.InitBook
ElseIf Type = "Film" Then
    oItem.InitFilm

Однако, если они имеют одинаковое имя, например, Init, мы можем заменить строки кода If ElseIf одной строкой:

  ' это вызовет подпрограмму Init любого типа oItem, установленного в
    oItem.Init

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

Ранее мы видели, что событие Initialize не принимает параметры. Мы можем позвонить в Init на фабрике классов, чтобы обойти эту проблему.

Полный код для функции ClassFactory здесь:

Function ClassFactory(rg As Range) As Variant

    ' Получить тип продукта
    Dim sType As String
    sType = rg.Cells(1, 1)

    ' Создать объект на основе типа
    Dim oItem As Variant
    Select Case sType
    
        Case "Book":
            Set oItem = New clsBook
        Case "Film":
            Set oItem = New clsFilm
        Case Else
            MsgBox "Invalid type"
    
    End Select
    
    ' Разобрать поля на правильные переменные класса
    oItem.Init rg
    
    ' Вернуть объект продукта
    Set ClassFactory = oItem
        
End Function

Это следующее наше начало. В этом разделе мы читаем таблицу и передаем диапазон в ClassFactory.

Создает объект, передает диапазон в метод Parse объекта. Затем он возвращает объект, который мы добавляем в нашу коллекцию.

Sub ReadProducts()
    
    ' Создать коллекцию
    Dim coll As New Collection
    Dim product As Variant
    
    Dim rg As Range


    ' Читайте продукты с листа
    Dim i As Long
    For i = 1 To 2
        Set rg = Sheet1.Range("A" & i & ":E" & i)
        Set product = ClassFactory(rg)
        coll.Add product
    Next

    ' Распечатать информацию о продукте в Immediate Window(Ctrl + G)
    PrintCollection coll

End Sub

Мы также можем использовать вариант объекта для печати элементов. Пока оба объекта имеют подпрограмму с одинаковым именем и параметрами (например, PrintToImmediate), мы можем вызывать ее, используя тип Variant.

Public Sub PrintCollection(ByRef coll As Collection)
    
    Dim v As Variant
    For Each v In coll
        ' Печать элементов
        v.PrintToImmediate
    Next
    
End Sub

Заключение

На этом я заканчиваю свою статью о Class Module VBA. В этой статье мы рассмотрели части Class Module VBA и два примера, в которых вы могли бы их использовать.

Важно понимать, что классы и объекты — это обширная тема. Существует множество типов объектов, которые вы можете создавать, и способы их использования.

Если вы планируете использовать Class Module, то я советую начать с основ и ознакомиться с тем, как создать простой. Как только вы освоите основы, вам будет намного легче переходить к более сложным сценариям.

Время на прочтение
13 мин

Количество просмотров 50K

Решил написать статью, о том, как сделать выгрузку данных в Excel файл по шаблону и считывать данные из Excel.
Началось всё с того, что на работе, дали указание, уйти от MS Office, на бесплатные аналоги.
У нас уже была система выгрузки, основанная на библиотеке “Microsoft.Office. Interop.Excel” и много готовых шаблонов, для выгрузки тех или иных отчётов.
Поэтому надо было найти бесплатную библиотеку, работающую с офисом. И сделать так, чтоб выгрузка работала по той же системе, что и раньше. Ибо переделывать все шаблоны и структуру, не хотелось.
Вот я и наткнулся на OpenXML. И думал, сейчас по быстрому найду решение в интернете и всё готово (т.к. на это было выделено мало времени). Но подходящего решения так и не нашёл, поэтому и решил написать эту статью, для тех у кого будет, такая же проблема.
Саму библиотеку, можно скачать бесплатно с сайта Micrisoft (я использовал в проекте OpenXML sdk 2.5 “ OpenXMLSDKV25.msi ”)
здесь.
После скачивания “OpenXMLSDKV25.msi ”, устанавливаем и заходим в папку
“C:Program FilesOpen XML SDKV2.5lib” там лежит библиотека, которая нам понадобится, мы её подключим к проекту (ниже будет описано, как).
Проект был написан на Visual Studio 2010 (Framework 4.0).
Ниже пример шаблона (сделан для теста) “C:Templatestemplate.xlsx”.

И пример выгруженных данных (как это будет выглядеть в итоге, после выгрузки).

Ключевые слова:
DataField: — Означает, что на этом месте будут выведены наши банные из DataTable.
DataField:[название выводимого поля]
Label: — Означает, что на этом месте будут выводиться данные, которые надо вставить однократно из словаря
Label:[название ключа в словаре]
А это файл из которого мы будем считывать данные “C:LoadingReadMePlease.xlsx”.

Теперь создадим в VS2010, Решение в котором будет 4 проекта:
1) OpenXmlPrj – это консольный проект, для запуска теста.
2) Interfaces – это проект типа “Библиотека классов”, будет хранить наши интерфейсы данных для выгрузки.
3) Framework — это проект типа “Библиотека классов”, тут и будет происходить вся работа с Excel-ем.
4) Converter — это проект типа “Библиотека классов”, для конвертирования наших данных в DataTable (т.к. работа происходит с DataTable).

Теперь в проекте “Framework” создаём две папки и подключим ссылку на библиотеку OpenXML и WindowsBase:
“Create” – для работы с выгрузкой данных.
“Load” – для работы с загрузкой данных.
“lib” – в папку, добавим библиотеку OpenXML.
В папке “Create” создаём 4 класса.
1) Worker – это будет наш главный обработчик.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;

namespace Framework.Create
{
    /// <summary>
    /// Создание Excel файла
    /// </summary>
    public class Worker
    {
        /// <summary>
        /// путь к папке с шаблонами 
        /// </summary>
        private const String TemplateFolder = "C:\Templates\";

        /// <summary>
        /// имя листа шаблона (с которым мы будем работать) 
        /// </summary>
        private const String SheetName = "Лист1";

        /// <summary>
        /// тип документа
        /// </summary>
        private const String FileType = ".xlsx";

        /// <summary>
        /// Папка, для хранения выгруженных файлов
        /// </summary>
        public static String Directory
        {
            get
            {
                const string excelFilesPath = @"C:xlsx_repository";
                if (System.IO.Directory.Exists(excelFilesPath) == false)
                {
                    System.IO.Directory.CreateDirectory(excelFilesPath);
                }

                return excelFilesPath;
            }
        }

        public void Export(System.Data.DataTable dataTable, System.Collections.Hashtable hashtable, String templateName)
        {
            var filePath = CreateFile(templateName);

            OpenForRewriteFile(filePath, dataTable, hashtable);

            OpenFile(filePath);
        }

        private String CreateFile(String templateName)
        {
            var templateFelePath = String.Format("{0}{1}{2}", TemplateFolder, templateName, FileType);
            var templateFolderPath = String.Format("{0}{1}", Directory, templateName);
            if (!File.Exists(String.Format("{0}{1}{2}", TemplateFolder, templateName, FileType)))
            {
                throw new Exception(String.Format("Не удалось найти шаблон документа n"{0}{1}{2}"!", TemplateFolder, templateName, FileType));
            }

            //Если в пути шаблона (в templateName) присутствуют папки, то при выгрузке, тоже создаём папки
            var index = (templateFolderPath).LastIndexOf("\", System.StringComparison.Ordinal);
            if (index > 0)
            {
                var directoryTest = (templateFolderPath).Remove(index, (templateFolderPath).Length - index);
                if (System.IO.Directory.Exists(directoryTest) == false)
                {
                    System.IO.Directory.CreateDirectory(directoryTest);
                }
            }

            var newFilePath = String.Format("{0}_{1}{2}", templateFolderPath, Regex.Replace((DateTime.Now.ToString(CultureInfo.InvariantCulture)), @"[^a-z0-9]+", ""), FileType);
            File.Copy(templateFelePath, newFilePath, true);
            return newFilePath;
        }

        private void OpenForRewriteFile(String filePath, System.Data.DataTable dataTable, System.Collections.Hashtable hashtable)
        {
            Row rowTemplate = null;
            var footer = new List<Footer>();
            var firsIndexFlag = false;
            using (var document = SpreadsheetDocument.Open(filePath, true))
            {
                Sheet sheet;
                try
                {
                    sheet = document.WorkbookPart.Workbook.GetFirstChild<Sheets>().Elements<Sheet>().SingleOrDefault(s => s.Name == SheetName);
                }
                catch (Exception ex)
                {
                    throw new Exception(String.Format("Возможно в документе существует два листа с названием "{0}"!n",SheetName), ex);
                }

                if (sheet == null)
                {
                    throw new Exception(String.Format("В шаблоне не найден "{0}"!n",SheetName));
                }

                var worksheetPart = (WorksheetPart)document.WorkbookPart.GetPartById(sheet.Id.Value);
                var sheetData = worksheetPart.Worksheet.GetFirstChild<SheetData>();

                var rowsForRemove = new List<Row>();
                var fields = new List<Field>();
                foreach (var row in worksheetPart.Worksheet.GetFirstChild<SheetData>().Elements<Row>())
                {
                    var celsForRemove = new List<Cell>();
                    foreach (var cell in row.Descendants<Cell>())
                    {
                        if (cell == null)
                        {
                            continue;
                        }

                        var value = GetCellValue(cell, document.WorkbookPart);
                        if (value.IndexOf("DataField:", StringComparison.Ordinal) != -1)
                        {
                            if (!firsIndexFlag)
                            {
                                firsIndexFlag = true;
                                rowTemplate = row;
                            }
                            fields.Add(new Field(Convert.ToUInt32(Regex.Replace(cell.CellReference.Value, @"[^d]+", ""))
                                , new string(cell.CellReference.Value.ToCharArray().Where(p => !char.IsDigit(p)).ToArray())
                                , value.Replace("DataField:", "")));

                        }

                        if (value.IndexOf("Label:", StringComparison.Ordinal) != -1 && rowTemplate == null)
                        {
                            var labelName = value.Replace("Label:", "").Trim();
                            if (!hashtable.ContainsKey(labelName))
                            {
                                throw new Exception(String.Format("Нет такого лэйбла "{0}"", labelName));
                            }
                            cell.CellValue = new CellValue(hashtable[labelName].ToString());
                            cell.DataType = new EnumValue<CellValues>(CellValues.String);

                        }

                        if (rowTemplate == null || row.RowIndex <= rowTemplate.RowIndex || String.IsNullOrWhiteSpace(value))
                        {
                            continue;
                        }
                        var item = footer.SingleOrDefault(p => p._Row.RowIndex == row.RowIndex);
                        if (item == null)
                        {
                            footer.Add(new Footer(row, cell, value.IndexOf("Label:", StringComparison.Ordinal) != -1 ? hashtable[value.Replace("Label:", "").Trim()].ToString() : value));
                        }
                        else
                        {
                            item.AddMoreCell(cell, value.IndexOf("Label:", StringComparison.Ordinal) != -1 ? hashtable[value.Replace("Label:", "").Trim()].ToString() : value);
                        }
                        celsForRemove.Add(cell);
                    }

                    foreach (var cell in celsForRemove)
                    {
                        cell.Remove();
                    }

                    if (rowTemplate != null && row.RowIndex != rowTemplate.RowIndex)
                    {
                        rowsForRemove.Add(row);
                    }
                }

                if (rowTemplate == null || rowTemplate.RowIndex == null || rowTemplate.RowIndex < 0)
                {
                    throw new Exception("Не удалось найти ни одного поля, для заполнения!");
                }

                foreach (var row in rowsForRemove)
                {
                    row.Remove();
                }

                var index = rowTemplate.RowIndex;
                foreach (var row in from System.Data.DataRow item in dataTable.Rows select CreateRow(rowTemplate, index, item, fields))
                {
                    sheetData.InsertBefore(row, rowTemplate);
                    index++;
                }

                foreach (var newRow in footer.Select(item => CreateLabel(item, (UInt32)dataTable.Rows.Count)))
                {
                    sheetData.InsertBefore(newRow, rowTemplate);
                }

                rowTemplate.Remove();
            }
        }

        private Row CreateLabel(Footer item, uint count)
        {
            var row = item._Row;
            row.RowIndex = new UInt32Value(item._Row.RowIndex + (count - 1));
            foreach (var cell in item.Cells)
            {
                cell._Cell.CellReference = new StringValue(cell._Cell.CellReference.Value.Replace(Regex.Replace(cell._Cell.CellReference.Value, @"[^d]+", ""), row.RowIndex.ToString()));
                cell._Cell.CellValue = new CellValue(cell.Value);
                cell._Cell.DataType = new EnumValue<CellValues>(CellValues.String);
                row.Append(cell._Cell);
            }
            return row;
        }

        private Row CreateRow(Row rowTemplate, uint index, System.Data.DataRow item, List<Field> fields)
        {
            var newRow = (Row)rowTemplate.Clone();
            newRow.RowIndex = new UInt32Value(index);

            foreach (var cell in newRow.Elements<Cell>())
            {
                cell.CellReference = new StringValue(cell.CellReference.Value.Replace(Regex.Replace(cell.CellReference.Value, @"[^d]+", ""), index.ToString(CultureInfo.InvariantCulture)));
                foreach (var fil in fields.Where(fil => cell.CellReference == fil.Column + index))
                {
                    cell.CellValue = new CellValue(item[fil._Field].ToString());
                    cell.DataType = new EnumValue<CellValues>(CellValues.String);
                }
            }
            return newRow;
        }


        private string GetCellValue(Cell cell, WorkbookPart wbPart)
        {
            var value = cell.InnerText;

            if (cell.DataType == null)
            {
                return value;
            }
            switch (cell.DataType.Value)
            {
                case CellValues.SharedString:

                    var stringTable = wbPart.GetPartsOfType<SharedStringTablePart>().FirstOrDefault();

                    if (stringTable != null)
                    {
                        value = stringTable.SharedStringTable.ElementAt(int.Parse(value)).InnerText;
                    }
                    break;
            }

            return value;
        }

        private void OpenFile(string filePath)
        {
            if (!File.Exists(filePath))
            {
                throw new Exception(String.Format("Не удалось найти файл "{0}"!", filePath));
            }

            var process = Process.Start(filePath);
            if (process != null)
            {
                process.WaitForExit();
            }
        }
    }
}

2) Footer – будет содержать строки и их ячейки идущие после наших данных.

using System;
using System.Collections.Generic;
using DocumentFormat.OpenXml.Spreadsheet;
namespace Framework.Create
{
    public class Footer
    {
        /// <summary>
        /// строка
        /// </summary>
        public Row _Row { get; private set; }
        /// <summary>
        /// ячейки данной строки
        /// </summary>
        public List<CellForFooter> Cells { get; private set; }

        public Footer(Row row, Cell cell, String cellValue)
        {
            _Row = new Row((Row)row.Clone()) { RowIndex = row.RowIndex };
            var _Cell = (Cell)cell.Clone();
            _Cell.CellReference = cell.CellReference;
            Cells = new List<CellForFooter> { new CellForFooter(_Cell, cellValue) };
        }

        public void AddMoreCell(Cell cell, String cellValue)
        {
            var _Cell = (Cell)cell.Clone();
            _Cell.CellReference = cell.CellReference;
            Cells.Add(new CellForFooter(_Cell, cellValue));
        }
    }
}

3) CellForFooter – содержит в себе координаты ячейки и её значение, используется в Footer-е.

using System;
using DocumentFormat.OpenXml.Spreadsheet;
namespace Framework.Create
{
    public class CellForFooter
    {
        /// <summary>
        /// ячейка
        /// </summary>
        public Cell _Cell { get; private set; }
        /// <summary>
        /// значение
        /// </summary>
        public String Value { get; private set; }

        public CellForFooter(Cell cell, String value)
        {
            _Cell = cell;
            Value = value;
        }
    }
}

4) Field – будет содержать индекс строки, где находится DataField, координаты ячеек с DataField и название поля, значение которого надо вывести.

using System;
namespace Framework.Create
{
    public class Field
    {
        /// <summary>
        /// Индекс строки
        /// </summary>
        public uint Row { get; private set; }
        /// <summary>
        /// координаты колонки
        /// </summary>
        public String Column { get; private set; }
        /// <summary>
        /// название колонки, выводимых данных
        /// </summary>
        public String _Field { get; private set; }

        public Field(uint row, String column, String field)
        {
            Row = row;
            Column = column;
            _Field = field;
        }
    }
}

В папке “Load” создаём 2 класса.
1) Worker – это будет наш главный обработчик.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;
namespace Framework.Load
{
    /// <summary>
    /// Загрузка данных из Excel
    /// </summary>
    public class Worker
    {
        /// <summary>
        /// имя листа (откуда будем читать данные) 
        /// </summary>
        private const String SheetName = "Лист1";

        /// <summary>
        /// Подавать только файлы в формате .xlsx
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public System.Data.DataTable ReadFile(String path)
        {
            CheckFile(path);
            return OpenDocumentForRead(path);
        }

        private System.Data.DataTable OpenDocumentForRead(string path)
        {
            System.Data.DataTable data = null;
            using (var document = SpreadsheetDocument.Open(path, false))
            {
                Sheet sheet;
                try
                {
                    sheet = document.WorkbookPart.Workbook.GetFirstChild<Sheets>().Elements<Sheet>().SingleOrDefault(s => s.Name == SheetName);
                }
                catch (Exception ex)
                {
                    throw new Exception(String.Format("Возможно в документе существует два листа с названием "{0}"!n", SheetName), ex);
                }

                if (sheet == null)
                {
                    throw new Exception(String.Format("В файле не найден "{0}"!n", SheetName));
                }

                var relationshipId = sheet.Id.Value;
                var worksheetPart = (WorksheetPart)document.WorkbookPart.GetPartById(relationshipId);
                var sheetData = worksheetPart.Worksheet.GetFirstChild<SheetData>();

                var firstRow = true;
                var columsNames = new List<ColumnName>();
                foreach (Row row in sheetData.Elements<Row>())
                {
                    if (firstRow)
                    {
                        columsNames.AddRange(GetNames(row, document.WorkbookPart));
                        data = GetTable(columsNames);
                        firstRow = false;
                        continue;
                    }

                    var item = data.NewRow();
                    foreach (var line in columsNames)
                    {
                        var coordinates = String.Format("{0}{1}", line.Liter, row.RowIndex);
                        var cc = row.Elements<Cell>().SingleOrDefault(p => p.CellReference == coordinates);
                        if (cc == null)
                        {
                            throw new Exception(String.Format("Не удалось найти ячейку "{0}"!", coordinates));
                        }
                        item[line.Name.Trim()] = GetVal(cc, document.WorkbookPart);

                    }
                    data.Rows.Add(item);
                }
            }

            return data;
        }

        private System.Data.DataTable GetTable(IEnumerable<ColumnName> columsNames)
        {
            var teb = new System.Data.DataTable("ExelTable");

            foreach (var col in columsNames.Select(columnName => new System.Data.DataColumn { DataType = typeof(String), ColumnName = columnName.Name.Trim() }))
            {
                teb.Columns.Add(col);
            }

            return teb;
        }

        private IEnumerable<ColumnName> GetNames(Row row, WorkbookPart wbPart)
        {
            return (from cell in row.Elements<Cell>()
                    where cell != null
                    let
                        text = GetVal(cell, wbPart)
                    where !String.IsNullOrWhiteSpace(text)
                    select
                    new ColumnName(text, Regex.Replace(cell.CellReference.Value, @"[-9]", ""))).ToList();
        }

        private string GetVal(Cell cell, WorkbookPart wbPart)
        {
            string value = cell.InnerText;

            if (cell.DataType == null)
            {
                return value;
            }
            switch (cell.DataType.Value)
            {
                case CellValues.SharedString:

                    var stringTable =
                        wbPart.GetPartsOfType<SharedStringTablePart>()
                            .FirstOrDefault();

                    if (stringTable != null)
                    {
                        value =
                            stringTable.SharedStringTable
                                .ElementAt(int.Parse(value)).InnerText;
                    }
                    break;
            }

            return value;
        }

        private void CheckFile(String path)
        {
            if (String.IsNullOrWhiteSpace(path) || !File.Exists(path))
            {
                throw new Exception(String.Format("Такого файла "{0}", не существует!", path));
            }
        }
    }
}

2) ColumnName – будет название колонки, для загружаемых данных.

using System;
namespace Framework.Load
{
    public class ColumnName
    {
        /// <summary>
        /// название колонки, для загружаемых данных
        /// </summary>
        public String Name { get; private set; }
        /// <summary>
        /// буква колонки
        /// </summary>
        public String Liter { get; private set; }

        public ColumnName(string name, string liter)
        {
            Name = name;
            Liter = liter;
        }
    }
}

В проекте “Interfaces” создадим интерфейс наших данных IDataForTest.

using System;
namespace Interfaces
{
    public interface IDataForTest
    {
        String A { get; }
        String B { get; }
        String C { get; }
    }
}

В проекте “Converter” создадим класс
ConvertToDataTable – для конвертирования наших данных в DataTable.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using Interfaces;
namespace Converter
{
    public class ConvertToDataTable
    {
        public DataTable ExcelTableLines(IEnumerable<IDataForTest> lines)
        {
            var dt = CreateTable();
            foreach (var line in lines)
            {
                var row = dt.NewRow();
                row["AAA"] = line.A;
                row["BBB"] = line.B;
                row["CCC"] = line.C;
                dt.Rows.Add(row);
            }
            return dt;
        }

        public Hashtable ExcelTableHeader(Int32 count)
        {
            var head = new Dictionary<String, String> { { "Date", DateTime.Today.Date.ToShortDateString() }, { "Count", count.ToString() } };
            return new Hashtable(head);
        }

        private DataTable CreateTable()
        {
            var dt = new DataTable("ExelTable");
            var col = new DataColumn { DataType = typeof(String), ColumnName = "AAA" };
            dt.Columns.Add(col);
            col = new DataColumn { DataType = typeof(String), ColumnName = "BBB" };
            dt.Columns.Add(col);
            col = new DataColumn { DataType = typeof(String), ColumnName = "CCC" };
            dt.Columns.Add(col);
            return dt;
        }
    }
}

В проекте “OpenXmlPrj”
Будет класс для выполнения программы “Program”.

using System;
using System.Collections.Generic;
using System.Data;
namespace OpenXmlPrj
{
    class Program
    {
        static void Main(string[] args)
        {
            //заполняем тестовыми данными
            var myData = new List<DataForTest>
            {
                new DataForTest("a1","b1","c1"),
                new DataForTest("a2","b2","c2"),
                new DataForTest("a3","b3","c3"),
                new DataForTest("a4","b4","c4"),
                new DataForTest("a5","b5","c5")
            };

            var ex = new Converter.ConvertToDataTable();
            //ex.ExcelTableLines(myData) - конвертируем наши данные в DataTable
            //ex.ExcelTableHeader(myData.Count) - формируем данные для Label
            //template - указываем название нашего файла  - шаблона
            new Framework.Create.Worker().Export(ex.ExcelTableLines(myData), ex.ExcelTableHeader(myData.Count), "template");

            Console.WriteLine("Excel File Has Created!nFor Read Data From Excel, press any key!");
            Console.ReadKey();
            //"C:\Loading\ReadMePlease.xlsx" - путь к файлу, с которого будем считывать данные (возвращяет нам DataTable)
            var dt = new Framework.Load.Worker().ReadFile("C:\Loading\ReadMePlease.xlsx");
            var myDataFromExcel = new List<DataForTest>();
            //Заполняем наш объект, считанными данными из DataTable
            foreach (DataRow item in dt.Rows)
            {
                myDataFromExcel.Add(new DataForTest(item));
            }

            Console.WriteLine("---------- Data ---------------------");
            //Выводим считанные данные
            foreach (var line in myDataFromExcel)
            {
                Console.WriteLine("{0} | {1} | {2}", line.A, line.B, line.C);
            }

            Console.WriteLine("Done. Press any key, for exit!");
            Console.ReadKey();
        }
    }
}

И класс для наших данных “DataForTest”.

using System;
using System.Data;
using Interfaces;
namespace OpenXmlPrj
{
    public class DataForTest : IDataForTest
    {
        public String A { get; private set; }
        public String B { get; private set; }
        public String C { get; private set; }

        public DataForTest(String a, String b, String c)
        {
            A = a;
            B = b;
            C = c;
        }

        public DataForTest(DataRow item)
        {
            A = item["MyFieldA"].ToString();
            B = item["MyFieldB"].ToString();
            C = item["MyFieldC"].ToString();
        }
    }
}

И проекте “OpenXmlPrj” надо подключить ссылки на следующие проекты: Interfaces, Framework, Converter
Условия для создания шаблона:
1. Excel лист, обязательно должен называться “Лист1” (ну или если захотите переименовать, то в коде надо будет изменить название тоже).
2. Названия после DataField: должны строго совпадать с названиями колонок в DataTable.
3. Шаблон должен быть сохранён в формате “.xlsx”.
Условия для файла, с которого мы будем считывать данные:
1. Excel лист, обязательно должен называться “Лист1” (ну или если захотите переименовать, то в коде надо будет изменить название тоже).
2. Первая строка, должна содержать названия колонок, по которым мы потом будем парсить данные.

Ссылка на исходник, в GitHub-е.

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

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

Создание раскрывающегося списка

Путь: меню «Данные» — инструмент «Проверка данных» — вкладка «Параметры». Тип данных – «Список».

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

1. Вручную через «точку-с-запятой» в поле «Источник».



2. Ввести значения заранее. А в качестве источника указать диапазон ячеек со списком.



3. Назначить имя для диапазона значений и в поле источник вписать это имя.

Любой из вариантов даст такой результат.



Выпадающий список в Excel с подстановкой данных

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

1. Выделяем диапазон для выпадающего списка. В главном меню находим инструмент «Форматировать как таблицу».



2. Откроются стили. Выбираем любой. Для решения нашей задачи дизайн не имеет значения. Наличие заголовка (шапки) важно. В нашем примере это ячейка А1 со словом «Деревья». То есть нужно выбрать стиль таблицы со строкой заголовка. Получаем следующий вид диапазона:



3. Ставим курсор в ячейку, где будет находиться выпадающий список. Открываем параметры инструмента «Проверка данных» (выше описан путь). В поле «Источник» прописываем такую функцию:

Протестируем. Вот наша таблица со списком на одном листе:

Добавим в таблицу новое значение «елка».

Теперь удалим значение «береза».

Осуществить задуманное нам помогла «умная таблица», которая легка «расширяется», меняется.

Теперь сделаем так, чтобы можно было вводить новые значения прямо в ячейку с этим списком. И данные автоматически добавлялись в диапазон.

1. Сформируем именованный диапазон. Путь: «Формулы» — «Диспетчер имен» — «Создать». Вводим уникальное название диапазона – ОК.



2. Создаем раскрывающийся список в любой ячейке. Как это сделать, уже известно. Источник – имя диапазона: =деревья.
3. Снимаем галочки на вкладках «Сообщение для ввода», «Сообщение об ошибке». Если этого не сделать, Excel не позволит нам вводить новые значения.



4. Вызываем редактор Visual Basic. Для этого щелкаем правой кнопкой мыши по названию листа и переходим по вкладке «Исходный текст». Либо одновременно нажимаем клавиши Alt + F11. Копируем код (только вставьте свои параметры).

Private Sub Worksheet_Change(ByVal Target As Range)
 
Dim lReply As Long
 
    If Target.Cells.Count > 1 Then Exit Sub
    If Target.Address = "$C$2" Then
     If IsEmpty(Target) Then Exit Sub
       If WorksheetFunction.CountIf(Range("Деревья"), Target) = 0 Then
          lReply = MsgBox("Добавить введенное имя " & _
                         Target & " в выпадающий список?", vbYesNo + vbQuestion)
          If lReply = vbYes Then
              Range("Деревья").Cells(Range("Деревья").Rows.Count + 1, 1) = Target
          End If
       End If
     End If
End Sub
 

5. Сохраняем, установив тип файла «с поддержкой макросов».



6. Переходим на лист со списком. Вкладка «Разработчик» — «Код» — «Макросы». Сочетание клавиш для быстрого вызова – Alt + F8. Выбираем нужное имя. Нажимаем «Выполнить».

Когда мы введем в пустую ячейку выпадающего списка новое наименование, появится сообщение: «Добавить введенное имя баобаб в выпадающий список?».

Нажмем «Да» и добавиться еще одна строка со значением «баобаб».

Выпадающий список в Excel с данными с другого листа/файла

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

1. Делаем активной ячейку, куда хотим поместить раскрывающийся список.
2. Открываем параметры проверки данных. В поле «Источник» вводим формулу: =ДВССЫЛ(“[Список1.xlsx]Лист1!$A$1:$A$9”).

Имя файла, из которого берется информация для списка, заключено в квадратные скобки. Этот файл должен быть открыт. Если книга с нужными значениями находится в другой папке, нужно указывать путь полностью.

Как сделать зависимые выпадающие списки

Возьмем три именованных диапазона:

Это обязательное условие. Выше описано, как сделать обычный список именованным диапазоном (с помощью «Диспетчера имен»). Помним, что имя не может содержать пробелов и знаков препинания.

1. Создадим первый выпадающий список, куда войдут названия диапазонов.



2. Когда поставили курсор в поле «Источник», переходим на лист и выделяем попеременно нужные ячейки.



3. Теперь создадим второй раскрывающийся список. В нем должны отражаться те слова, которые соответствуют выбранному в первом списке названию. Если «Деревья», то «граб», «дуб» и т.д. Вводим в поле «Источник» функцию вида =ДВССЫЛ(E3). E3 – ячейка с именем первого диапазона.



Выбор нескольких значений из выпадающего списка Excel

Бывает, когда из раскрывающегося списка необходимо выбрать сразу несколько элементов. Рассмотрим пути реализации задачи.

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

Private Sub Worksheet_Change(ByVal Target As Range)
    On Error Resume Next
    If Not Intersect(Target, Range("Е2:Е9")) Is Nothing And Target.Cells.Count = 1 Then
        Application.EnableEvents = False
        If Len(Target.Offset(0, 1)) = 0 Then
            Target.Offset(0, 1) = Target
        Else
            Target.End(xlToRight).Offset(0, 1) = Target
        End If
        Target.ClearContents
        Application.EnableEvents = True
    End If
End Sub
 

2. Чтобы выбранные значения показывались снизу, вставляем другой код обработчика.

Private Sub Worksheet_Change(ByVal Target As Range)
    On Error Resume Next
    If Not Intersect(Target, Range("Н2:К2")) Is Nothing And Target.Cells.Count = 1 Then
        Application.EnableEvents = False
        If Len(Target.Offset(1, 0)) = 0 Then
            Target.Offset(1, 0) = Target
        Else
            Target.End(xlDown).Offset(1, 0) = Target
        End If
        Target.ClearContents
        Application.EnableEvents = True
    End If
End Sub
 

3. Чтобы выбираемые значения отображались в одной ячейке, разделенные любым знаком препинания, применим такой модуль.


Private Sub Worksheet_Change(ByVal Target As Range)
    On Error Resume Next
    If Not Intersect(Target, Range("C2:C5")) Is Nothing And Target.Cells.Count = 1 Then
        Application.EnableEvents = False
        newVal = Target
        Application.Undo
        oldval = Target
        If Len(oldval) <> 0 And oldval <> newVal Then
            Target = Target & "," & newVal
        Else
            Target = newVal
        End If
        If Len(newVal) = 0 Then Target.ClearContents
        Application.EnableEvents = True
    End If
End Sub


Не забываем менять диапазоны на «свои». Списки создаем классическим способом. А всю остальную работу будут делать макросы.

Выпадающий список с поиском

1. На вкладке «Разработчик» находим инструмент «Вставить» – «ActiveX». Здесь нам нужна кнопка «Поле со списком» (ориентируемся на всплывающие подсказки).



2. Щелкаем по значку – становится активным «Режим конструктора». Рисуем курсором (он становится «крестиком») небольшой прямоугольник – место будущего списка.



3. Жмем «Свойства» – открывается перечень настроек.



4. Вписываем диапазон в строку ListFillRange (руками). Ячейку, куда будет выводиться выбранное значение – в строку LinkedCell. Для изменения шрифта и размера – Font.

Скачать пример выпадающего списка

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

Как в эксель добавить файл эксель

Как вставить файл в книгу Excel?

Узнаем как внедрять любые типы документов в файл Excel для возможности открытия документов непосредственно из книги.

Приветствую всех, дорогие читатели блога TutorExcel.Ru.

Для тех кто больше предпочитает формат видео — приятного просмотра, для любителей же текста приятного чтения.

Давайте для начала подумаем для чего вообще это может полезно?

Помимо работы с данными внутри книги Excel иногда бывает необходимо к документу приложить какие-либо внешние данные в виде дополнительного файла. Так как вместо отдельного хранения файлов зачастую удобней внедрить их все в документ.

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

Как внедрить документ в Excel?

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

Далее щелкаем мышкой по кнопке Объект и перед нами появляется всплывающее окно с настройками вставки:

Excel предлагает нам 2 основные опции для внедрения файлов в книгу:

• Добавить новый объект (вкладка Новый);
• Добавить существующий файл (вкладка Из файла).

А также возможность отображения файла в виде значка и создания связи с файлом. Давайте поподробнее остановимся на каждом из имеющихся вариантов.

Создание нового документа

Остаемся в текущей вкладке Новый и в зависимости от наших задач в поле Тип объекта выбираем подходящий тип файла (из наиболее используемых типов тут присутствуют документы Microsoft Word и PowerPoint), далее нажимаем OK и в текущей книге Excel встроенный окном появится новый документ.

К примеру, если выбрать тип файла Microsoft Word, то в окне Excel появится встроенное окно с Word, где доступны все функции программы и мы можем начать набирать любой текст:

Аналогичный пример при работе с Microsoft PowerPoint:

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

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

В результате в рабочем окне Excel появится изображение выбранной иконки и по двойному щелчку мыши по иконке будет открываться исходный документ:

Теперь перейдем ко второму варианту вставки документа.

Внедрение существующего файла

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

Далее для добавления файла нажимаем кнопку Обзор и вставляем нужный нам файл (как и в предыдущем случае мы дополнительно можем задать значок):

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

В этом случае при внесении каких-либо изменений в исходный файл эти изменения отобразятся в прикреплённом файле. Однако, обратите внимание, что связь будет работать только в том случае, если у конечного пользователя (который работает с файлом) будет доступ к этому файлу.

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

Спасибо за внимание!
Если у вас остались вопросы по теме статьи — делитесь своими мыслями в комментариях.

Excel works!

Excel работает за вас

Excel works!

Thanks for Visiting

Как вставить документ в Excel или Word целиком? Хранение доков внутри файлов

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

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

Как это сделать рассказываю далее.

Как вставить документ в Excel или Word целиком?

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

И в Excel, и в Word и даже в PowerPoint на ленте инструментов есть раздел Вставка, в которой есть раздел Текст, а значит мы сможем вставить целый объект в документ. Этот пример для Word

Выбираем пункт Объект. Открывается окно

На вкладке Создание, вы можете создать новый объект, в том числе и новую книгу Excel.

Но нам нужно перейти на вкладку Создание из файла (пункт 1 на следующей картинке)

Затем выбираем файл из нужной папки (п.2) и выбираем галочку «В виде значка» (п.3). После чего жмем ОК. Таким образом в условный файл Word вставится и будет хранится целый документ Excel.

Обратите внимание на галочку Связь с файлом. Если нажмете ее перед, то все изменения из созданного ранее и помещенного внутрь файла будет отображаться открытии. Если галочку как в примере не ставить, то получится чистое хранение файла в файле.

Хранение и вставка доков внутри файлов. Что еще нужно знать?

• Чтобы сделать совсем красиво, вы можете изменить значок вставляемого файла.
• Такие «комплекты файлов» удобно создавать для рассылки нескольким адресатам. Получатель скачивает файл и хранит все файлы в одном. Удобно
• Если же сделать изменения во вложенном файле и сохранить основной документ, то все правки останутся и будут хранится в основном документе.

Небольшая, но удобная возможность пакет MS Office, рекомендую присмотреться.

Вставка объекта в электронную таблицу Excel

Примечание: Мы стараемся как можно оперативнее обеспечивать вас актуальными справочными материалами на вашем языке. Эта страница переведена автоматически, поэтому ее текст может содержать неточности и грамматические ошибки. Для нас важно, чтобы эта статья была вам полезна. Просим вас уделить пару секунд и сообщить, помогла ли она вам, с помощью кнопок внизу страницы. Для удобства также приводим ссылку на оригинал (на английском языке).

Для включения содержимого из других программ, таких как Word или Excel, можно использовать связывание и внедрение объектов (OLE).

Технология OLE поддерживается многими различными программами, и технология OLE используется для создания содержимого, которое создается в одной программе, доступной в другой программе. Например, вы можете вставить документ Office Word в книгу Office Excel. Чтобы узнать, какие типы контента можно вставить, в группе текст на вкладке Вставка нажмите кнопку объект . В поле тип объекта отображаются только программы, установленные на вашем компьютере и поддерживающие объекты OLE.

При копировании данных между Excel или любой программой, поддерживающей технологию OLE, например Word, вы можете скопировать эти данные как связанный объект или внедренный объект. Основные различия между связанными и внедренными объектами находятся в том месте, где хранятся данные, а также о том, как объект будет обновлен после того, как вы поместите его в конечный файл. Внедренные объекты хранятся в книге, в которой они вставлены, и не обновляются. Связанные объекты сохраняются как отдельные файлы, и их можно обновить.

Связанные и внедренные объекты в документе

1. внедренный объект не имеет соединения с исходным файлом.

2. связанный объект связан с исходным файлом.

3. исходный файл обновляет связанный объект.

Когда следует использовать связанные объекты

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

При использовании связанного объекта исходные данные сохраняются в исходном файле. В конечном файле выводится представление связанных данных, в котором хранятся только исходные данные (и размер объекта, если объект является диаграммой Excel). Исходный файл должен быть доступен на вашем компьютере или в сети для поддержания связи с исходными данными.

Связанные данные могут быть обновлены автоматически при изменении исходных данных в исходном файле. Например, если выбрать абзац в документе Word, а затем вставить его как связанный объект в книгу Excel, то при изменении данных в документе Word можно обновить данные в Excel.

Использование внедренных объектов

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

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

Изменение способа отображения объекта OLE

Вы можете отобразить связанный объект или внедренный объект в книге так, как она отображается в программа-источник или в виде значка. Если книга будет просматриваться в Интернете и вы не планируете печатать книгу, вы можете отобразить объект в виде значка. Это уменьшает объем отображаемого пространства, занимаемого объектом. Для просмотра, в котором нужно отобразить сведения, дважды щелкните значок.

Ремонт компьютеров в Самаре

Вы можете использовать программу «Excel» для систематизации различных типов данных, начиная от обзора личного бюджета, заканчивая финансами целых компаний. Вам может понадобиться вставить определенное изображение или документ в рабочий лист. Для этого в программе «Excel» существует функция «Вставка», которую вы можете использовать для вставки множества видов файлов в ваш документ. Широко использующиеся файлы формата PDF совместимы с программой «Excel», поэтому вы можете вставить файл PDF в рабочий лист программы «Excel».

Инструкции

1. Откройте документ «Excel», в который хотите поместить файл PDF.

2. Кликните по клетке, в которую хотите поместить PDF.

3. Кликните меню «Вставка», которое располагается вверху окна программы «Excel».

4. Выберите «Объект».

5. Кликните «Adobe Acrobat Document» в поле «Тип объекта», а затем кликните кнопку «Ок».

6. Найдите нужный файл PDF.

7. Кликните по файлу PDF, затем кликните кнопку «Открыть». Ваш компьютер откроет файл PDF в программе «Adobe reader» и вставит его в ваш рабочий лист программы «Excel».

Примечания

1. Если вы кликните два раза по файлу PDF в программе «Excel», то он откроется в «Adobe reader».

2. Вы можете изменить размер файла PDF, кликнув и перетянув его границы. Помните, что это может привести к искажению PDF в вашем документе «Excel». Если зажмете клавишу «Shift» при изменении размера файла, то такой метод сохранит пропорции и не вызовет искажения.

Прикрепление и извлечение различных файлов из книги Excel

Можно ли прикрепить (вложить) произвольные файлы в обычную книгу Excel?
А потом извлечь эти файлы в заданную папку, и работать с ними?

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

Теперь прикрепить к книге Excel любой файл, а затем извлечь его в любую папку под заданным именем, можно при помощи нескольких строк кода!

В прикреплённом к статье файле находятся 2 модуля класса (AttachedFiles и AttachedFile), а также примеры их использования в виде макросов, позволяющих управлять вложениями в книге Excel.

Пример использования функционала модулей класса для сохранения в книге Excel исполняемого файла, с последующим извлечением:

Если вам требуется прикрепить к книге Excel лишь один небольшой файл (например, маленькую картинку или иконку),
воспользуйтесь возможностью сохранения файлов в виде VBA-функций

Рассмотрим доступные свойства и методы классов, используемых для работы со вложениями.

Класс AttachedFiles позволяет управлять вложенными файлами.

• Функция GetAllFilenames () возвращает коллекцию имён файлов, прикреплённых к документу Excel
  (если нет ни одного прикреплённого файла, возвращается пустая коллекция)
• Функция GetAllFiles () возвращает коллекцию объектов типа AttachedFile (прикреплённый файл)
  (если нет ни одного прикреплённого файла, возвращается пустая коллекция)
  Свойства и методы объекта AttachedFile см. ниже.
• Функция AttachmentExist (ByVal filename$) позволяет проверить наличие вложения с именем файла filename$
  (если книга содержит вложенный файл с таким именем, возвращается TRUE, иначе — FALSE)
• Функция AttachNewFile (Optional ByVal filepath$, Optional ByVal filename$, Optional Overwrite As Boolean = True)
  предназначена для добавления (прикрепления) нового файла, полный путь к которому задан в параметре filepath$.
  Если параметр filepath$ не задан, то будет выведено диалоговое окно, позволяющее выбрать прикрепляемый файл.
  Параметр filename$ служит для указания имени файла, под которым он будет храниться в книге Excel. Если этот параметр не задан, файл сохраняется под тем именем, которое он имел в момент загрузки.
  Парамерт Overwrite, если он равен TRUE (по-умолчанию), позволяет заменять старые вложения новыми без лишних вопросов. При его значении FALSE будет выведено диалоговое окно с вопросом, заменить старый вложенный файл на новый, или нет.
• Функция MaxFileSize () возвращает максимальный допустимый размер прикрепляемого файла
  (для файлов Excel 97, 2000, XP, 2003 можно прикрепить файлы размером до 31 мегабайта , а для Excel 2007б 2010, 2013 — максимальный размер прикрепляемого файла составляет 500 МБ)
• Функция GetAttachment (ByVal filename$) возвращает вложение с именем filename$ в виде объекта типа AttachedFile
  Таким способом, мы получаем возможность обратиться по имени к любому из вложенных файлов (чтобы его запустить, сохранить, удалить, и т.д.)
• Метод DeleteAllAttachments удаляет ВСЕ вложенные файлы из книги Excel

У класса AttachedFiles есть и некоторые свойства, доступные для чтения и изменения:

• Свойство WB (As Workbook) — ссылка на книгу Excel, с которой производятся манипуляции.
  По-умолчанию, WB ссылается на текущую книгу Excel (ThisWorkbook), но можно работать и с любой другой открытой книгой, — для этого достаточно добавить строку кода типа
  Set FileManager.WB = ActiveWorkbook или Set FileManager.WB = Workbooks(«test.xls»)
• Свойство AutoSaveWorkbook (As Boolean, по умолчанию = FALSE) — при установке в TRUE позволяет автоматически сохранять изменения в книге при добавлении или удалении вложенных файлов
• Свойство SilentMode (As Boolean, по умолчанию = FALSE) — при установке в TRUE запрещает вывод информации о процессе извлечения или добавления файла в строку состояния Excel, а также блокирует все уведомления. Таким образом, извлекать и запускать файлы можно в скрытом режиме — пользователь ничего не заметит.
  По-умолчанию (при SilentMode = FALSE), в строке состояния Excel отображается ход выполнения действий с файлами (своего рода прогресс-бар)

Второй модуль класса — AttachedFile — позволяет работать с конкретным вложенным файлом.

• Метод SaveAs (Optional ByVal filepath$) позволяет извлечь (сохранить) вложенный файл по заданному пути filepath$.
  Если путь filepath$ не задан, макрос выдаёт диалоговое окно сохранения файла, где можно указать папку, куда будет извлекаться файл, и задать имя создаваемого файла.
• Метод Delete безвозвратно удаляет вложенный в Excel файл
• Метод Run — позволяет запустить (открыть в программе по-умолчанию) вложенный файл.
  Для этого, файл автоматически извлекается во временную папку Windows, и оттуда уже выполняется запуск созданного файла.
• Функция IsCorrect возвращает TRUE, если размер области данных файла соответствует значению длины файла (которое сохранено при добавлении файла в книгу Excel)
  Если часть данных на скрытом листе (где хранятся вложенные файлы) затерта, функция вернёт значение FALSE, что говорит о нарушении целостности файла.
  Внимание: проверка производится медленно, т.к. при этом производится извлечение данных с листа (аналогично извлечению файла на диск). И, если прикреплённые файлы большие (сотни килобайтов и больше), то проверка каждого файла может длиться от нескольких секунд до минут (для многомегабайтных файлов)
• Функция FileSizeTXT возвращает размер файла в доступном ткестовом виде. Например, 129 Кб, 3.4 Кб, 12.7 Мб

Свойства класса AttachedFiles предназначены только для чтения (хотя их изменение возможно, но нежелательно):

• Свойство filename (As String) содержит имя вложенного файла с расширением
• Свойство AttachDate (As Date) хранит дату и время добавления файла в книгу Excel
• Свойство FileSize (As Long) возвращает размер файла в байтах. Результат возвращается в виде числа, в отличии от функции FileSizeTXT, выдающей текстовое значение.

Принципы работы программы:

• файлы сохраняются на «очень скрытом» листе с названием «SheetForAttachedFiles»
• при загрузке, файлы считываются в бинарном виде, и каждый байт преобразуется в 16-ричное представление.
  Например, файл, состоящий из 5 байтов, будет преобразован в текстовую строку длиной 10 символов примерно такого вида: 3395B3D7FF
• Каждому файлу отводится отдельный столбец на листе:
  (щелкните на картинке для увеличения)
  
• В каждой ячейке хранится 500 байтов данных. (1000 символов)
  Это значение можно изменить в строке Private Const BYTES_PER_CELL& = 500 модуля класса AttachedFiles
• Количеством данных в одной ячейке вызвано ограничение на размер файла.
  Для Excel 2003 оно составляет (65536 — 6) строк * 500 байтов в ячейке = 32765000 байтов = 31,24 Мб
  В Excel 2007 и более новых версиях строк намного больше, поэтому там можно прикреплять файлы размером для 500 МБ (правда, очень сомневаюсь, что Excel выдержит такое издевательство над собой)
• Максимальное число прикрепляемых файлов ограничено числом столбцов на листе Excel.
  В большинстве случаев, 255 файлов — это более чем достаточно. В Excel 2007-2010-2013 можно прикрепить более 16 тысяч файлов.
• Данные файлов не шифруются, но при необходимости это несложно реализовать.

Таблицы – важный инструмент в работе пользователя Excel. Как в Экселе сделать таблицу и автоматизировать этот процесс, ответит наша статья.

Советы по структурированию информации

Перед тем, как создать таблицу в Excel, предлагаем изучить несколько общих правил:

• Сведения организуются по колонкам и рядам. Каждая строка отводится под одну запись.
• Первый ряд отводится под так называемую «шапку», где прописываются заголовки столбцов.
• Нужно придерживаться правила: один столбец – один формат данных (числовой, денежный, текстовый и т.д.).
• В таблице должен содержаться идентификатор записи, т.е. пользователь отводит один столбец под нумерацию строк.
• Структурированные записи не должны содержать пустых колонок и рядов. Допускаются нулевые значения.

Как создать таблицу в Excel вручную

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

1. Открыть книгу и активировать нужный лист.
2. Выделить необходимые ячейки.
3. На панели инструментов найти пиктограмму «Границы» и пункт «Все границы».
4. Указать в таблице имеющиеся сведения.

II способ заключается в ручном рисовании сетки таблицы. В этом случае:

1. Выбрать инструмент «Сетка по границе рисунка» при нажатии на пиктограмму «Границы».
2. При зажатой левой кнопке мыши (ЛКМ) перетащить указатель по обозначенным линиям, в результате чего появляется сетка. Таблица создается, пока нажата ЛКМ.

Как создать таблицу в Excel автоматически

Опытные пользователи рекомендуют прибегнуть к изучению вопроса, как создать таблицу в Excel
автоматически. С использованием встроенного инструментария процесс создания табличной формы происходит в разы быстрее.

Область таблицы

Перед тем, как составить таблицу в Excel, пользователю нужно определить, какой интервал ячеек ему понадобится:

1. Выделить требуемый диапазон.
2. В MS Excel 2013-2019 на вкладке «Главная» кликнуть на пиктограмму «Форматировать как таблицу».
3. При раскрытии выпадающего меню выбрать понравившийся стиль.

Кнопка «Таблица» на панели быстрого доступа

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

1. Активировать интервал ячеек, необходимых для работы.
2. Перейти в меню «Вставка».
3. Найти пиктограмму «Таблицы»:

• В MS Excel 2007 кликнуть на пиктограмму. В появившемся диалоговом окне отметить или убрать переключатель пункта «Таблица с заголовками». Нажать ОК.
• В MS Excel 2016 нажать пиктограмму и выбрать пункт «Таблица». Указать диапазон ячеек через выделение мышкой или ручное прописывание адресов ячеек. Нажать ОК.

Примечание: для создания объекта используют сочетание клавиш CTRL + T.

4. Для изменения названия столбца перейти на строку формул или дважды кликнуть на объекте с заголовком.

Диапазон ячеек

Работа с числовой информацией подразумевает применение функций, в которых указывается интервал (диапазон ячеек). Под диапазоном справочная литература определяет множество клеток электронной таблицы, в совокупности образующих единый прямоугольник (А1:С9).

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

Заполнение данными

Работа со структурированной информацией возможна, если ячейки заполнены текстовой, численной и иной информацией.

• Для заполнения необходимо активировать ячейку и начать вписывать информацию.
• Для редактирования ячейки дважды кликнуть на ней или активировать редактируемую ячейку и нажать F2.
• При раскрытии стрелок в строке заголовка структурированной информации MS Excel можно отфильтровать имеющуюся информацию.
• При выборе стиля форматирования объекта MS Excel автоматически выбрать опцию черезстрочного выделения.
• Вкладка «Конструктор» (блок «Свойства») позволяет изменить имя таблицы.
• Для увеличения диапазона рядов и колонок с последующим наполнением информацией: активировать кнопку «Изменить размер таблицы» на вкладке «Конструктор», новые ячейки автоматически приобретают заданный формат объекта, или выделить последнюю ячейку таблицы со значением перед итоговой строкой и протягивает ее вниз. Итоговая строка останется неизменной. Расчет проводится по мере заполнения объекта.

• В заголовках должны отсутствовать числовые форматы, поскольку при создании таблицы они преобразуются в текст. Если формула содержит в качестве аргумента ссылку на ячейку заголовка, где предполагалось число, то функция может не сработать.

Сводная таблица

Сводка используется для обобщения информации и проведения анализа, не вызывает трудностей при создании и оформлении. Для создания сводной таблицы:

1. Структурировать объект и указать сведения.
2. Перейти в меню «Вставка» и выбрать пиктограмму: в MS Excel 2007 – «Сводная таблица»; в MS Excel 2013-2019 – «Таблицы – Сводная таблица».
3. При появлении окна «Создание сводной таблицы» активировать строку ввода диапазона, устанавливая курсор.
4. Выбрать диапазон и нажать ОК.

Примечание: Если сводка должна находиться после создания на этом же листе, пользователь устанавливает переключатель на нужную опцию.

5. При появлении боковой панели для настройки объекта перенести категории в нужные области или включить переключатели («галочки»).

Созданная сводка автоматически подсчитывает итоги по каждому столбцу.

Рекомендуемые сводные таблицы

Поздние версии MS Excel предлагают воспользоваться опцией «Рекомендуемые сводные таблицы». Подобная вариация анализа информации применяется в случаях невозможности правильного подбора полей для строк и столбцов.

Для применения рекомендуемых сводных таблиц:

1. Выделить ячейки с введенной информацией.
2. При клике на пиктограмму «Таблицы» выбрать пункт «Рекомендуемые сводные таблицы».
3. Табличный процессор автоматически анализирует информацию и предлагает оптимальные варианты решения задачи.
4. В случае выбора подходящего пункта таблицы и подтверждения через ОК получить сводную таблицу.

Готовые шаблоны в Excel 2016

Табличный процессор MS Excel 2016 при запуске предлагает выбрать оптимальный шаблон для создания таблицы. В офисном пакете представлено ограниченное количество шаблонов. В Интернете пользователь может скачать дополнительные образцы.

Чтобы воспользоваться шаблонами:

1. Выбирать понравившийся образец.
2. Нажать «Создать».
3. Заполнить созданный объект в соответствии с продуманной структурой.

Оформление

Экстерьер объекта – важный параметр. Поэтому пользователь изучает не только, как построить таблицу в Excel, но и как акцентировать внимание на конкретном элементе.

Создание заголовка

Дана таблица, нарисованная посредством инструмента «Границы». Для создания заголовка:

Выделить первую строку, кликнув ЛКМ по численному обозначению строки.

На вкладке «Главная» найти инструмент «Вставить».

Активировать пункт «Вставить строки на лист».

После появления пустой строки выделить интервал клеток по ширине таблицы.

Нажать на пиктограмму «Объединить» и выбрать первый пункт.

Задать название в ячейке.

Изменение высоты строки

Обычно высота строки заголовка больше первоначально заданной. Корректировка высоты строки:

• Нажать правой кнопкой мыши (ПКМ) по численному обозначению строки и активировать «Высота строки». В появившемся окне указать величину строки заголовка и нажать ОК.
• Или перевести курсор на границу между первыми двумя строками. При зажатой ЛКМ оттянуть нижнюю границу ряда вниз до определенного уровня.

Выравнивание текста

Если пользователь предполагает расположение текста в ячейке иное, нежели по умолчанию, то пользуется пиктограммами «Выравнивание» относительно горизонтали и вертикали, а также кнопкой «Ориентация». Выбор пунктов выпадающего списка позволит расположить текст по вертикали или диагонали.

Изменение стиля

Изменение размера шрифта, начертания и стиля написания осуществляется вручную. Для этого пользователь пользуется инструментами блока «Шрифт» на вкладке «Главная» или вызывает диалоговое окно «Формат ячеек» через ПКМ.

Пользователь может воспользоваться пиктограммой «Стили». Для этого выбирает диапазон ячеек и применяет понравившийся стиль.

Как вставить новую строку или столбец

Для добавления строк, столбцов и ячеек:

• выделить строку или столбец, перед которым вставляется объект;
• активировать пиктограмму «Вставить» на панели инструментов;
• выбрать конкретную опцию.

Удаление элементов

Для удаления объектов на листе MS Excel пользователь активирует аналогичную кнопку на панели инструментов, предварительно выделив строку, столбец, ячейку.

Заливка ячеек

Для задания фона ячейки, строки или столбца:

• выделить диапазон;
• найти на панели инструментов пиктограмму «Цвет заливки»;
• выбрать понравившийся цвет.

II способ

• вызвать «Формат ячеек» через ПКМ;
• перейти на вкладку «Заливка»;
• выбрать цвет, способы заливки, узор и цвет узора.

III способ

• щелкнуть на стрелочку в блоке «Шрифт»;
• перейти на вкладку «Заливка»;
• выбрать понравившийся стиль.

Формат элементов

На панели инструментов находится пиктограмма «Формат». Опция помогает задать размер ячеек, видимость, упорядочить листы и защитить лист.

Формат содержимого

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

Использование формул в таблицах

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

Ознакомиться с полным списком и вписываемыми аргументами пользователь может, нажав на ссылку «Справка по этой функции».

Для задания формулы:

• активировать ячейку, где будет рассчитываться формула;
• открыть «Мастер формул»;

или

• написать формулу самостоятельно в строке формул и нажимает Enter;

или

• применить и активирует плавающие подсказки.

На панели инструментов находится пиктограмма «Автосумма», которая автоматически подсчитывает сумму столбца. Чтобы воспользоваться инструментом:

• выделить диапазон;
• активировать пиктограмму.

Использование графики

Для вставки изображения в ячейку:

1. Выделить конкретную ячейку.
2. Перейти в меню «Вставка – Иллюстрации – Рисунки» или «Вставка – Рисунок».
3. Указать путь к изображению.
4. Подтвердить выбор через нажатие на «Вставить».

Инструментарий MS Excel поможет пользователю создать и отформатировать таблицу вручную и автоматически.