Как создать надстройку для word

Введение

Целью создания этой статьи является сделать мини- шпаргалку для создания надстроек VSTO, здесь я попытался объединить собранные разрозненные крупицы информации по созданию надстройки VSTO на языке C# для Excel. Статья не претендует на целостное описание процесса создания надстройки, это скорее, «дорожная карта» для новичков, здесь описывается как по шагам сделать простейшую надстройку над Excel.

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

Visual Studio Tools for Office (VSTO, Visual Studio Tools для офиса) представляет собой набор средств разработки, позволяющий использовать всю функциональность .NET Framework для написания пользовательских функций офисного пакета. Надстройки, написанные в VSTO, являются полноценными скомпилированными программами, которые дополняют функционал офисного пакета и кастомизируют бизнес-логику конкретной фирмы.

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

Для начала необходимо создать проект и выбрать тип «Надстройка VSTO для Exсel» в нашей любимой, а может не очень Visual Studio 2022, при необходимости выполнить установку соответствующих компонентов. Далее на следующей странице ввести имя проекта и выбрать платформу .NET Framework 4.8, как самую последнею. Увы платформа ограничивает максимально доступную версию используемого языка С# не выше 7.3, и некий «синтаксический сахар» из последних версий будет недоступен, что немного огорчает.

Сразу же при создании проекта открывается файл ThisAddIn.cs, представляющий собой точку доступа к функциям листа Excel, один недостаток, эти функции доступны только в этом файле, и помочь в этом нам сможет следующий код:

//Возвращает объект приложение Excel
public Excel.Application GetApplication()
{
	return Application;
}
//Возвращает объект активная рабочаяя книга
public Excel.Workbook GetActiveWorkBook()
{
	return (Excel.Workbook)Application.ActiveWorkbook;
}
//Возвращает объект активный рабочий лист
public Excel.Worksheet GetActiveWorksheet()
{
	return (Excel.Worksheet)Application.ActiveSheet;
}
//Возвращает объект активная ячейка
public Excel.Range GetActiveCell()
{
	return (Excel.Range)Application.Selection;
}

И теперь прописав в любом месте в приложения ниже идущий код мы можем получить доступ к функциям Excel:

Application application = Globals.ThisAddIn.GetApplication();
Worksheet worksheet = Globals.ThisAddIn.GetActiveWorksheet();
Range cell = Globals.ThisAddIn.GetActiveCell();
Workbook workBook = Globals.ThisAddIn.GetActiveWorkBook();

Данный код проще всего добавить в абстрактный класс и от него наследовать все функции нашего приложения:

protected abstract class AbstractFunctions
{
	protected readonly Application application = Globals.ThisAddIn.GetApplication();
	protected readonly Worksheet worksheet = Globals.ThisAddIn.GetActiveWorksheet();
	protected readonly Range cell = Globals.ThisAddIn.GetActiveCell();
	protected readonly Workbook workBook = Globals.ThisAddIn.GetActiveWorkBook();
	public abstract void Start();  
}

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

internal class DeleteFormula : AbstractFunctions
{
	public override void Start()
	{
		cell.Value = cell.Value;                            //Удаляем формул
		worksheet.get_Range("A1", Type.Missing).Select();   //Фокус на ячейку А1   
	}
}

Далее необходимо добавить ленту Ribbon (Visual Designer) на которой будут располагаться кнопки запуска наших приложений, тут тоже хитрого ничего нет, и добавляется на точно также, как и все элементы в проект:

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

public partial class Ribbon1
{     
	private void Ribbon1_Load(object sender, RibbonUIEventArgs e)
	{             
		button1.Click += (s, a) =>
		{
			DeleteFormyla deleteFormyla= new DeleteFormyla ();
			DeleteFormyla.Start();
		}
	}
}

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

Теперь кульминация, запуск и.. Не работает, необходимо создать сертификат надстройки, заходим в Projects-Propertis-Signing, создаем тестовый ключ Create Test Certificate. И теперь Ваша надстройка успешно работает.

Таким образом, за минимум действий можно создать рабочую надстройку Excel.

Время прочтения: 6 мин.

Можно создать шаблон документа в Word, используя элементы управления содержимым (Content Control), и ограничить редактирование в нем. Но в документах бывает такое содержимое, которое необходимо добавлять или удалять. Например, добавить еще одну строку в таблицу, добавить пункт распоряжения и т.п. В таком случае будет удобнее создать собственную вкладку в Word, которая позволит изменять структуру документа при необходимости. В этой статье будет показано, как создавать Надстройку VSTO для документа Word.

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

В Visual Studio создадим новый проект «ExampleRibbonWord» типа «Надстройка VSTO для Word 2013 и Word 2016»:

Нам необходимо создать ленту, на которой будут размещаться кнопки и выпадающие списки. Для этого щелкаем правой кнопкой мыши на названии проекта и добавляем элемент Лента (визуальный конструктор):

Вот такая лента у нас создалась:

Теперь в окне свойств элементов управления изменим названия нашей вкладки (Tab1) и группы (Group1).

tab1.Label=”Мои шаблоны”

group1.Label=”Создание шаблона”

Для начала давайте добавим на ленту кнопку (Button1), при нажатии на которую в документе Word будет создаваться шаблон. Свойства Label задаем= «Пример шаблона».

Теперь создадим событие Click для кнопки. Кнопка должна в документе Word сформировать указанный выше шаблон. В элементах управления содержимым мы разместим следующую информацию: дата распоряжения, номер распоряжения, название распоряжения, текст распоряжения, должность и ФИО. Пункты распоряжения мы разместим в таблице без границ. Каждый пункт распоряжения будет также размещаться в элементе управления. При нажатии на кнопку таблица должна сформироваться с одной строкой и двумя столбцами (номер пункта, текст пункта). В дальнейшем необходимо будет реализовать функционал, который позволит добавлять новые пункты в распоряжение.

Код:

