Freigeben über


Exemplarische Vorgehensweise: Aufrufen von Code in einem Add-In auf Anwendungsebene von VBA

Aktualisiert: November 2007

Betrifft

Die Informationen in diesem Thema gelten nur für die angegebenen Projekte und Versionen von Visual Studio Tools for Office von Microsoft Office.

Projekttyp

  • Projekte auf Anwendungsebene

Microsoft Office-Version

  • 2007 Microsoft Office System

  • Microsoft Office 2003

Weitere Informationen hierzu finden Sie unter Verfügbare Features nach Anwendung und Projekttyp.

Diese exemplarische Vorgehensweise veranschaulicht, wie ein Objekt in einem Add-In auf Anwendungsebene für andere Microsoft Office-Projektmappen einschließlich VBA (Visual Basic for Applications)- und COM-Add-Ins verfügbar gemacht wird.

Obwohl in dieser exemplarischen Vorgehensweise speziell Excel verwendet wird, gelten die Konzepte in dieser exemplarischen Vorgehensweise für alle von Visual Studio Tools for Office bereitgestellten Add-In-Projekte.

In dieser exemplarischen Vorgehensweise werden die folgenden Aufgaben veranschaulicht:

  • Definieren einer Klasse, die für andere Office-Projektmappen verfügbar gemacht werden kann

  • Verfügbarmachen der Klasse für andere Office-Projektmappen

  • Aufrufen einer Methode der Klasse von VBA-Code

Hinweis:

Ihr Computer zeigt möglicherweise für einige der Elemente der Visual Studio-Benutzeroberfläche in der folgenden Anleitung andere Namen oder Standorte an. Diese Elemente sind von der jeweiligen Visual Studio-Version und den verwendeten Einstellungen abhängig. Weitere Informationen finden Sie unter Visual Studio-Einstellungen.

Vorbereitungsmaßnahmen

Zum Durchführen dieser exemplarischen Vorgehensweise benötigen Sie die folgenden Komponenten:

  • Visual Studio Tools for Office (eine optionale Komponente von Visual Studio 2008 Professional und Visual Studio Team System).

  • Microsoft Office Excel 2007.

    Hinweis:

    Sie können diese exemplarische Vorgehensweise auch mit Microsoft Office Excel 2003 ausführen. Bei einigen der Anweisungen wird allerdings davon ausgegangen, dass Sie die Multifunktionsleiste in Excel 2007 verwenden.

Visual Studio Tools for Office wird standardmäßig mit den aufgeführten Versionen von Visual Studio installiert. Wie Sie überprüfen können, ob die Software installiert ist, erfahren Sie in Installieren von Visual Studio Tools for Office.

Eine Videodemonstration finden Sie unter in-Gewusst wie: Aufrufen von Code in einem Add-In auf Anwendungsebene von VBA.

Erstellen des Add-In-Projekts

Im ersten Schritt erstellen Sie ein Add-In-Projekt für Excel.

So erstellen Sie ein neues Projekt

  • Erstellen Sie ein Excel-Add-In-Projekt mit dem Namen ExcelImportData unter Verwendung der Excel-Add-In-Projektvorlage für 2007 Microsoft Office System. Weitere Informationen finden Sie unter Gewusst wie: Erstellen von Visual Studio Tools for Office-Projekte.

    Visual Studio öffnet die Codedatei ThisAddIn.cs oder ThisAddIn.vb und fügt dem Projektmappen-Explorer das Projekt ExcelImportData hinzu.

Definieren einer Klasse, die für andere Office-Projektmappen verfügbar gemacht werden kann

Das Ziel dieser exemplarischen Vorgehensweise besteht darin, einen Aufruf in die ImportData-Methode einer Klasse namens AddInUtilities in Ihrem Add-In von VBA-Code auszuführen. Mit dieser Methode werden Daten in ein neues Arbeitsblatt in der aktiven Arbeitsmappe importiert, und es wird ein einfaches DataSet-Element für die Aufnahme der Daten erstellt.

Um die AddInUtilities-Klasse für andere Office-Projektmappen verfügbar zu machen, müssen Sie die Klasse öffentlich und für COM sichtbar machen. Außerdem müssen Sie eine Möglichkeit bieten, die IDispatch-Schnittstelle in der Klasse verfügbar zu machen. Im Code in der folgenden Prozedur wird eine Möglichkeit veranschaulicht, diese Anforderungen zu erfüllen. Weitere Informationen finden Sie unter Aufrufen von Code in Add-Ins auf Anwendungsebene von anderen Office-Projektmappen.

