Markieren Sie das Kontrollkästchen Englisch, um die englische Version dieses Artikels anzuzeigen. Sie können den englischen Text auch in einem Popup-Fenster einblenden, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch
Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

Exemplarische Vorgehensweise: Aktualisieren der Steuerelemente in einer Multifunktionsleiste zur Laufzeit

 

Diese exemplarische Vorgehensweise veranschaulicht das Verwenden des Menüband-Objektmodells zum Aktualisieren der Steuerelemente auf einem Menüband, nachdem das Menüband in die Office-Anwendung geladen wurde.

Betrifft: Die Informationen in diesem Thema betreffen Projekte auf Dokumentebene und VSTO-Add-In-Projekte für die folgenden Anwendungen: Excel, InfoPath 2013 und InfoPath 2010, Outlook, PowerPoint, Project, Visio und Word. Weitere Informationen finden Sie unter Verfügbare Funktionen nach Office-Anwendung und Projekttyp.

Das Beispiel ruft Daten aus der Beispieldatenbank "Northwind" ab, um ein Kombinationsfeld und ein Menü in Microsoft Office Outlook mit Daten aufzufüllen. Elemente, die Sie in diesen Steuerelementen auswählen, füllen Felder wie z. B. An und Betreff in einer E-Mail-Nachricht automatisch mit Daten auf.

In dieser exemplarischen Vorgehensweise werden die folgenden Aufgaben veranschaulicht:

  • Erstellen eines neuen Outlook VSTO-Add-In-Projekts.

  • Entwerfen einer benutzerdefinierten Menübandgruppe.

  • Hinzufügen der benutzerdefinierten Gruppe zu einer integrierten Registerkarte.

  • Aktualisieren von Steuerelementen auf dem Menüband zur Laufzeit.

System_CAPS_noteHinweis

Auf Ihrem Computer werden möglicherweise andere Namen oder Speicherorte für die Benutzeroberflächenelemente von Visual Studio angezeigt als die in den folgenden Anweisungen aufgeführten. Diese Elemente sind von der jeweiligen Visual Studio-Version und den verwendeten Einstellungen abhängig. Weitere Informationen finden Sie unter Customizing Development Settings in Visual Studio.

Vorbereitungsmaßnahmen

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

Erstellen Sie zunächst ein neues Outlook VSTO-Add-In-Projekt.

So erstellen Sie ein neues Outlook VSTO-Add-In-Projekt

  1. Erstellen Sie in Visual Studio ein Outlook VSTO-Add-In-Projekt mit dem Namen "Ribbon_Update_At_Runtime".

  2. Wählen Sie im Dialogfeld Neues Projekt die Option Projektmappenverzeichnis erstellen.

  3. Speichern Sie das Projekt im Standardprojektverzeichnis.

    Weitere Informationen finden Sie unter Gewusst wie: Erstellen von Office-Projekten in Visual Studio.

Das Menüband für dieses Beispiel wird angezeigt, wenn ein Benutzer eine neue E-Mail-Nachricht verfasst. Um eine benutzerdefinierte Gruppe für das Menüband zu erstellen, fügen Sie dem Projekt zuerst Sie ein Menübandelement hinzu, und entwerfen Sie dann die Gruppe im Menüband-Designer. Diese benutzerdefinierte Gruppe unterstützt Sie beim Generieren von Nachverfolgungs-Mail-Nachrichten, indem Namen und Auftragsverläufe aus einer Datenbank abgerufen werden.