public partial class Ribbon1
    {
        private void Ribbon1_Load(object sender, RibbonUIEventArgs e)
        {

        }

        //Создание текстового элемента управления
        //диапазон, тэг (по нему в дальнейшем можно получать содержимое), замещающий текст, когда элемент не заполнен, название 
        private void AddContentControlText(Word.Range r, string tagRTC, string PlaceholderTextRTC, string titleRTC)
        {
            Word.Document currentDocument = Globals.ThisAddIn.Application.ActiveDocument;
            Document extendedDocument = Globals.Factory.GetVstoObject(currentDocument);
            RichTextContentControl rTC = extendedDocument.Controls.AddRichTextContentControl(r, tagRTC);
            rTC.PlaceholderText = PlaceholderTextRTC;
            rTC.Tag = tagRTC;
            rTC.LockContentControl = true;//элемент нельзя удалить
            rTC.Title = titleRTC;
        }

        //Создание элемента управления даты 
        //диапазон, тэг (по нему в дальнейшем можно получать содержимое), замещающий текст, когда элемент не заполнен, стиль даты, название 
        private void AddContentControlDate(Word.Range r, string tagDPC, string PlaceholderTextDPC, string styleDate, string titleDPC)
        {
            Word.Document currentDocument = Globals.ThisAddIn.Application.ActiveDocument;
            Document extendedDocument = Globals.Factory.GetVstoObject(currentDocument);
            DatePickerContentControl dPC = extendedDocument.Controls.AddDatePickerContentControl(r, tagDPC);
            dPC.PlaceholderText = PlaceholderTextDPC;
            dPC.Tag = tagDPC;
            dPC.LockContentControl = true;//элемент нельзя удалить
            dPC.DateDisplayFormat = styleDate;
            dPC.Title = titleDPC;
        }

        //создаем собственный стиль
        private void CreateMyStyle(Word.Document doc)
        {
            Word.Style style = doc.Styles.Add("MyStyleParagraph", Word.WdStyleType.wdStyleTypeParagraph);
            style.Font.Size = 12;
            style.Font.Name = "Times New Roman";
        }

        private void button1_Click(object sender, RibbonControlEventArgs e)
        {
            //при нажатии на кнопку появится диалоговое окно, которое спросит где создать шаблон в текущем открытом word или в новом.
            //при этом, если текущий документ будет не пустым, то шаблон создастся в новом документе
            Word.Document doc;
            DialogResult dialogResult = MessageBox.Show("Создать шаблон в новом документе?", "Создание шаблона", MessageBoxButtons.YesNo);
            if (dialogResult == DialogResult.Yes) doc = new Word.Document();
            else
            {
                doc = Globals.ThisAddIn.Application.ActiveDocument;
                if (doc.Characters.Count > 1)
                {
                    MessageBox.Show("Текущий документ не пустой! Шаблон будет создан в новом документе!");
                    doc = new Word.Document();
                }
            }

            //создаем стиль в текущем документе
            CreateMyStyle(doc);

            //создаем абзац
            doc.Paragraphs.Add();
            Word.Paragraph p = doc.Paragraphs.First;
            Word.Range r = p.Range;
            r.Font.Bold = 1;// шрифт жирный
            r.Text = "РАСПОРЯЖЕНИЕ";//текст абзаца
            r.ParagraphFormat.set_Style(doc.Styles["MyStyleParagraph"]); //стиль применяем

            //создаем абзац и вставляем в него 2 элемента управления
            //для каждого типа элемента управления создаем функцию с параметрами
            doc.Paragraphs.Add();
            p = doc.Paragraphs.Last;
            r = p.Range;
            r.ParagraphFormat.set_Style(doc.Styles["MyStyleParagraph"]);
            //дата распоряжения
            AddContentControlDate(r, "DateRaspr", "Дата распоряжения", "d MMMM yyyy г.", "Дата распоряжения");
            r = doc.Range(p.Range.End - 1, p.Range.End - 1);
            r.Text = " № ";
            //номер распоряжения
            AddContentControlText(r, "NumberRaspr", "Номер распоряжения", "Номер распоряжения");

            doc.Paragraphs.Add();
            p = doc.Paragraphs.Last;
            p.SpaceAfter = 18;
            r = p.Range;
            r.ParagraphFormat.set_Style(doc.Styles["MyStyleParagraph"]);
            r.Font.Bold = 1;
            p.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;//по центру размещаем
            //название распоряжения
            AddContentControlText(r, "NameRaspr", "Название распоряжения", "Название распоряжения");

            doc.Paragraphs.Add();
            p = doc.Paragraphs.Last;
            p.SpaceAfter = 18;
            r = p.Range;
            r.ParagraphFormat.set_Style(doc.Styles["MyStyleParagraph"]);
            p.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;
            //текст распоряжения
            AddContentControlText(r, "TextRaspr", "Текст распоряжения", "Текст распоряжения");

            doc.Paragraphs.Add();
            p = doc.Paragraphs.Last;
            r = p.Range;
            r.ParagraphFormat.set_Style(doc.Styles["MyStyleParagraph"]);
            //таблица для пунктов распоряжения
            Word.Table tbl = doc.Tables.Add(r, 1, 2);
            tbl.Columns[1].SetWidth(doc.Application.CentimetersToPoints(1), Word.WdRulerStyle.wdAdjustFirstColumn);
            tbl.Cell(1, 1).Range.Text = "1.";
            r = doc.Range(tbl.Cell(1, 2).Range.End - 1, tbl.Cell(1, 2).Range.End - 1);
            AddContentControlText(r, "TextPunkt", "Пункт распоряжения", "Пункт распоряжения");

            doc.Paragraphs.Add();
            p = doc.Paragraphs.Last;
            r = p.Range;
            //должность
            AddContentControlText(r, "Dolgnost", "Должность", "Должность");
            r = doc.Range(p.Range.End - 1, p.Range.End - 1);
            r.Paragraphs.TabStops.Add(350, Word.WdAlignmentTabAlignment.wdLeft);
            r.Text = "t";
            r = doc.Range(p.Range.End - 1, p.Range.End - 1);
            //ФИО
            AddContentControlText(r, "FIO", "ФИО", "ФИО");
        }
    }

Запускаем и получаем вот такой шаблон документа:

Для примера заполним дату распоряжения:

Дата заполнена:

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

Конструирование интерфейсов чаще всего используется при создании надстроек. Надстройка представляет собой невидимый документ со встроенным VBA-кодом и с собственными дополнениями к интерфейсу, автоматически открываемый приложением при запуске. При запуске он не показывает своё тело (т.е. содержимое документа — текст, рисунки и пр.), а проявляется только своими изменениями в интерфейсе и подключенными макросами. Таким образом, приложение Microsoft Office дополняет свой функционал, и позволяет редактировать другие документы, используя вновь полученные функции.

Документ надстройки для Word имеет расширение .dotm. Фактически, надстройка для Word является обычным шаблоном с поддержкой макросов. Для надстроек Excel и PowerPoint имеются отдельные расширения — .xlam и .ppam соответственно.

Замечу, что надстройки .xlam и .ppam просто так не открываются в приложениях в качестве документа для редактирования, поэтому пока такая надстройка не готова, её сохраняют как обычный документ с поддержкой макросов. А вот шаблон .dotm можно открыть в Word именно как шаблон (по крайней мере, Ribbon XML Editor это делает), поэтому его можно сохранять шаблоном и в процессе разработки надстройки. Однако, я всё же рекомендую действовать единообразно, и исходники надстроек всегда держать в формате обычных документов с поддержкой макросов, и переводить их в шаблоны или надстройки только после полного окончания их разработки.

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

Откроем Ribbon XML Editor, откроем в нём наш подопытный документ, и в окно для 2007-го интерфейса скопируем текст интерфейса нашей надстройки:

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui">
    <ribbon startFromScratch="false">
        <tabs>
            <tab id="Вкладка1" label="Полезные надстройки" insertBeforeMso="TabHome" keytip="Н">
                <group id="РаботаСПробелами" label="Работа с пробелами">
                    <button 
                        id="УдалитьПовторяющиесяПробелы" 
                        onAction="УдалитьПовторяющиесяПробелы" 
                        label="Удалить повторяющиеся пробелы" 
                        keytip="У" 
                        imageMso="WordArtSpacingMenu" 
                        size="large" 
                        screentip="Удалить повторяющиеся пробелы" 
                        supertip="Найти и заменить все повторяющиеся пробелы одним"/>
                    <button 
                        id="ПробелыВПереносыСтрок" 
                        onAction="ПробелыВПереносыСтрок" 
                        label="Пробелы в переносы строк" 
                        keytip="ПС" 
                        imageMso="PivotExpandField" 
                        size="large" 
                        screentip="Пробелы в переносы строк" 
                        supertip="Найти и заменить все пробелы переносом строки"/>
                    <button 
                        id="ПереносыСтрокВПробелы" 
                        onAction="ПереносыСтрокВПробелы" 
                        label="Переносы строк в пробелы" 
                        keytip="СП" 
                        imageMso="PivotCollapseField" 
                        size="large" 
                        screentip="Переносы строк в пробелы" 
                        supertip="Найти и заменить все переносы строк пробелами"/>                        
                </group>
            </tab>
        </tabs>
    </ribbon>
</customUI>

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

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

Сгенерируем функции обратного вызова (Alt+F11). Скопируем шаблоны в буфер обмена (обращаем внимание на раскладку клавиатуры во избежание появления кракозябр). Закроем окно шаблонов и запустим документ. Перейдём в редактор Бейсика (Alt+F11) и вставим взятые в буфер обмена шаблоны функций вместо наших старых функций модуля RibbonCallbacks.

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

Итак, вставляем в код новую функцию:

'НайтиИЗаменить (компонент: button, атрибут: onAction), 2007
Sub НайтиИЗаменить(findString As String, replaceString As String)
    With Selection.Find
        .ClearFormatting
        .Replacement.ClearFormatting
        .Text = findString
        .Replacement.Text = replaceString
        .Forward = True
        .Wrap = wdFindContinue
        .Format = False
        .MatchCase = False
        .MatchWholeWord = False
        .MatchWildcards = False
        .MatchSoundsLike = False
        .MatchAllWordForms = False
        .Execute Replace:=wdReplaceAll
    End With 
End Sub

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

Теперь заполняем шаблоны процедур обратного вызова:

'УдалитьПовторяющиесяПробелы (компонент: button, атрибут: onAction), 2007
Sub УдалитьПовторяющиесяПробелы(control As IRibbonControl)
Dim NumCharsBefore As Long, NumCharsAfter As Long
    Do
        NumCharsBefore = ActiveDocument.Characters.Count
        Call НайтиИЗаменить("  ", " ")
        NumCharsAfter = ActiveDocument.Characters.Count
    Loop Until NumCharsBefore = NumCharsAfter
End Sub

'ПробелыВПереносыСтрок (компонент: button, атрибут: onAction), 2007
Sub ПробелыВПереносыСтрок(control As IRibbonControl)
    Call НайтиИЗаменить(" ","^p")
End Sub

'ПереносыСтрокВПробелы (компонент: button, атрибут: onAction), 2007
Sub ПереносыСтрокВПробелы(control As IRibbonControl)
    Call НайтиИЗаменить("^p", " ")
    Call НайтиИЗаменить("^w^p", "")
End Sub

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

Две последние функции ещё более элементарны. Там просто вызывается наша функция по поиску и замене, которая меняет пробел на символ абзаца (^p) или наоборот. В последнем случае мы ещё и удаляем появившийся в конце текста из-за неубирающегося символа абзаца лишний пробел (^w — чистое пространство, например, пробелы или табуляция).

Сохраняем код, закрываем редактор Бейсика и сразу проверяем работу кнопок в документе. Замечу, что закрывать редактор Бейсика не обязательно, можно просто сохранить в нём изменения и переключиться в окно документа. Если кнопки заработали, как надо, сохраняем документ как шаблон с макросами (.dotm) в папку:

C:Users[ИмяПользователя]AppDataRoamingMicrosoftWordSTARTUP

Теперь добавим нашу надстройку. Закрываем всё, открываем Word, лезем в Файл -> Параметры -> Надстройки -> Управление, выбираем «Надстройки Word» и нажимаем кнопку «Перейти». В открывшемся окне на первой же вкладке нажимаем «Добавить…» и выбираем наш файл. Нажимаем «ОК», и наша надстройка начинает действовать.

Introduction

In this article, we will see how to create a word add-in and how to run it.

Word add-in is an application that we can run inside of the word to increase the functionality. We can build word add-ins by using HTML, CSS, JavaScript, C#, or any other technology. It does not matter what platform we are using it will work (word for windows, mac, web- office 365 account).

Steps to Create Word Add-in

Step 1

We need to install Yeoman generator (yo) and generator-office globally using npm.

