MSDN Magazin > Home > Ausgaben > 2008 > May >  Office Space: Vom VBA-Makro zum Word-Add-In
Office Space
Vom VBA-Makro zum Word-Add-In
Robert Bogue

Codedownload verfügbar unter: OfficeSpace2008_05.exe (166 KB)
Browse the Code Online
Dokumentautomation ist keinesfalls eine neue Funktionalität. Es gibt sie seit der Erfindung von Makros, und seit den frühen 1990er-Jahren gibt es in Microsoft® Office-Anwendungen ein voll entwickeltes Programmiermodell. Viele Jahre verfügten Office-Tools über Makroaufzeichnung, die nicht darauf beschränkt war, einfache Tastaturanschläge wiederzugeben, sondern auch dynamisch Code schreiben konnte. Es hat sich sogar gezeigt, dass Makros für das Schreiben von Viren geeignet sind. Das Schreiben eines Virus mit einem Word-Makro ist zwar ein fragwürdiges Kunststück, aber dennoch ein Kunststück.
Aber trotz aller Funktionen von Visual Basic® for Applications (VBA) gibt es einige Dinge, die sich damit nicht sehr gut umsetzen lassen. In den frühen Tagen von VBA war XML noch nicht erfunden, das Internet steckte noch in den Kinderschuhen, und die ersten HTML-Seiten tauchten gerade erst auf. Somit ist es nicht verwunderlich, dass ein Webdienstaufruf im Kontext von Visual Basic for Applications nicht gut verarbeitet wird.
Die Microsoft .NET Framework-CLR andererseits kennt diese Technologien recht gut. Die Möglichkeit, Webdienste aufzurufen, ist nur einer von vielen Gründen dafür, auf .NET statt auf VBA abzielenden Code schreiben zu wollen. Dafür ist Visual Studio® Tools for Office (VSTO) erforderlich. Doch beim Wechsel von VBA zu VSTO muss nicht das Kind mit dem Bade ausgeschüttet werden. Es kann lediglich eine natürliche Möglichkeit sein, die Entwicklung von Lösungen in Office zu erweitern.
In diesem Artikel erfahren Sie, wie Sie mit Word etwas VBA-Code erstellen können, um ein grundlegendes Problem zu lösen. Dann wird die aktuelle, in Visual Studio 2008 enthaltene Version von VSTO verwendet, um diesen Code in ein bereitstellbares Word-Add-In zu packen. Es wird auch ein wenig einfacher Code für einige der Aufgaben geschrieben, die mit der Makroaufzeichnung entweder gar nicht oder nicht optimal aufgezeichnet werden können.