So entwerfen Sie eine benutzerdefinierte Gruppe

  1. Klicken Sie im Menü Projekt auf Neues Element hinzufügen.

  2. Wählen Sie im Dialogfeld Neues Element hinzufügen die Option Menüband (Visueller Designer) aus.

  3. Ändern Sie den Namen des neuen Menübands in CustomerRibbon, und klicken Sie dann auf Hinzufügen.

    Die Datei CustomerRibbon.cs oder CustomerRibbon.vb wird im Menüband-Designer geöffnet. Sie beinhaltet eine Standardregisterkarte und eine Gruppe.

  4. Klicken Sie auf den Menüband-Designer, um diese auszuwählen.

  5. Klicken Sie im FensterEigenschaften auf den Dropdownpfeil neben der Eigenschaft RibbonType, und klicken Sie dann auf Microsoft.Outlook.Mail.Compose.

    Auf diese Weise wird das Menüband angezeigt, wenn der Benutzer eine neue E-Mail-Nachricht in Outlook verfasst.

  6. Klicken Sie auf den Menüband-Designer auf Group1, um diese auszuwählen.

  7. Legen Sie im Fenster Eigenschaften die Eigenschaft Name auf den Wert "Kundenbestellungen" fest.

  8. Ziehen Sie aus der Registerkarte Steuerelemente für Office-Menübänder der Toolbox ein ComboBox-Element in die Gruppe Kundenbestellungen.

  9. Klicken Sie auf ComboBox1, um diese Option auszuwählen.

  10. Legen Sie im Fenster Eigenschaften die Eigenschaft Label auf "Kunden" fest.

  11. Ziehen Sie aus der Registerkarte Steuerelemente für Office-Menübänder der Toolbox ein Menü-Element in die Gruppe Kundenbestellungen.

  12. Legen Sie im Fenster Eigenschaften die Eigenschaft Label auf "Gekauftes Produkt" fest.

  13. Legen Sie Dynamisch auf true fest.

    Auf diese Weise können Schaltflächen für das Menü während der Laufzeit hinzugefügt und entfernt werden, nachdem das Menüband in die Office-Anwendung geladen wurde.

Eine integrierte Registerkarte ist eine Registerkarte, die sich bereits auf dem Menüband einer Outlook Explorer- oder Inspector-Anwendung befindet. In diesem Verfahren fügen Sie die benutzerdefinierte Gruppe einer integrierten Registerkarte hinzu und geben dann die Position der benutzerdefinierten Gruppe auf der Registerkarte an.

So fügen Sie die benutzerdefinierte Gruppe einer integrierten Registerkarte hinzu

  1. Klicken Sie auf die Registerkarte TabAddins (integriert), um diese auszuwählen.

  2. Erweitern Sie im Fenster Eigenschaften die Eigenschaft ControlId, und legen Sie dann OfficeId auf "TabNewMailMessage" fest.

    Auf diese Weise wird die Gruppe Kundenbestellungen der Registerkarte Nachrichten des Menübands hinzugefügt, die in einer neuen E-Mail-Nachricht angezeigt wird.

  3. Klicken Sie auf Gruppe Kundenbestellungen, um diese auszuwählen.

  4. Erweitern Sie im Fenster Eigenschaften die Eigenschaft Position, klicken Sie auf den Dropdownpfeil neben der Eigenschaft PositionType, und klicken Sie dann auf BeforeOfficeId.

  5. Legen Sie die Eigenschaft OfficeId auf "GroupClipboard" fest.

    Dies positioniert die Gruppe Kundenbestellungen vor der Gruppe Zwischenablage der Registerkarte Nachrichten.

Verwenden das Fenster Datenquellen, um dem Projekt ein typisiertes Dataset hinzuzufügen.

So erstellen Sie die Datenquelle

  1. Klicken Sie im Menü Daten auf Neue Datenquelle hinzufügen.

    Der Assistent zum Konfigurieren von Datenquellen wird gestartet.

  2. Wählen Sie Datenbank aus, und klicken Sie dann auf Weiter.

  3. Wählen Sie Dataset aus, und klicken Sie dann auf Weiter.

  4. Wählen Sie eine Datenverbindung mit der Microsoft SQL Server Compact 4.0-Beispieldatenbank "Northwind" aus, oder fügen Sie eine neue Verbindung mithilfe der Schaltfläche Neue Verbindung hinzu.

  5. Nachdem eine Verbindung ausgewählt oder erstellt wurde, klicken Sie auf Weiter.

  6. Klicken Sie auf Weiter, um die Verbindungszeichenfolge zu speichern.

  7. Erweitern Sie auf der Seite Datenbankobjekte auswählen den Knoten Tabellen.

  8. Aktivieren Sie das Kontrollkästchen neben jeder der folgenden Tabellen:

    1. Kunden

    2. Auftragsdetails

    3. Aufträge

    4. Produkte

  9. Klicken Sie auf Fertig stellen.