Step 2

Run npm install -g yo generator-office to install yo and office project template generator globally.

Step 3

Run yo office command to create an add-in project.

Step 4

When you run the above command, it will ask for below information.

1. Choose a project type — Office Add-in Task Pane project
2. Choose a script type — JavaScript
3. What do you want to name your add-in? — My Office Add-in
4. Which Office client application would you like to support? — Word

Once you complete the wizard, the generator will create the project and install supporting Node components.

Step 5

Go your project using this command cd «My Office Add-in».

Step 6

Run this command to start development server npm run dev-server. 

Step 7

Run npm start this command run your add-ins.

Step 8

Once you run above command it opens word desktop apps with your add-ins. You can see your add-ins in Home Tab.

Step 9

When you click on add-ins it will open side pane.

Conclusion

This is how we can easily create Word add-in and test it.

1. Вступление

Привет всем!

Ранее мной была написана статья о создании расширения для Microsoft Excel на C#, где я описывал, как с помощью библиотеки Excel-DNA можно создать надстройку, с добавлением пользовательского интерфейса на ленту, и дополнительные функции, для приложения Microsoft Excel. Библиотека Excel-DNA, надо сказать, очень неплохая библиотека, но она имеет как свои плюсы, так и очень существенные минусы.

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

А теперь минусы.

Создание визуального интерфейса надстройки на пользовательскую ленту уже не такое удобное и требует дополнительного стороннего приложения в виде какого-нибудь ribbon xml editor, если Вы, конечно, не желаете довольно досконально изучить все особенности xml-разметки ленты ribbon, чтобы создавать её самому, как говориться, ручками. Хотя, если Вы это действительно изучите, то Вам будет конечно же большой плюс.

Но, кроме не самого приятного способа создания пользовательского интерфейса, ещё и взаимодействие с ним не очень удобное. Дело в том, что прямой доступ к ленте ribbon, при использовании библиотеки Excel-DNA, крайне ограничен, и некоторые взаимодействия с элементами на этой ленте можно произвести только посредством хитрых конструкций, основанных на обработчиках событий, да и то надёжность этих конструкций вызывает вопросы.

Ну и ещё один довольно большой минус — это то, что эта библиотека позволяет создавать надстройки исключительно только для Excel, лишая всякой возможности создать надстройку, скажем, для Word. Кстати, именно это ограничение всё время и мотивировало меня найти какую-либо более универсальную технологию для создания надстроек. И такой технологией оказалось VSTO расширение для Microsoft Office.

2. VSTO расширения для Microsoft Office

Что же такое VSTO? VSTO это Visual Studio Tools for Office, то есть это набор инструментов визуальной среды разработки приложений Visual Studio для Office.

Вообще VSTO не является чем-то совсем уж новым, расширения VSTO можно было создавать еще для Office 2013. Но, что важно, не ниже. И это как раз то, что является его довольно большим минусом. Проблема заключается в том, что в организациях, которые когда-то закупили лицензионный Office 2007, он чаще всего так до сих пор и работает. А что, простой, надежный, без лишних прибамбасов, можно сказать на 100% покрывающий все потребности работы с документами, и закупка более новой версии в целом, вроде как и не имеет смысла, можно сказать пустая трата денег. Но вот расширения VSTO на них встанут едва ли, только если может быть с помощью каких-нибудь «костылей». Так что, если появилась потребность в создании собственных надстроек в приложениях Microsoft Office, то это можно считать существенным мотивом к обновлению ПО, если оно не соответствует требованиям.

Как можно понять из названия VSTO, для его создания в первую очередь конечно же нужен Visual Studio,

на данный момент актуальной версией которой является 2019, и его дополнительный инструмент «Разработка надстроек для Office и SharePoint«.

Добавляемые при этом в Visual studio дополнительные шаблоны и предоставляют наборы инструментов для создания надстроек к Word, Excel, PowerPoint и многих других приложений Microsoft.

Так же в дальнейшем наверняка понадобится инструмент для установки своих созданных надстроек на другие компьютеры, и для этого подойдет расширение «Microsoft Visual Studio Installer Projects«,

которое можно установить с помощью инструмента «управление расширениями«.

Надстройку для Office можно создавать как на уровне документа, то есть эта надстройка будет запущена только при открытии конкретного документа, в котором она была создана, так и на уровне приложения, когда надстройка будет запускаться вместе с приложением независимо от открываемого документа.

Принцип создания надстройки для всех приложений (Word, Excel, PowerPoint и т.д.) в общем-то одинаковый. Для начала создаётся некий интерфейс на пользовательскую ленту инструментов, а затем обрабатываются события, инициируемые элементами этого созданного интерфейса, например, нажатие кнопки. Фактически создание надстройки отличаются в основном только объектной моделью приложения, поэтому, прежде чем создавать надстройку, скажем для Word, вначале нужно изучить объектную модель Word, структуру его документа и API, предоставляющий набор методов для работы с ним. Разумеется, то же касается и остальных приложений пакета Microsoft Office.

Кстати у технологии VSTO я вижу еще один минус. Я пока что так и не нашел, как с помощью VSTO просто расширить набор функций Excel, как это возможно посредством библиотеки Excel-DNA, а ведь это весьма полезная функция.

3. Приступаем к разработке надстройки

А теперь пример создания очень простенькой надстройки для Word, которая все что и будет уметь делать, так это вставлять в документ в текущую позицию фразу «Привет Мир!», ну или за место слова «Мир» будет вставляться указанное имя. При этом можно будет оценить преимущества разработки расширений VSTO по отношению к библиотеке Excel-DNA, если Вы читали мою статью об этой библиотеке.

И так, после того как инструмент «Разработка надстроек для Office и SharePoint» будет добавлен в Visual Studio, в нём появятся множество дополнительных шаблонов. Среди этих шаблонов нас в данный момент интересует шаблон «Надстройка VSTO для Word«.

Кстати, как можно увидеть на изображении выше, рядом так же находятся шаблоны для создания Документа VSTO для Word, и Шаблона VSTO для Word, которые позволяют соответственно создать конкретный документ Word, расширенный дополнительным функционалом, или шаблон документа, который далее будет генерировать документы Word.

Создадим новый проект надстройки VSTO для Word и назовём его «HelloWoldAddIn», на что в ответ будет получен следующий автоматически сгенерированный код:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using Word = Microsoft.Office.Interop.Word;
using Office = Microsoft.Office.Core;
using Microsoft.Office.Tools.Word;

namespace HelloWoldAddIn
{
    public partial class ThisAddIn
    {
        private void ThisAddIn_Startup(object sender, System.EventArgs e)
        {
        }

        private void ThisAddIn_Shutdown(object sender, System.EventArgs e)
        {
        }

        #region Код, автоматически созданный VSTO

        /// <summary>
        /// Требуемый метод для поддержки конструктора — не изменяйте 
        /// содержимое этого метода с помощью редактора кода.
        /// </summary>
        private void InternalStartup()
        {
            this.Startup += new System.EventHandler(ThisAddIn_Startup);
            this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);
        }
        
        #endregion
    }
}

Класс ThisAddIn, который был автоматически создан, является наследником класса Microsoft.Office.Tools.AddInBase, который, в свою очередь, предоставляет доступ к объектной модели текущего приложения посредством поля Application, возвращающего объект, представляющий экземпляр этого приложения.

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

Но, с помощью только этих двух обработчиков многого не сделаешь, для работы нужна хотя бы одна какая-нибудь кнопка, которую можно было бы нажать в нужный момент работы с документом. И эту кнопку конечно же можно создать на ленте пользовательского интерфейса. Поэтому следующая задача — добавить в проект «Ленту«, и чтобы было удобнее её редактировать, стоит выбрать именно ленту в визуальном конструкторе,

после чего, собственно, и появится конструктор вкладки TabAddIns на ленте, пока еще пустой. Эту вкладку представляет класс Ribbon1, который является наследником класса Microsoft.Office.Tools.Ribbon.RibbonBase, который, в свою очередь, представляет базовый класс для настроек ленты Microsoft Office.

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

И вот теперь в надстройке наконец-то появилась такая нужная нам кнопка, которую я назвал «Привет Мир!». Так же, для небольшой демонстрации некоторых возможностей, я сразу же добавил текстовое поле «Имя», из которого будет браться указанное имя для замены слова «Мир» во вставляемой этой надстройкой фразе.

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

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

protected override IRibbonExtensibility CreateRibbonExtensibilityObject() {
    Ribbon1 ribbon = new Ribbon1();
    return Globals.Factory.GetRibbonFactory().CreateRibbonManager(
        new Microsoft.Office.Tools.Ribbon.IRibbonExtension[] { ribbon });
}

И теперь, запустив приложение кнопкой Пуск,

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

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

Но далее возникает одна проблемка. Сама лента Ribbon не имеет доступа к Application, и соответственно не может получить экземпляр текущего приложения для работы с ним и его документами. Так что писать код обработчика события нажатия кнопки прямо в классе Ribbon это плохая идея. Но это проблема решается довольно просто — нужно добавить новое событие, например, ButtonClicked, самому классу Ribbon, и при нажатии кнопки на ленте запустить обработчик этого нового события. А сам программный код этого обработчика определить в классе ThisAddIn, который уже вполне имеет доступ к Application. И кроме того, через этот обработчик, основанный на стандартном делегате Action, в класс ThisAddIn можно передать экземпляр текущего класса Ribbon, что позволит получить полноценный доступ к своей вкладке на ленте и всем её компонентам.

    public partial class Ribbon1 {
        public event System.Action<Ribbon1> ButtonClicked;
        private void Ribbon1_Load(object sender, RibbonUIEventArgs e) {
            
        }

        private void btnHelloWorld_Click(object sender, RibbonControlEventArgs e) {
            ButtonClicked?.Invoke(this);
        }
    }

    public partial class ThisAddIn
    {

        . . .

        protected override IRibbonExtensibility CreateRibbonExtensibilityObject() {
            Ribbon1 ribbon = new Ribbon1();
            ribbon.ButtonClicked += Ribbon_ButtonClicked;
            return Globals.Factory.GetRibbonFactory().CreateRibbonManager(
                new Microsoft.Office.Tools.Ribbon.IRibbonExtension[] { ribbon });
        }

        private void Ribbon_ButtonClicked(Ribbon1 ribbon) {
            // Если в текстовом поле на ленте указано имя, то возьмем его. Иначе имя будет Мир.
            string _name = ribbon.ebHelloWorld.Text == "" ? "Мир" : ribbon.ebHelloWorld.Text;
            // Вставим в текущую позицию текст "Привет" и определенное выше имя.
            Application.Selection.Text = $"Привет {_name}!";
        }
    }

Ну вот надстройка и готова, осталось её запустить, и проверить её работу.

Да, кстати, после того как Вы протестируете надстройку, она останется в приложении Word и после закрытия Visual Studio, что не совсем правильно, так как эта надстройка пока еще только тестовая. Поэтому перед тем как завершить работу в Visual Studio не забудьте очистить собранный проект.

4. Дополнительные возможности надстройки

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

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

public partial class ThisAddIn
{
    const string FILE_NAME = "HelloWordAddIn.txt";
    string name = "";

    private void ThisAddIn_Startup(object sender, System.EventArgs e)
    {
        name = LoadName();
    }

    private void ThisAddIn_Shutdown(object sender, System.EventArgs e)
    {
    }

    #region Код, автоматически созданный VSTO

    /// <summary>
    /// Требуемый метод для поддержки конструктора — не изменяйте 
    /// содержимое этого метода с помощью редактора кода.
    /// </summary>
    private void InternalStartup()
    {
        this.Startup += new System.EventHandler(ThisAddIn_Startup);
        this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);
    }

    #endregion

    protected override IRibbonExtensibility CreateRibbonExtensibilityObject() {
        Ribbon1 ribbon = new Ribbon1();
        ribbon.ButtonClicked += Ribbon_ButtonClicked;
        return Globals.Factory.GetRibbonFactory().CreateRibbonManager(
            new Microsoft.Office.Tools.Ribbon.IRibbonExtension[] { ribbon });
    }

    private void Ribbon_ButtonClicked(Ribbon1 ribbon) {
        // Определим какое имя должно быть указно при нажатии кнопки.
        string _name = 
            ribbon.ebHelloWorld.Text == "" ? (string.IsNullOrEmpty(name) ? "Мир" : name) 
            : ribbon.ebHelloWorld.Text;
        // Вставим в текущую позицию текст "Привет" и определенное выше имя.
        Application.Selection.Text = $"Привет {_name}!";
    }

    /// <summary>
    /// Получает имя из файла в директории "Мои документы"
    /// </summary>
    /// <returns></returns>
    private string LoadName() {
        string _name = "";
        // Для начала надо узнать путь к директорию "Мои документы" 
        // текущего пользователя,
        string myDocuments = 
            Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
        // и сформировать полный путь к текстовому файлу, 
        // в котором должно быть указано имя.
        string path = $@"{myDocuments}{FILE_NAME}";

        // Если этого файла нет,
        if (!File.Exists(path))
            // то надо его создать, и сразу закрыть.
            File.Create(path).Close();

        try {
            // Далее надо открыть текстовый файл,
            using (StreamReader sr = 
                new StreamReader($@"{myDocuments}{FILE_NAME}", Encoding.UTF8)) {
                // и считать из него указанное имя.
               _name = sr.ReadLine();
            }
        } catch (FileNotFoundException) {
            // Если во время открытия файла возникла ошибка, 
            // значит пусть имя останется пустым.
            _name = "";
        }
        return _name != null ? _name : "";
    }
}

В этом коде был добавлен метод LoadName, который находит в директории документов пользователя файл «HelloWordAddIn.txt» и считывает из него имя, которое нужно поприветствовать. Чтобы постоянно не обращаться к файлу, имя считывается один раз при запуске настройки из метода ThisAddIn_Startup, и запоминается в глобальной переменной name, к которой уже в любой момент могут обратиться все желающие.

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

Сделать это можно в классе ленты Ribbon в методе Ribbon1_Load, который срабатывает при загрузке ленты в приложении Office. Но делать это прямо в классе ленты опять же будет не целесообразно, так как прямой связи с классом ThisAddIn он не имеет, а ведь именно в нём находятся данные для загрузки имени из файла. Зато есть смысл добавить классу Ribbon ещё одно событие RibbonLoad, обработчик которого будет запускаться при загрузке ленты.

И тогда класс Ribbon примет следующий вид:

    public partial class Ribbon1 {
        public event System.Action<Ribbon1> RibbonLoad;
        public event System.Action<Ribbon1> ButtonClicked;

        private void Ribbon1_Load(object sender, RibbonUIEventArgs e) {
            RibbonLoad?.Invoke(this);
        }

        private void btnHelloWorld_Click(object sender, RibbonControlEventArgs e) {
            ButtonClicked?.Invoke(this);
        }
    }

а в классе ThisAddIn тогда немного изменится метод CreateRibbonExtensibilityObject.

    protected override IRibbonExtensibility CreateRibbonExtensibilityObject() {
        Ribbon1 ribbon = new Ribbon1();
        ribbon.RibbonLoad += Ribbon_RibbonLoad;
        ribbon.ButtonClicked += Ribbon_ButtonClicked;
        return Globals.Factory.GetRibbonFactory().CreateRibbonManager(
            new Microsoft.Office.Tools.Ribbon.IRibbonExtension[] { ribbon });
    }

В нем добавляется обработчик на новое, только что созданное, событие. И, соответственно, добавиться метод Ribbon_RibbonLoad,

        /// <summary>
        /// Обработка события возникающего при загрузке надстройки на ленте Ribbon
        /// </summary>
        /// <param name="ribbon"></param>
        private void Ribbon_RibbonLoad(Ribbon1 ribbon) {
            ribbon.ebHelloWorld.Text = name;
        }

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

5. Ручная установка надстройки

Теперь, когда надстройка готова, её надо установить. Для того чтобы Microsoft Word увидел и подключил надстройку на другом компьютере, проект надстройки надо собрать уже не в режиме разработки (Debug), а в режиме развертывания (Release). В выходном каталоге, примерно где-то здесь: C:UsersUsersourcereposHelloWoldAddInHelloWoldAddInbinRelease, будут скомпилированы несколько файлов. Нас интересуют четыре из них:

• HelloWoldAddIn.dll
• HelloWoldAddIn.dll.manifest
• HelloWoldAddIn.vsto
• Microsoft.Office.Tools.Common.v4.0.Utilities.dll

Все эти четыре файла нужно скопировать куда-нибудь в одну папку. Но, для того чтобы Word увидел надстройку, нужна еще соответствующая запись в системном реестре. А точнее, в ветке реестра HKEY_CURRENT_USERSoftwareMicrosoftOfficeWordAddins (если приложение Excel, то и ветка соответствующая), нужно добавить раздел нашей надстройки, например, HelloWoldAddIn. В этом разделе нужно создать четыре параметра:

• строковый параметр «Description»
• строковый параметр «FriendlyName»
• параметр DWORD (32 бита) «LoadBehavior»
• строковый параметр «Manifest»

и заполнить их примерно как указано на изображении ниже.

Параметр «Description» — это понятно, описание надстройки.

Параметр «FriendlyName» — это то, как надстройка будет выглядеть в списке надстроек в приложении Microsoft.

Параметр «LoadBehavior» равный 3 означает, что надстройка включена.

Самый сложный получается параметр «Manifest«, тут указан путь к файлам надстройки. Но, надо обязательно учесть, что перед началом пути стоит префикс «file:///», да-да, именно с треся слешами, а в конце пути указан суффикс «|vstolocal» и именно с «пайпом» в начале суффикса. А сам путь должен указывать на конкретный файл с расширением «vsto».

Если Вы все правильно сделаете, то запустив приложение Word, после нескольких предупреждений о нарушении безопасности, на ленте интерфейса Вы увидите свою надстройку. А если зайти в параметры Word, то на вкладке «Надстройки» будет информация о добавленной надстройке.

Так же, если зайти в «Управление надстройками COM«, то в списке надстроек будет отображаться Ваша надстройка, которую при желании можно временно отключить, убрав галочку напротив неё.

Если параметры реестра прописаны в ветке «HKEY_CURRENT_USER«, то надстройка будет доступна только текущему пользователю Windows, а если те же параметры прописать в ветке «HKEY_LOCAL_MACHINE«, то надстройка станет доступна для всех пользователей системы.

6. Установка надстройки с помощью установщика Windows

Но конечно же устанавливать надстройку вручную очень неудобно, поэтому гораздо лучше создать установщик, который всё сделает сам. Поэтому, если Вы все ещё не установили себе расширение «Microsoft Visual Studio Installer Projects«, то самое время это сделать.

Далее надо добавить проект установщика (Setup Project) в решение,

после чего сразу откроется вкладка «File System«. Если же она не открылась, то открыть её можно самому, нажав правой кнопкой мыши на проекте установщика, и в появившемся меню из «View» выбрать пункт «Файловая система«.

Во вкладке файловой системы надо указать, какие файлы нужны для работы. Для этого надо вызвать меню правой кнопкой мыши на разделе «Application Folder«, и из пункта «Add» выбрать подпункт «Выходной элемент проекта…«.

Появится окно «Добавление выходной группы проекта«, в котором надо выбрать пункт «Основные выходные файлы» и нажать кнопку «ОК».

После этого в разделе «Application Folder» появится список файлов. Это и есть те файлы, которые далее будут скопированы в рабочий раздел надстройки, и которые должны отвечать за её работу.

Но этот список надо немного скорректировать, что-то надо в него добавить, а что-то из него удалить. А именно.

В этом списке в данный момент не хватает двух важных файлов манифеста надстройки Word:

• HelloWoldAddIn.dll.manifest
• HelloWoldAddIn.vsto

Чтобы их добавить нужно снова вызвать контекстное меню раздела «Application Folder» и из пункта меню «Add» выбрать теперь уже подпункт «Файл…«. Откроется окно выбора файлов, в котором надо найти эти файлы манифеста. Найти их можно, как я уже указывал ранее, в выходном каталоге проекта надстройки, примерно где-то здесь: C:UsersUsersourcereposHelloWoldAddInHelloWoldAddInbinRelease. Если этот каталог пустой, значит Вы просто забыли собрать проект надстройки в режиме развертывания (Release), сделайте это. А далее надо добавить эти два файла в список выходных файлов.

А теперь в списке ещё остались файлы, которые в рабочем каталоге надстройки совершенно не нужны, их надо исключить из списка выходных файлов. Это удобнее делать из окна «Обозревателя решений«. Чтобы исключить файл из списка надо выбрать его в обозревателе, после чего в окне свойств установить значение параметра «Exclude» в True. После этого этот файл в «Обозревателе решений» примет вид как исключённый, а из списка выходных файлов и вовсе исчезнет.

Исключить из списка нужно все файлы из-под раздела обнаруженных зависимостей («Detected Dependencies»), за исключением платформы «Microsoft .NET Framework» или любой сборки, завершающейся ** *.Utilities.dll**

Должно получиться примерно вот так:

Сразу же можно настроить путь к выходным файлам надстройки. Для этого надо выбрать раздел «Application Folder«, после чего в окне свойств в параметре «DefaultLocation» можно будет увидеть шаблон пути: [ProgramFiles64Folder][Manufacturer][ProductName].

ProgramFiles64Folder или ProgramFilesFolder означает путь к директорию Program Files, или Program Files (x86), смотря какую платформу Вы выберите, 64-битную или 32-битную.

Параметры «Manufacturer» и «ProductName» — это переменные, которые можно настроить в окне свойств проекта установщика, после того как будет выбран корень проекта «HelloWorldAddInSetup«.

Здесь же с помощью параметра «TargetPlatform» выбирается платформа, 64-битная (x64) или 32-битная (x86), это важно и зависит от того, для какого офиса будет устанавливаться надстройка, для 64-битного или 32-битного.

Не менее важным параметром является параметр «Version«, который влияет на то, будут ли при переустановке надстройки уже существующие файлы заменены, или будет отображено сообщение, что более новая версия уже установлена. При изменении этого параметра, будет предложено автоматически изменить значение параметра «ProductCode«, сформировав новый уникальный код. Ориентируясь на этот код, установщик будет принимать решение, устанавливается ли измененная надстройка или производится попытка ещё раз установить ту же самую надстройку. Если код разный, то далее уже делается проверка номера версии устанавливаемой надстройки, выше она, уже установленной, или ниже.

Так же здесь настраивается переменная «Author«, которую тоже можно использовать в шаблоне пути выходных файлов.

Еще полезные параметры, которые будут видны при установке надстройки, это «Description» — описание надстройки и «Title» — всплывающая подсказка к надстройке.

Как можно вспомнить из раздела ручной установки надстройки, для её работы кроме файлов нужна ещё запись в системном реестре. Для программной установки записи в реестр надо правой кнопкой вызвать контекстное меню на заголовке проекта установщика, и далее из меню «View» выбрать подменю «Реестр«.

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

Запись в ветке реестра HKEY_CURRENT_USER означает, что настройка будет установлена только для текущего пользователя. А ветка HKEY_LOCAL_MACHINE — что надстройка будет установлена для всех пользователей операционной системы. Но, в любом случае, начальные записи не верны, поэтому раздел «[Manufacture]» можно смело удалять из обоих веток.

Далее надо решить, будет ли всё-таки устанавливаться надстройка для всех или только для текущего пользователя, и выбрать для дальнейшей работы соответствующую ветку HKEY. В этой ветке к разделу «Software» надо последовательно добавить разделы, чтобы получился следующий путь: HKEY_*SoftwareMicrosoftOfficeWordAddInsParadox.HelloWorldAddIn. Понятно, что в этом пути Word означает надстройку для приложения Microsoft Word, и если надстройка создается, например, для Excel, то за место Word надо указать Excel. А раздел с именем «Paradox.HelloWorldAddIn» это уже непосредственно сама надстройка и может быть названа как угодно по своему усмотрению, но обычно её имя строится из названия организации или автора и названия надстройки через точку.

После того как путь будет построен, в разделе «Paradox.HelloWorldAddIn» следует создать четыре параметра:

• строковый параметр «Description»
• строковый параметр «FriendlyName»
• параметр DWORD (32 бита) «LoadBehavior»
• строковый параметр «Manifest»

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

Как можно заметить, в параметре «Manifest«, в отличии от ручной настройки, указан не путь к файлам надстройки, а переменная «[TARGETDIR]«, которая автоматически выстроит путь к директорию, куда будет установлена надстройка. А какой путь выстроит эта переменная, настраивается в свойствах «Application Folder» вкладки «File System» («Файловой системы«). По умолчанию это директорий с указанным наименованием организации и наименованием имени продукта в каталоге Program Files или Program Files (x86), в зависимости от того, какая платформа была выбрана.