Bücherwissen
Kürzlich befand ich mich selbst in einer Situation, in der diese Art der Konvertierung von VBA zu VSTO die perfekte Lösung für das vorliegende Problem war. Ich schloss gerade mein aktuelles Buch ab, „The SharePoint Shepherd's Guide for End Users“. Das Buch wurde von mir selbst veröffentlicht, und das Manuskript musste von Word in einer PDF ausgegeben werden, die vom Drucker verwendet werden konnte. Für diese Arbeit mussten zunächst mehrere Schritte durchgeführt werden, um das Manuskript vorzubereiten.
Zuerst mussten mehrere Dateien in einem großen Dokument zusammengeführt werden. Bei mehr als 140 einzelnen Dateien, die 13 Abschnitte und 116 Aufgaben repräsentieren, wollte ich das Zusammenfügen nicht von Hand erledigen. So viele einzelne Dateien zu haben war bei der Arbeit mit Microsoft SharePoint® toll, weil damit jede einzelne Aufgabe durch den redaktionellen Workflow nachverfolgt werden konnte. Doch durch die große Zahl wurde das Zusammenfügen zu einer Aufgabe, die am besten durch Automatisierung zu bewältigen war.
Zweitens sollte sichergestellt werden, dass alle nachverfolgten Änderungen in allen Dokumenten akzeptiert worden waren. Während der Bearbeitung wurden Überarbeitungsmarkierungen verwendet (über das Feature „Änderungen nachverfolgen“ in Word), um die Bearbeitungen und andere Änderungen am Manuskript nachzuverfolgen. Die Überarbeitungsmarkierungen sollen alle im Rahmen des endgültigen Auscheckens des Inhalts akzeptiert werden. Wenn ich aber einige übersehen hätte, würde die Formatierung der Überarbeitungsmarkierungen im endgültigen Buch sichtbar sein, was nicht sehr professionell aussehen würde.
Drittens mussten alle verbliebenen Kommentare aus den Dokumenten entfernt werden. Es gab zwischen den verschiedenen Editoren Kommentare dazu, wie die Dinge funktionieren und wie einiges von der Terminologie standardisiert werden kann. Diese Kommentare hätten während einer früheren Überarbeitung entfernt worden sein sollen. Aber ein bisschen Automatisierung, um dies zu überprüfen, ist vernünftig und angemessen. Wie die Überarbeitungsmarkierungen waren die Kommentare etwas, das nicht im endgültigen Produkt erscheinen sollte.
Ich werde den Prozess der Erstellung jedes dieser Teile erläutern und auf die Möglichkeit eingehen, mithilfe der Makroaufzeichnung den für jede Funktion erforderlichen Code aufzuzeichnen. Zu Beginn wird mithilfe der Makroaufzeichnung grundlegender Automatisierungscode generiert. Dann wird der verwendbare, aber nicht optimale generierte Code näher betrachtet. Abschließend wird betrachtet, warum mit der Makroaufzeichnung u. U. gar kein Code generiert wird. Der VBA-Code wird in VSTO-Code konvertiert und in ein Word-Add-In gepackt, mit dem das endgültige Buch zusammengestellt werden kann. Um den Prozess etwas herausfordernder zu gestalten, wird der Code auf seinem Weg von VBA nach VSTO in C# konvertiert.

Makro-Grundlagen
Der erste Schritt in diesem Prozess besteht darin, sich zu vergewissern, dass die Registerkarte „Entwicklertools“ in Word sichtbar ist, damit die Makros aufgezeichnet werden können. Klicken Sie auf die Office-Schaltfläche und dann unten im Menü auf die Schaltfläche „Word-Optionen“. Aktivieren Sie im Dialogfeld „Word-Optionen“ das Kontrollkästchen „Registerkarte 'Entwicklertools' in der Multifunktionsleiste anzeigen“ (siehe Abbildung 1), und klicken Sie auf „OK“. Die Registerkarte „Entwicklertools“ wird in der Multifunktionsleiste angezeigt.
Abbildung 1 Aktivieren der Registerkarte „Entwicklertools“ in der Multifunktionsleiste (Klicken Sie zum Vergrößern auf das Bild)
Zeichnen Sie das Öffnen einer Datei und das Hinzufügen der Inhalte des Dokuments in einer neuen Datei auf. Klicken Sie dazu auf der Registerkarte „Entwicklertools“ auf die Schaltfläche „Makro aufzeichnen“ (siehe Abbildung 2). Geben Sie in dem Dialogfeld, das daraufhin angezeigt wird (siehe Abbildung 3), den Namen „AddFiles“ ein, und klicken Sie auf „OK“. Das Cursorsymbol ändert sich in einen Zeiger mit einer kleinen Kassette daneben.
Abbildung 2 Aufzeichnen eines Makros in der Registerkarte „Entwicklertools“ (Klicken Sie zum Vergrößern auf das Bild)
Abbildung 3 Benennen des Makros 
Öffnen Sie jetzt ganz normal eine Datei, und kopieren Sie die Inhalte des Dokuments. Erstellen Sie dann ein neues leeres Dokument, und fügen Sie den kopierten Text in das neue Dokument ein. Klicken Sie auf die Schaltfläche „Aufzeichnung beenden“. Diese wird an der Stelle auf der Registerkarte „Entwicklertools“ angezeigt, an der sich die Schaltfläche „Makro aufzeichnen“ befand. Wenn Sie fertig sind, können Sie auf die Schaltfläche „Visual Basic“ ganz links auf der Registerkarte „Entwicklertools“ klicken, um den Visual Basic-Editor (for Applications) zu starten. Sie sollten eine neue AddFiles-Funktion sehen, ähnlich wie in Abbildung 4.
Sub AddFiles()
'
' AddFiles Macro
'
'
ChangeFileOpenDirectory _
  "https://sharepoint.contoso.com/sites/sharepoint/" & _
    "Shared%20Documents/SharePoint%20Tasks/"

  Documents.Open fileName:= _
    "https://sharepoint.contoso.com/sites/SharePoint/" & _
      "Shared%20Documents/SharePoint%20Tasks/" & _ 
      "Task001%20-%20Create%20a%20Team%20Web%20Site.docx", _
    ConfirmConversions:=False, _
    ReadOnly:=False, _
    AddToRecentFiles:=False, _
    PasswordDocument:="", _
    PasswordTemplate:="", _
    Revert:=False, _
    WritePasswordDocument:="", _
    WritePasswordTemplate:="", _
    Format:= wdOpenFormatAuto, _
    XMLTransform:=""

    Selection.WholeStory
    Selection.Copy
    Documents.Add Template:="Normal", NewTemplate:=False, DocumentType:=0
    Selection.PasteAndFormat (wdPasteDefault)
End Sub

Beachten Sie, dass es eine Zeile gibt, mit der das nächste „Datei öffnen“-Verzeichnis zurückgesetzt wird. Danach sehen Sie den Befehl „Öffnen“ und dann die Befehle, mit denen der Text kopiert, ein neues Dokument erstellt und der Text in das neue Dokument eingefügt wird. Der Code, der durch die Makroaufzeichnung erstellt wurde, ist nicht perfekt, aber er ist auch nicht schlecht. Also wird er übernommen, verbessert und in VSTO platziert.

Verschieben von Makros nach VSTO
Um mit VSTO zu beginnen, wird zuerst ein Word 2007-Add-In-Projekt erstellt. Dazu wird Visual Studio geöffnet, ein neues Projekt gestartet, die Vorlage für das Word 2007 Add-In für das Projekt verwendet und das Projekt „PublishPrep“ genannt. Nach der erfolgreichen Erstellung des neuen VSTO-Projekts sollte Ihre Visual Studio 2008-Umgebung so ähnlich aussehen wie in Abbildung 5.
Abbildung 5 Neues Word-Add-In-Projekt (Klicken Sie zum Vergrößern auf das Bild)
Nun, da das Projekt erstellt ist, muss eine Möglichkeit für Benutzer geschaffen werden, auf die Funktionalität des Add-Ins zuzugreifen. Für Anwendungen in 2007 Office System bedeutet das die Erstellung einer Multifunktionsleisten-Registerkarte und von Schaltflächen. Fügen Sie Ihrem Projekt zunächst ein neues Element hinzu, und wählen Sie im Dialogfeld „Neues Element hinzufügen“ die Vorlage „Multifunktionsleiste (Visueller Designer)“ aus. Nennen Sie Ihre neue Multifunktionsleiste „PublishPrep“.
Der nächste Schritt besteht darin, die Multifunktionsleiste anzupassen. In diesem Fall erstelle ich nur eine Gruppe, die sich auf der Registerkarte „Add-Ins“ befindet, statt der Multifunktionsleiste meine eigene Registerkarte hinzuzufügen. Die Gruppe wird drei Schaltflächen umfassen.
Klicken Sie auf die Gruppe „group1“ in der Multifunktionsleiste. Klicken Sie dann mit der rechten Maustaste, und wählen Sie „Eigenschaften“ aus. Ändern Sie im Bereich „Eigenschaften“ den Namen der Gruppe in „grpPublishPrep“, und ändern Sie die Beschriftung in „Publishing Preparation“ (Veröffentlichungsvorbereitung), wie in Abbildung 6 gezeigt.
Abbildung 6 Konfigurieren der Multifunktionsleiste „PublishPrep“ (Klicken Sie zum Vergrößern auf das Bild)
Öffnen Sie die Toolbox, führen Sie einen Bildlauf zu der Gruppe „Steuerelemente für Office-Multifunktionsleisten“ durch, und ziehen Sie drei Schaltflächensteuerelemente auf die Gruppe „Publishing Preparation“. Beachten Sie, dass die Schaltflächen standardmäßig senkrecht übereinander angeordnet werden.
Klicken Sie mit der rechten Maustaste auf die erste Schaltfläche, und wählen Sie „Eigenschaften“ aus. Setzen Sie die Namenseigenschaft auf „btnCreateMaster“ und die Beschriftung auf „Create Master“ (Master erstellen). Setzen Sie den Namen für die zweite Schaltfläche auf „btnAcceptRevisions“ und die Beschriftung auf „Accept Revisions“ (Überarbeitungen annehmen). Setzen Sie schließlich für die dritte Schaltfläche die Nameneigenschaft auf „btnRemoveComments“ und die Beschriftung auf „Remove Comments“ (Kommentare entfernen). Die Gruppe sollte aussehen wie in Abbildung 7.
Abbildung 7 Für das Add-In konfigurierte Schaltflächen und Gruppe (Klicken Sie zum Vergrößern auf das Bild)

Schreiben von neuem Add-In-Code
Die Makroaufzeichnung hat das Aufzeichnen der erforderlichen Schritte zum Zusammenstellen des Buchs aus dessen einzelnen Dateien recht gut erledigt. Allerdings wurde nicht der Code aufgenommen, der zum Auswählen einzelner Dateien erforderlich ist. Zu diesem Zweck werden die Vorteile des standardmäßigen Dialogfelds „Datei öffnen“ genutzt. Den Benutzern wird ermöglicht, eine einzelne Datei auszuwählen, bei der es sich um eine Textdatei mit den Namen aller Dateien handelt, die zusammengefügt werden sollen. Es gibt zwei Hauptteile im Code. Mit dem ersten Teil wird die Datei angefügt. Mit dem zweiten Teil wird die Liste der Dateien abgerufen, die angefügt werden sollen.
Der erste Teil des Codes, eine Funktion namens „AppendFile“ (siehe Abbildung 8), übernimmt einen einzelnen Parameter, den Dateinamen. Auf den ersten Blick ähnelt der Code nicht dem Code, den die Makroaufzeichnung für mich geschrieben hat, aber das ist größtenteils eine Illusion.
void AppendFile(string file)
{
    if (string.IsNullOrEmpty(file)) return;

    Application app = Globals.ThisAddIn.Application;
    Document activeDoc = app.ActiveDocument;
    if (activeDoc == null) return;

    object fileObj = file;
    object confirmConversions = false;
    object readOnly = true;
    object addToRecentFiles = false;
    object passwordDocument = Missing.Value;
    object passwordTemplate = Missing.Value;
    object revert = true;
    object writePasswordDocument = Missing.Value;
    object writePasswordTemplate = Missing.Value;
    object format = Missing.Value;
    object encoding = Missing.Value;
    object visible = false;
    object openAndRepair = false;
    object documentDirection = Missing.Value;
    object noEncodingDialog = Missing.Value;
    object xMLTransform = Missing.Value;

    Document newDoc = app.Documents.Open(ref fileObj, 
        ref confirmConversions, ref readOnly, 
        ref addToRecentFiles, ref passwordDocument, 
        ref passwordTemplate, ref revert, 
        ref writePasswordDocument, ref writePasswordTemplate, 
        ref format, ref encoding, ref visible, 
        ref openAndRepair, ref documentDirection, 
        ref noEncodingDialog, ref xMLTransform);

    app.Selection.WholeStory();
    app.Selection.Copy();
    activeDoc.Select();
    object collapseEnd = WdCollapseDirection.wdCollapseEnd;
    app.Selection.Collapse(ref collapseEnd);
    app.Selection.Paste();

    object saveChanges = WdSaveOptions.wdDoNotSaveChanges;
    object originalFormat = WdOpenFormat.wdOpenFormatAuto;
    object routeDocument = Missing.Value;
    newDoc.Close(ref saveChanges, ref originalFormat, 
        ref routeDocument);
    object breakType = WdBreakType.wdPageBreak;
    app.Selection.InsertBreak(ref breakType);
}

Mit den ersten vier Zeilen wird lediglich das aktive Dokument abgerufen und eine Fehlerüberprüfung durchgeführt. Wenn es kein aktives Dokument gibt, können Sie nicht wirklich etwas daran anfügen, und wenn Sie keinen Namen für die anzufügende Datei haben, können Sie nicht viel mehr tun. Außerdem werden mit diesen Zeilen Verweise auf die Anwendung (die in VBA vorausgesetzt wird) und das aktive Dokument abgerufen, wenn die Schaltflächenmethode aufgerufen wurde. Die aufgezeichnete Version des Makros musste dies nicht tun.
Der nächste Satz von Zeilen, die Objektvariablendeklarationen, ist aufgrund der Art und Weise erforderlich, wie C# die COM-Komponenten aufruft, die in Word verfügbar gemacht werden. Fehlende Werte müssen angegeben werden, und da die Werte alle durch Verweise übergeben werden, wird eine Variable benötigt, um sie zu halten.
Mit dem Code wird dann der gleiche Kopiervorgang durchgeführt, der durch die Makroaufzeichnung generiert wurde. Der wirkliche Unterschied besteht darin, dass mein Add-In-Code für die Verwaltung des aktiven Dokuments verantwortlich ist, einschließlich der Sicherstellung, dass der Cursor an das Ende des aktiven Dokuments gesetzt ist.
Mit dem letzten Block des Codes wird das Dokument geschlossen, das ich geöffnet habe, und es wird sichergestellt, dass keine Änderungen gespeichert werden. Außerdem wird nach dem eingefügten Inhalt ein Seitenwechsel hinzugefügt, da sichergestellt werden soll, dass die Inhalte der einzelnen Dateien nicht zusammenlaufen.
Mit dem zweiten Teil des Codes wird die Liste der Dateien abgerufen, die zusammengefügt werden sollen, und „AppendFile“ wird aufgerufen (siehe Abbildung 9). Dies ist kein Code, der von der Makroaufzeichnung erfasst wurde. Hier sehen Sie aber die Leistungsfähigkeit von VSTO, da Sie alle .NET-Konstrukte nutzen können. In diesem Fall werden das OpenFileDialog-Steuerelement genutzt; die Möglichkeit, eine Textdatei zu öffnen und daraus zu lesen; die Verwendung von Generika zum Erstellen einer Liste von Dateien und das Aufrufen einer weiteren, kleineren Methode, die sich in der Liste wiederholt.
private void btnCreateMaster_Click(object sender, 
    RibbonControlEventArgs e)
{
    Document activeDoc = Globals.ThisAddIn.Application.ActiveDocument;
    if ((activeDoc == null)) return;
    didSelect = false;
    dlgOpenFile.DefaultExt = ".TXT";
    dlgOpenFile.FileOk += 
        new System.ComponentModel.CancelEventHandler(
        dlgOpenFile_FileOk);
    dlgOpenFile.ShowDialog();
    if ((didSelect))
    {
        string selectedFile = dlgOpenFile.FileName;
        List<string> files = new List<string>();
        using (StreamReader inFile = File.OpenText(selectedFile))
        {
            string fileLine = inFile.ReadLine();
            while (fileLine != null && !inFile.EndOfStream)
            {
                if ((fileLine.Length > 0))
                {
                    // Process non-blank lines
                    files.Add(fileLine);
                }
                fileLine = inFile.ReadLine();
            }
        }

        if ((files.Count > 0))
        {
            AppendFiles(files);
        }
    }
}

private bool didSelect = false;
void dlgOpenFile_FileOk(object sender, 
    System.ComponentModel.CancelEventArgs e)
{
    didSelect = true;
}

void AppendFiles(List<string> files)
{
    foreach (string file in files)
    {
        AppendFile(file);
    }
}

Eine ziemlich offensichtliche Frage zu der Struktur dieses Codes ist folgende: Warum plage ich mich damit herum, eine Liste der Dateien zu erstellen, wenn sie in der Datei sequenziell aufgelistet sind und es beinahe ebenso einfach wäre, AppendFile direkt in der Schleife aufzurufen, mit der die Datei gelesen wird? Dadurch soll zukünftige Flexibilität gewährleistet werden. Eine einfach zu erkennende Verbesserung an diesem Tool wäre, dem Benutzer zu ermöglichen, die anzufügenden Dateien auszuwählen, statt sie in einer Steuerungsdatei aufzulisten. Dies ist ein Aspekt, bei dem VSTO VBA überlegen ist. Da VSTO auf dem vollständigen .NET Framework erstellt ist, können Sie Features wie Generika nutzen und stark typisierte Parameter erstellen.
Es sind ein paar mehr Schritte erforderlich, um den Code nutzen zu können, den Sie gerade gesehen haben: Hinzufügen des OpenFileDialog und Hinzufügen der using-Anweisungen für alle verschiedenen Namespaces, die die Lösung erfordert. Begeben Sie sich im Entwurfsmodus für die Datei „PublishPrep.cs“ zur Toolbox, und ziehen Sie OpenFileDialog aus der Gruppe der Dialogfelder auf die Multifunktionsleiste. In Visual Studio wird OpenFileDialog an ein Dock am unteren Ende verschoben. Ändern Sie den Namen des Dialogfelds in „dlgOpenFile“, und löschen Sie dann FileName. Doppelklicken Sie auf die Schaltfläche „Create Master“, die Sie zuvor erstellt haben. Fügen Sie oben in der Datei wie folgt using-Anweisungen hinzu:
using Microsoft.Office.Interop.Word;
using System.IO;
using System.Reflection;
Ersetzen Sie schließlich den Methodenstub, der von Visual Studio mit dem Code in Abbildung 9 erstellt wurde.
Jetzt können Sie F5 drücken, und Visual Studio startet eine Kopie von Word, bei der das Add-In installiert ist. Sie können auf die Schaltfläche „Create Master“ klicken und eine Textdatei auswählen, aus der der Code die hinzuzufügenden Dateien abrufen kann. Sobald das Testen beendet ist, kann Word beendet oder in Visual Studio auf Umschalt+F5 gedrückt werden, um das Debuggen zu beenden.

Weitere Schaltflächen
Die meisten schwierigen Aufgaben sind abgeschlossen. Jetzt ist es an der Zeit, rasch den Code für die Schaltfläche „Accept Revisions“ hinzuzufügen. Sie können zu der Registerkarte „Entwicklertools“ in der Multifunktionsleiste von Word zurückkehren und die Makroaufzeichnung wieder starten, um den Schritt des Annehmens aller Überarbeitungen aufzuzeichnen. Die eigentliche Aufgabe wird erledigt, indem Sie die Registerkarte „Überprüfen“ aufrufen, auf die Schaltfläche „Annehmen“ klicken und anschließend auf „Alle Änderungen im Dokument annehmen“ (siehe Abbildung 10). Dadurch sieht das aufgezeichnete Makro in etwa so aus:
Abbildung 10 Aktivieren der Registerkarte „Entwicklertools“ in der Multifunktionsleiste (Klicken Sie zum Vergrößern auf das Bild)
Sub AcceptAllChanges()
'
' AcceptAllChanges Macro
'
    WordBasic.AcceptAllChangesInDoc
End Sub
Die Makroaufzeichnung hat aufgezeichnet, dass bei dieser Aktion das WordBasic-Objekt verwendet wird. Das WordBasic-Objekt ist ein Überbleibsel aus der Zeit, als Word-Makros noch nicht VBA verwendeten. Es ist nicht die beste Möglichkeit, sich dem Problem zu nähern. Es ist viel besser, ActiveDocument zu verwenden. Sie können entweder die AcceptAllRevisions-Methode oder die AcceptAll-Methode der Überarbeitungseigenschaft einsetzen. Ich gebe der Namensgebung „Revisions.AcceptAll“ einen leichten Vorzug, aber beide Methoden funktionieren.
Hier ist der Code, der erforderlich ist, um Überarbeitungen im VSTO-Code zu akzeptieren:
private void btnAcceptRevisions_Click(
    object sender, RibbonControlEventArgs e)
{
    Application app = Globals.ThisAddIn.Application;
    Document activeDoc = app.ActiveDocument;
    if (activeDoc == null) return;

    // Accept all Changes
    activeDoc.Revisions.AcceptAll();
}
Die Methode könnte aus einer Zeile bestehen. Es ist aber eine gute Idee, auf ein aktives Dokument zu prüfen und eingreifende Variable bereitzustellen, sollten Sie debuggen müssen. Um diesen Code einzufügen, öffnen Sie PublishPrep.cs einfach im Entwurfsmodus in Visual Studio. Doppelklicken Sie auf die Schaltfläche „Accept Revisions“, und ersetzen Sie dann den Methodenprototyp „btnAcceptRevisions_Click“, der in Visual Studio mit diesem neuen Code hinzugefügt wurde. Drücken Sie F5, um mit dem Debuggen zu beginnen, und navigieren Sie zur Registerkarte „Add-Ins“. Sie sollten auf die Schaltfläche klicken können, sodass alle Überarbeitungen im Dokument akzeptiert werden.
Die Schaltfläche „Remove Comments“ ist ein bisschen schwieriger, da es sich dabei um etwas handelt, das die Makroaufzeichnung nicht für Sie aufzeichnen wird. Wenn ich die Makroaufzeichnung starte und dann versuche, mit der rechten Maustaste auf einen Kommentar zu klicken, um die Löschoption auszuwählen, funktioniert das einfach nicht. Das bedeutet, dass kein Kommentar zum Entfernen ausgewählt werden kann. Darum muss ich meinen eigenen Code für VSTO ganz neu schreiben. Glücklicherweise ist der Code nicht sehr schwierig.
Es ist bereits ein Verweis auf das aktive Dokument in Word vorhanden. Dieses Objekt verfügt über eine Eigenschaft zum Sammeln von Kommentaren. Aus dieser Sammlung kann so lange der erste Kommentar gelöscht werden, bis keine Kommentare mehr vorhanden sind:
private void btnRemoveComments_Click(
    object sender, RibbonControlEventArgs e)
{
    Application app = Globals.ThisAddIn.Application;
    Document activeDoc = app.ActiveDocument;
    if ((activeDoc == null)) return;
    // Clear Comments
    while ((activeDoc.Comments.Count > 0))
    {
        app.Selection.Comments[1].Delete();
    }

}
Es ist bemerkenswert, dass die Indexerstellung hier auf 1 basiert und nicht auf null, wie das in C# zu erwarten wäre.
Das Hinzufügen dieses Features zur Lösung ist ebenso einfach wie das Doppelklicken auf die Schaltfläche „Remove Comments“ und das Ersetzen des Methodenprototyps „btnRemoveComments_Click“, der in Visual Studio mit dem soeben gezeigten Code hinzugefügt wurde.
Jetzt können Sie erneut F5 drücken und alle Aufgaben abschließen, die zu erledigen sind: Kompilieren von Dateien, Annehmen von Überarbeitungen und Entfernen von Kommentaren. Dies ist keine welterschütternde Funktionalität. Anhand des vollständigen Add-Ins wird aber sehr schön veranschaulicht, wie mit der Makroaufzeichnung schnell ein wenig Prototyp-VBA-Code generiert werden kann, der Sie beim Schreiben umfassenderer und ausgereifterer Lösungen in Visual Basic oder C# mit VSTO auf den richtigen Weg bringen kann. Mit der Makroaufzeichnung konnte nicht jedes Szenario bewältigt werden, aber die Aufgaben, die es unterstützt, sind viel einfacher zu lösen.

Senden Sie Ihre Fragen und Kommentare (in englischer Sprache) an mmoffice@microsoft.com.


Robert Bogue, Microsoft MVP für Microsoft Office SharePoint Server, MCSE und MCSA für Sicherheit, hat an mehr als 100 Buchprojekten und zahlreichen anderen Publikationen mitgearbeitet. Robert führt einen Blog unter www.thorprojects.com/blog und ist unter Rob.Bogue@thorprojects.com zu erreichen. Weitere Informationen zu seinem aktuellen Buchprojekt, The SharePoint Shepherd's Guide for End Users, finden Sie unter sharepointshepherd.com.

Page view tracker