Verwenden Sie Menüband-Objektmodell, um die folgenden Aufgaben auszuführen:

  • Hinzufügen von Kundennamen zum Kombinationsfeld Kunden.

  • Hinzufügen von Menüs und Schaltflächen-Steuerelementen zum Menü Gekaufte Produkte, das Bestellungen und Produkte darstellt.

  • Auffüllen der Felder To, Subject und Body neuer E-Mail-Nachrichten mithilfe von Daten aus dem Kombinationsfeld Kunden und dem Menü Gekaufte Produkte.

So aktualisieren Sie Steuerelemente in der benutzerdefinierten Gruppe mithilfe des Menüband-Objektmodells

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

  2. Klicken Sie im Dialogfeld Verweis hinzufügen auf die Registerkarte .NET, wählen Sie die Assembly System.Data.Linq aus, und klicken Sie dann auf OK.

    Diese Assembly enthält Klassen für die Verwendung von LINQ (Language-Integrated Queries). Sie verwenden LINQ zum Auffüllen der Steuerelemente in der benutzerdefinierten Gruppe mit Daten aus der Datenbank "Northwind".

  3. Klicken Sie im Projektmappen-Explorer auf CustomerRibbon.cs oder CustomerRibbon.vb, um die Datei auszuwählen.

  4. Klicken Sie im Menü Ansicht auf Code.

    Die Menüband-Codedatei wird im Code-Editor geöffnet.

  5. Fügen Sie am Anfang der Menüband-Codedatei die folgenden Anweisungen hinzu. Diese Anweisungen ermöglichen den einfachen Zugriff auf LINQ-Namespaces und den Namespace der primären Interopassembly (PIA) von Outlook.

    using System.Data.Linq;
    using System.Data.Linq.Mapping;
    using System.Linq.Expressions;
    using Outlook = Microsoft.Office.Interop.Outlook;
    using System.Data;
    using System.IO;
    using Ribbon_Update_At_Runtime.Northwind40DataSetTableAdapters;
    
  6. Fügen Sie den folgenden Code in der Klasse "CustomerRibbon" hinzu. Dieser Code deklariert die Datentabelle und die Tabellenadapter, die Sie zum Speichern von Informationen aus den Kunden-, Bestellungen-, Bestelldetails- und Produkttabellen der Datenbank "Northwind" verwenden.

    //Declare the Northwind dataset.
    Northwind40DataSet nwDataSet = new Northwind40DataSet();
    
    //Declare the data tables.
    
    Northwind40DataSet.CustomersDataTable customerTable;
    Northwind40DataSet.OrdersDataTable orderTable;
    Northwind40DataSet.Order_DetailsDataTable orderDetailsTable;
    Northwind40DataSet.ProductsDataTable productsTable;
    
    //Declare the data table adapters for each table.
    
    CustomersTableAdapter customerTableAdapter = new CustomersTableAdapter();
    OrdersTableAdapter ordersTableAdapter = new OrdersTableAdapter();
    Order_DetailsTableAdapter detailsTableAdapter = new Order_DetailsTableAdapter();
    ProductsTableAdapter productsTableAdapter = new ProductsTableAdapter();
    
  7. Fügen Sie der Klasse CustomerRibbon den folgenden Codeblock hinzu. Dieser Code fügt drei Hilfsmethoden hinzu, die zur Laufzeit Steuerelemente für das Menüband erstellen.

    private RibbonDropDownItem CreateRibbonDropDownItem()
    {
        return this.Factory.CreateRibbonDropDownItem();
    }
    private RibbonMenu CreateRibbonMenu()
    {
        return this.Factory.CreateRibbonMenu();
    }
    private RibbonButton CreateRibbonButton()
    {
        RibbonButton button = this.Factory.CreateRibbonButton();
        button.Click += new RibbonControlEventHandler(button_Click);
        return button;
    }
    
  8. Ersetzen Sie die CustomerRibbon_Load-Ereignishandlermethode durch den folgenden Code. Dieser Code verwendet eine LINQ-Abfrage, um die folgenden Aufgaben auszuführen:

    • Auffüllen des Kombinationsfelds Kunden mithilfe der ID und dem Namen von 20 Kunden in der Datenbank "Northwind".

    • Aufrufen der Hilfsmethode PopulateSalesOrderInfo. Diese Methode aktualisiert das Menü ProductsPurchased mit Bestellnummern, die den zurzeit ausgewählten Kunden betreffen.

    private void CustomerRibbon_Load(object sender, RibbonUIEventArgs e)
    {
        customerTable = nwDataSet.Customers;
        customerTableAdapter.Fill(customerTable);
    
        var customerQuery = from customers in customerTable.AsEnumerable().Take(20)
                            select new
                            {
                                CustomerID = customers.Field<string>("Customer ID"),
                                CustomerName = customers.Field<string>("Contact Name")
                            };
    
    
        // Execute the query.
        foreach (var item in customerQuery)
        {
            this.comboBox1.Items.Add(CreateRibbonDropDownItem());
            this.comboBox1.Items.Last().Label =
            item.CustomerName + "|" + item.CustomerID.ToString();
        }
        this.comboBox1.Text = this.comboBox1.Items.First().Label;
        PopulateSalesOrderInfo();
    }
    
  9. Fügen Sie der CustomerRibbon-Klasse folgenden Code hinzu. Dieser Code verwendet LINQ-Abfragen, um die folgenden Aufgaben auszuführen:

    • Hinzufügen eines Untermenüs zum Menü ProductsPurchased für jede Bestellung, die sich auf den ausgewählten Kunden bezieht.

    • Hinzufügen von Schaltflächen zu jedem Untermenü für die Produkte, die sich auf die Bestellung beziehen.

    • Hinzufügen von Ereignishandlern zu jeder Schaltfläche.

    private void PopulateSalesOrderInfo()
    {
        String[] tempArray = comboBox1.Text.Split(new Char[] { '|' });
        menu1.Items.Clear();
    
        orderTable = nwDataSet.Orders;
        orderDetailsTable = nwDataSet.Order_Details;
        productsTable = nwDataSet.Products;
    
        ordersTableAdapter.Fill(orderTable);
        detailsTableAdapter.Fill(orderDetailsTable);
        productsTableAdapter.Fill(productsTable);
    
        var orderQuery = from orders in orderTable.AsEnumerable()
                         where orders.Field<string>("Customer ID") == tempArray[1]
                         select new { OrderID = orders.Field<int>("Order ID") };
    
        foreach (var orderItem in orderQuery)
        {
            menu1.Items.Add(CreateRibbonMenu());
    
            RibbonMenu orderMenu = (RibbonMenu)menu1.Items.Last();
            orderMenu.Dynamic = true;
            orderMenu.Label = orderItem.OrderID.ToString();
            orderMenu.Tag = orderItem.OrderID;
    
            var productQuery = from orderDetail in orderDetailsTable.AsEnumerable()
                               join product in productsTable.AsEnumerable() on
                                   orderDetail.Field<int>("Product ID")
                               equals product.Field<int>("Product ID")
                               where orderDetail.Field<int>("Order ID") ==
                                   orderItem.OrderID
                               select new { ProductName = product.Field<string>("Product Name") };
    
            foreach (var productItem in productQuery)
            {
                RibbonButton button = CreateRibbonButton();
                button.Label = productItem.ProductName;
                orderMenu.Items.Add(button);
            }
        }
    }
    
  10. Doppelklicken Sie im Projektmappen-Explorer auf die Menüband-Codedatei.

    Der Menüband-Designer wird geöffnet.

  11. Doppelklicken Sie im Menüband-Designer auf das Kombinationsfeld Kunden.

    Die Menüband-Codedatei wird im Code-Editor geöffnet, und der ComboBox1_TextChanged-Ereignishandler wird angezeigt.

  12. Ersetzen Sie den ComboBox1_TextChanged-Ereignishandler durch den folgenden Code. Mit diesem Code werden die folgenden Aufgaben ausgeführt:

    • Aufrufen der Hilfsmethode PopulateSalesOrderInfo. Diese Methode aktualisiert das Menü Gekaufte Produkte mit Bestellungen, die den zurzeit ausgewählten Kunden betreffen.

    • Aufrufen der Hilfsmethode PopulateMailItem und Übergeben des aktuellen Texts, der den Namen des ausgewählten Kunden darstellt. Diese Methode füllt die Felder To, Subject und Body neuer E-Mail-Nachrichten mit Daten auf.

    private void comboBox1_TextChanged(object sender,
        RibbonControlEventArgs e)
    {
        PopulateSalesOrderInfo();
        PopulateMailItem(comboBox1.Text);
    }
    
  13. Hinzufügen des folgenden Click-Ereignishandlers zur Klasse CustomerRibbon. Dieser Code fügt den Namen ausgewählter Produkte dem Feld Body neuer E-Mail-Nachrichten hinzu.

    void button_Click(object sender, RibbonControlEventArgs e)
    {
        Outlook.Application application = Globals.ThisAddIn.Application;
        Outlook.Inspector inspector = application.ActiveInspector();
        Outlook.MailItem myMailItem = (Outlook.MailItem)inspector.CurrentItem;
        RibbonButton myCheckBox = (RibbonButton)sender;
        myMailItem.Subject = "Following up on your order";
        myMailItem.Body = myMailItem.Body + "\n" + "* " + myCheckBox.Label;
    }
    
  14. Fügen Sie der CustomerRibbon-Klasse folgenden Code hinzu. Mit diesem Code werden die folgenden Aufgaben ausgeführt:

    • Auffüllen der Zeile To neuer E-Mail-Nachrichten mithilfe der E-Mail-Adresse des aktuell ausgewählten Kunden.

    • Hinzufügen von Text zu den Feldern Subject und Body neuer E-Mail-Nachrichten.

    private void PopulateMailItem(string addressToLine)
    {
        Outlook.Application application = Globals.ThisAddIn.Application;
        Outlook.Inspector inspector = application.ActiveInspector();
        Outlook.MailItem myMailItem = (Outlook.MailItem)inspector.CurrentItem;
    
        myMailItem.To = "";
        String[] tempArray = addressToLine.Split(new Char[] { '|' });
        myMailItem.To = tempArray[0] + "@example.com";
        myMailItem.Subject = "Following up on your order";
        myMailItem.Body = "Hello " + tempArray[0] + "," +
            "\n" + "We would like to get your feedback on the " +
            "following products that you recently ordered: ";
    }
    