Ну и в общем-то для сборки установщика почти всё готово. Можно ещё сделать проверку требуемой версии Microsoft .NET Framework. Для этого надо нажать правой кнопкой мыши на заголовке проекта установщика, в нашем случае это HelloWorldAddInSetup, и из контекстного меню выбрать пункт «Свойство«, после чего появиться окно страницы свойств установщика.

В этом окне надо нажать кнопку «Предварительные требования» (Prerequisites…), которое откроет окно «Необходимые компоненты«, в котором можно выбрать нужную версию .NET Framework, используемую при создании надстройки.

Так как моим приложениям часто приходиться работать на Windows 7, то я обычно рабою с .NET Framework версии 4.5.2.

Microsoft также при создании установщика для надстроек VSTO рекомендует настроить условия запуска для обнаружения среды выполнения VSTO. Но, для непосредственной установки надстройки, это не обязательно, если Вам будет интересно, то дополнительную информацию по настройке установщика можно найти на официальном сайте Microsoft. А без этих проверок надстройка после установки просто либо заработает, если у Вас Office 2013 или выше, или не заработает, если у Вас соответственно Office ниже версии 2013.

Всё, теперь надо убедиться, что режим компиляции установлен как Release и пересобрать проект установщика. В выходном каталоге проекта установщика надстройки будут созданы два файла — HelloWorldAddInSetup.msi и setup.exe, для установки надстройки можно использовать любой из них. Устанавливаем, запускаем Word и пользуемся.

• Download source files — 177 Kb
• Download demo files — 353 Kb

Introduction

In this article, we will learn how to create a simple Hello World browser add-in for Microsoft’s applications that supports add-in. A list of such applications is given here:

1. Microsoft Word
2. Microsoft VSMacros IDE
3. Microsoft Visual Studio .NET
4. Microsoft Visio
5. Microsoft Publisher
6. Microsoft Project
7. Microsoft PowerPoint
8. Microsoft Outlook
9. Microsoft FrontPage
10. Microsoft Excel
11. Microsoft Access

In this article, we will take Microsoft Outlook as an example.

Prerequisites:

You must have the following …

1. Microsoft Development Environment 2003 or higher
2. Microsoft .NET Framework 2.0
3. Office Primary Interop Assemblies (PIAs). For Office XP, click here to download.

Creating the Add-in

• Run the Microsoft Development Environment.
• Go to File> New Project>, a dialog will appear.
• Go to Other Projects> Extensibility Project, select Shared Add-in type project template.

Add-In Wizard

When the Add-in wizard starts, press Next…

Select programming language (example C#), press Next.

Select applications in which you want to host your add-in, press Next.

Provide add-in name and description, press Next.

Choose add-in options, press Next.

Press Finish.

Setup Projects

Two projects will be added automatically.

1. Add-in project.
2. Setup project.

Creating the Browser Form

1. Add a form for the Add-in project, named frmHelloWorld.cs.
2. Add a Label, TextBox, and a PictureBox.
3. Add a Microsoft web browser control to the form (you can get it by right clicking on the toolbox, selecting Add/Remove Items, and clicking on the “COM Components”: a lot of controls will be listed, select Microsoft Web Browser Control, and press OK.
4. With the following code, create a function go():

void go()
{
    try
    {
        stbPanel1.Text="Trying to open "+tbURL+"..." ;
        object obj=new object ();
        browser.Navigate(tbURL.Text,ref obj,ref obj,ref obj,ref obj);
    }
    catch(Exception ex)
    {
        
    }
}

Call this function on the PictureBox‘s Click event.

Programming for Add-in Connection

Install PIAs and add a reference to the following DLL: Microsoft.Office.Interop.Outlook.DLL.

There will be a file connect.cs in the add-in project, open it. Declare the following items globally:

private Microsoft.Office.Interop.Outlook.Application applicationObject; 
private object addInInstance; 
private CommandBarButton btnLaunch;

In the function OnStartupComplete, write the following code:

public void OnStartupComplete(ref System.Array custom)
{
    CommandBars commandBars = 
        applicationObject.ActiveExplorer().CommandBars;

    try
    {
        
               btnLaunch= (CommandBarButton)
            commandBars["Standard"].Controls["HelloWorld"];
    }
    catch
    {
        
                 btnLaunch = (CommandBarButton)
            commandBars["Standard"].Controls.Add(1, 
            System.Reflection.Missing.Value, 
            System.Reflection.Missing.Value, 
            System.Reflection.Missing.Value, 
            System.Reflection.Missing.Value);
        btnLaunch.Caption = "Hello World Browser!";
        btnLaunch.Style = MsoButtonStyle.msoButtonCaption;
    }
    
    btnLaunch.Tag = "This is Hello World Browser!";


    btnLaunch.OnAction = "!<EMAILSTATSADDIN.CONNECT>";
    btnLaunch.Visible = true;
    btnLaunch.Click += new 
        _CommandBarButtonEvents_ClickEventHandler(
        btnLaunch_Click);
}

In the function OnBeginShutdown, write the following code:

public void OnBeginShutdown(ref System.Array custom)
{
    
    CommandBars commandBars = applicationObject.ActiveExplorer().CommandBars;
    try
    {
        
        commandBars["Standard"].Controls["HelloWorld"].Delete(
                             System.Reflection.Missing.Value);
    }
    catch(System.Exception ex)
    {
        
    }
}

Write the following code in the btnLanuch event handler:

private void btnLaunch_Click(CommandBarButton Ctrl, 
                            ref bool CancelDefault)
{
    try
    {
        frmHelloWorld objfrmHelloWorld=new frmHelloWorld ();
        objfrmHelloWorld.Show();  
    }
    catch(Exception ex)
    {
        
    }
}

Rebuild and Installation

Right click on the setup project, click Rebuild, and it will automatically rebuild the add-in and the setup project. Then, right click on the setup project and click Install.

Running

Run Microsoft Outlook, and you will see “Hello World Browser!” on the toolbar. Click on it and your add-in will start. As you can see here…

Known Issues

After uninstallation, the “Hello World Browser!” button is not removed from the Outlook toolbar.