So definieren Sie eine Klasse, die Sie für andere Office-Projektmappen verfügbar machen können

  1. Klicken Sie im Menü Projekt auf Klasse hinzufügen.

  2. Ändern Sie im Dialogfeld Neues Element hinzufügen den Namen der neuen Klasse in AddInUtilities, und klicken Sie auf Hinzufügen.

    Die Datei AddInUtilities.cs oder AddInUtilities.vb wird im Code-Editor geöffnet.

  3. Fügen Sie am Anfang der Datei die folgenden Anweisungen ein.

    Imports System.Data
    Imports System.Runtime.InteropServices
    Imports Excel = Microsoft.Office.Interop.Excel
    
    using System.Data;
    using System.Runtime.InteropServices;
    using Excel = Microsoft.Office.Interop.Excel;
    
  4. Ersetzen Sie die leere AddInUtilities-Klassendeklaration durch den folgenden Code.

    Dieser Code macht die AddInUtilities-Klasse für COM sichtbar und fügt die ImportData-Methode zur Klasse hinzu. Um die IDispatch-Schnittstelle verfügbar zu machen, implementiert die AddInUtilities-Klasse außerdem eine Schnittstelle, die über das InterfaceIsIDispatch-Attribut verfügt.

    <System.Runtime.InteropServices.ComVisibleAttribute(True)> _
    <System.Runtime.InteropServices.InterfaceType(ComInterfaceType.InterfaceIsIDispatch)> _
    Public Interface IAddInUtilities
        Sub ImportData()
    End Interface
    
    <System.Runtime.InteropServices.ComVisibleAttribute(True)> _
    <System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)> _
    Public Class AddInUtilities
        Implements IAddInUtilities
    
        Public Sub ImportData() Implements IAddInUtilities.ImportData
    
            ' Create a new DataTable.
            Dim ds As New DataSet()
            Dim dt As DataTable = ds.Tables.Add("Customers")
            dt.Columns.Add(New DataColumn("LastName"))
            dt.Columns.Add(New DataColumn("FirstName"))
    
            ' Add a new row to the DataTable.
            Dim dr As DataRow = dt.NewRow()
            dr("LastName") = "Chan"
            dr("FirstName") = "Gareth"
            dt.Rows.Add(dr)
    
            ' Add a new XML map to the collection.
            Dim activeWorkbook As Excel.Workbook = Globals.ThisAddIn.Application.ActiveWorkbook
            Dim xmlMap1 As Excel.XmlMap = activeWorkbook.XmlMaps.Add(ds.GetXmlSchema(), _
                "NewDataSet")
    
            ' Import the data.
            If Not (xmlMap1 Is Nothing) Then
                Dim lastSheet As Object = activeWorkbook.Sheets(activeWorkbook.Sheets.Count)
                Dim newSheet As Excel.Worksheet = CType(activeWorkbook.Sheets.Add( _
                    After:=lastSheet), Excel.Worksheet)
                newSheet.Name = "Imported Data"
                activeWorkbook.XmlImportXml(ds.GetXml(), xmlMap1, True, _
                    newSheet.Range("A1"))
            End If
        End Sub
    End Class
    
    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
    [System.Runtime.InteropServices.InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    public interface IAddInUtilities
    {
        void ImportData();
    }
    
    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
    [System.Runtime.InteropServices.ClassInterface(ClassInterfaceType.None)]
    public class AddInUtilities : IAddInUtilities
    {
        public void ImportData()
        {
            // Create a new DataTable.
            DataSet ds = new DataSet();
            DataTable dt = ds.Tables.Add("Customers");
            dt.Columns.Add(new DataColumn("LastName"));
            dt.Columns.Add(new DataColumn("FirstName"));
    
            // Add a new row to the DataTable.
            DataRow dr = dt.NewRow();
            dr["LastName"] = "Chan";
            dr["FirstName"] = "Gareth";
            dt.Rows.Add(dr);
    
            // Add a new XML map to the collection.
            Excel.Workbook activeWorkbook = Globals.ThisAddIn.Application.ActiveWorkbook;
            Excel.XmlMap xmlMap1 = activeWorkbook.XmlMaps.Add(ds.GetXmlSchema(), 
                "NewDataSet");
    
            // Import the data.
            if (xmlMap1 != null)
            {
                object lastSheet = activeWorkbook.Sheets[activeWorkbook.Sheets.Count];
                Excel.Worksheet newSheet = (Excel.Worksheet)activeWorkbook.Sheets.Add(
                    System.Type.Missing, lastSheet, 1, System.Type.Missing);
                newSheet.Name = "Imported Data";
    
                activeWorkbook.XmlImportXml(ds.GetXml(), out xmlMap1, true,
                    newSheet.get_Range("A1", System.Type.Missing));
            }
        }
    }
    

Verfügbarmachen der Klasse für andere Office-Projektmappen

Um die AddInUtilities-Klasse für andere Office-Projektmappen verfügbar zu machen, überschreiben Sie die RequestComAddInAutomationService-Methode in der ThisAddIn-Klasse. Geben Sie in der Überschreibung eine Instanz der AddInUtilities-Klasse zurück.

So machen Sie die AddInUtilities-Klasse für andere Office-Projektmappen verfügbar

  1. Erweitern Sie im Projektmappen-Explorer die Option Excel.

  2. Klicken Sie mit der rechten Maustaste auf ThisAddIn.cs oder ThisAddIn.vb, und klicken Sie dann auf Code anzeigen.

  3. Fügen Sie der ThisAddIn-Klasse folgenden Code hinzu.

    Private utilities As AddInUtilities
    
    Protected Overrides Function RequestComAddInAutomationService() As Object
        If utilities Is Nothing Then
            utilities = New AddInUtilities()
        End If
        Return utilities
    End Function
    
    private AddInUtilities utilities;
    
    protected override object RequestComAddInAutomationService()
    {
        if (utilities == null)
            utilities = new AddInUtilities();
    
        return utilities;
    }
    
  4. Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

    Überprüfen Sie, ob sich die Projektmappe fehlerfrei erstellen lässt.

Testen des Add-Ins

Sie können einen Aufruf in die AddInUtilities-Klasse von verschiedenen Typen von Office-Projektmappen durchführen. In dieser exemplarischen Vorgehensweise verwenden Sie VBA-Code in einer Excel-Arbeitsmappe. Weitere Informationen über die anderen Typen von Office-Projektmappen, die Sie ebenfalls verwenden können, finden Sie unter Aufrufen von Code in Add-Ins auf Anwendungsebene von anderen Office-Projektmappen.

So testen Sie das Add-In

  1. Drücken Sie F5, um das Projekt auszuführen.

  2. Speichern Sie in Excel die aktive Arbeitsmappe als Excel-Arbeitsmappe mit Makros (* .xlsm). Speichern Sie sie an einem geeigneten Speicherort, z. B. auf dem Desktop.

  3. Klicken Sie in der Multifunktionsleiste auf die Registerkarte Entwickler.

    Hinweis:

    Wenn die Registerkarte Entwickler nicht sichtbar ist, müssen Sie diese zuerst anzeigen. Weitere Informationen finden Sie unter Gewusst wie: Anzeigen der Registerkarte "Entwickler" auf der Multifunktionsleiste.

  4. Klicken Sie in der Gruppe Code auf Visual Basic.

    Der Visual Basic-Editor wird geöffnet.

  5. Doppelklicken Sie im Fenster Projekt auf ThisWorkbook.

    Die Codedatei für das ThisWorkbook-Objekt wird geöffnet.

  6. Fügen Sie der Codedatei den folgenden VBA-Code hinzu. Dieser Code ruft zunächst ein COMAddIn-Objekt ab, das das ExcelImportData-Add-In darstellt. Anschließend verwendet der Code die Object-Eigenschaft des COMAddIn-Objekts zum Aufrufen der ImportData-Methode.

    Sub CallVSTOMethod()
        Dim addIn As COMAddIn
        Dim automationbject As Object
        Set addIn = Application.COMAddIns("ExcelImportData")
        Set automationObject = addIn.Object
        automationObject.ImportData
    End Sub
    
  7. Drücken Sie F5.

  8. Vergewissern Sie sich, dass der Arbeitsmappe ein neues Imported Data-Blatt hinzugefügt wurde. Stellen Sie außerdem sicher, dass die Zelle A1 die Zeichenfolge Chan und die Zelle B1 die Zeichenfolge Gareth enthält.

  9. Beenden Sie Excel.

Nächste Schritte

Mehr über die Programmierung von Add-Ins erfahren Sie in den folgenden Themen:

Siehe auch

Aufgaben

Gewusst wie: Erstellen von Visual Studio Tools for Office-Projekte

Konzepte

Programmieren von Add-Ins auf Anwendungsebene

Aufrufen von Code in Add-Ins auf Anwendungsebene von anderen Office-Projektmappen

Entwickeln von Office-Projektmappen

AddIn-Hostelement

Anpassen von Features der Benutzeroberfläche mithilfe von Erweiterungsschnittstellen

Architektur von Add-Ins auf Anwendungsebene