Wenn Sie ein neues E-Mail-Formular in Outlook öffnen, wird eine benutzerdefinierte Gruppe mit dem Namen Kundenbestellungen auf der Registerkarte Nachrichten des Menübands angezeigt.

Wählen Sie zum Erstellen einer Nachverfolgungs-E-Mail-Nachricht für Kunden einen Kunden aus, und wählen Sie dann die vom Kunden erworbenen Produkte aus. Die Steuerelemente in der Gruppe Kundenbestellungen werden zur Laufzeit mit Daten aus der Datenbank "Northwind" aktualisiert.

So testen Sie die Steuerelemente in der benutzerdefinierten Gruppe

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

    Outlook wird gestartet.

  2. Zeigen Sie in Outlook im Menü Datei auf Neu, und klicken Sie dann auf E-Mail-Nachricht.

    Die folgenden Aktionen werden ausgeführt:

    • Eine neues Inspektor-Fenster für E-Mail-Nachrichten wird angezeigt.

    • Auf der Registerkarte Nachricht des Menübands wird die Gruppe Kundenbestellungen vor der Gruppe Zwischenablage angezeigt.

    • Das Kombinationsfeld Kunden in der Gruppe wird mit den Namen der Kunden in der Datenbank "Northwind" aktualisiert.

  3. Wählen Sie auf der Registerkarte Nachricht des Menübands in der Gruppe Kundenbestellungen einen Kunden aus dem Kombinationsfeld Kunden aus.

    Die folgenden Aktionen werden ausgeführt:

    • Das Menü Gekaufte Produkte wird so aktualisiert, dass jede Bestellung für den ausgewählten Kunden angezeigt wird.

    • Jedes Bestellungsuntermenü wird so aktualisiert, dass die in der betreffenden Bestellung gekauften Produkte angezeigt werden.

    • Die E-Mail-Adresse des ausgewählten Kunden wird der Zeile An der E-Mail-Nachricht hinzugefügt, und der Betreff und der Nachrichtentext der E-Mail-Nachricht werden mit Text aufgefüllt.

  4. Klicken Sie auf das Menü Gekaufte Produkte, zeigen Sie auf eine beliebige Bestellung, und klicken Sie dann auf ein Produkt aus der Bestellung.

    Der Produktname wird dem Nachrichtentext der E-Mail-Nachricht hinzugefügt.

Nächste Schritte

Weitere Informationen zum Anpassen der Office-Benutzeroberfläche finden Sie in diesen Themen:

Anzeigen: