Exemplarische Vorgehensweise: Aktualisieren der Steuerelemente auf einem Menüband zur Laufzeit

In dieser exemplarischen Vorgehensweise wird veranschaulicht, wie Sie das Menübandobjektmodell verwenden, um die Steuerelemente in einem Menüband zu aktualisieren, nachdem das Menüband in die Office-App lizenzierung geladen wurde.

Gilt für: Die Informationen in diesem Thema gelten für Projekte auf Dokumentebene und VSTO-Add-In-Projekte für die folgenden Anwendungen: Excel; InfoPath 2013 und InfoPath 2010; Outlook; Powerpoint; Projekt; Visio; Wort. Weitere Informationen finden Sie unter features available by Office-App lication and project type.

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 automatisch Felder wie "An " und "Betreff " in einer E-Mail-Nachricht auf.

In dieser exemplarischen Vorgehensweise werden die folgenden Aufgaben veranschaulicht:

• Erstellen Sie ein neues Outlook VSTO-Add-In-Projekt.

• Entwerfen Sie eine benutzerdefinierte Menübandgruppe.

• Fügen Sie die benutzerdefinierte Gruppe zu einer integrierten Registerkarte hinzu.

• Aktualisieren von Steuerelementen im Menüband zur Laufzeit.

Hinweis

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 Personalisieren von Visual Studio-IDE.

Voraussetzungen

Zum Abschließen dieser exemplarischen Vorgehensweise benötigen Sie Folgendes:

• Eine Edition von Visual Studio, die die Microsoft Office-Entwicklungstools umfasst. Weitere Informationen finden Sie unter Konfigurieren eines Computers zum Entwickeln von Office-Lösungen.

• Microsoft Outlook

Erstellen eines neuen Outlook VSTO-Add-In-Projekts

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 erstellenaus.

3. Speichern Sie das Projekt im Standardprojektverzeichnis.

   Weitere Informationen finden Sie unter How to: Create Office projects in Visual Studio.

Entwerfen einer benutzerdefinierten Menübandgruppe

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 ihrem Projekt zuerst ein Menübandelement hinzu, und entwerfen Sie dann die Gruppe im Menüband-Designer. Diese benutzerdefinierte Gruppe hilft Ihnen, Nachverfolgungs-E-Mail-Nachrichten für Kunden zu generieren, indem Sie Namen und Bestellhistorien aus einer Datenbank abrufen.

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 und zeigt eine Standardregisterkarte und -gruppe an.

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

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

   Dadurch kann das Menüband angezeigt werden, wenn der Benutzer eine neue E-Mail-Nachricht in Outlook verfasst.

6. Klicken Sie im Menüband-Designer auf "Gruppe1 ", um sie auszuwählen.

7. Legen Sie im Eigenschaftenfenster die Bezeichnung auf Kundenkäufe fest.

8. Ziehen Sie auf der Registerkarte "Steuerelemente des Office-Menübands " der Toolbox ein ComboBox-Steuerelement auf die Gruppe " Kundenkäufe ".

9. Klicken Sie auf ComboBox1 , um es auszuwählen.

10. Legen Sie im Eigenschaftenfenster "Bezeichnung" auf "Kunden" fest.

11. Ziehen Sie auf der Registerkarte "Steuerelemente des Office-Menübands " der Toolbox ein Menü auf die Gruppe " Kundenkäufe ".

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

13. Legen Sie "Dynamisch" auf "true" fest.

    Auf diese Weise können Sie steuerelemente im Menü zur Laufzeit hinzufügen und entfernen, nachdem das Menüband in die Office-App lizenzierung geladen wurde.

Hinzufügen der benutzerdefinierten Gruppe zu einer integrierten Registerkarte

Eine integrierte Registerkarte ist eine Registerkarte, die sich bereits im Menüband eines Outlook-Explorers oder -Inspektors 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 sie auszuwählen.

2. Erweitern Sie im Eigenschaftenfenster die ControlId-Eigenschaft, und legen Sie dann OfficeId auf TabNewMailMessage fest.

   Dadurch wird die Gruppe "Kundenkäufe " zur Registerkarte "Nachrichten " des Menübands hinzugefügt, die in einer neuen E-Mail-Nachricht angezeigt wird.

3. Klicken Sie auf die Gruppe "Kundenkäufe ", um sie auszuwählen.

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

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

   Dadurch wird die Gruppe "Kundenkäufe " vor der Gruppe "Zwischenablage " der Registerkarte "Nachrichten " positioniert.

Die Datenquelle erstellen

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.

   Dadurch wird der Datenquellenkonfigurations-Assistent 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 Northwind-Beispieldatenbank "Microsoft SQL Server Compact 4.0" aus, oder fügen Sie eine neue Verbindung mithilfe der Schaltfläche "Neue Verbinden ion" 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" die Option "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.

Aktualisieren von Steuerelementen in der benutzerdefinierten Gruppe zur Laufzeit

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

• Hinzufügen von Kundennamen zum Kombinationsfeld "Kunden ".

• Fügen Sie menü- und Schaltflächensteuerelemente zum Menü "Gekaufte Produkte" hinzu, das Verkaufsaufträge und verkaufte Produkte darstellt.

• Füllen Sie die Felder "An", "Betreff" und "Textkörper" neuer E-Mail-Nachrichten mithilfe von Daten aus dem Kombinationsfeld "Kunden" und dem Menü "Gekaufte Produkte" aus.

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 in Projektmappen-Explorer auf "CustomerRibbon.cs" oder "CustomerRibbon.vb", um es 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.

   C#

   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;
   

   VB

   Imports System.Data.Linq
   Imports System.Linq
   Imports System.Data.Linq.Mapping
   Imports System.Linq.Expressions
   Imports Outlook = Microsoft.Office.Interop.Outlook
   Imports Ribbon_Update_At_Runtime.Northwind40DataSetTableAdapters
   

6. Fügen Sie den folgenden Code innerhalb der CustomerRibbon Klasse 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.

   C#

   //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();
   

   VB

   'Declare the Northwind data set.
   
   Dim nwDataSet As Northwind40DataSet = New Northwind40DataSet()
   
   'Declare the data tables.
   
   Dim customerTable As Northwind40DataSet.CustomersDataTable
   Dim orderTable As Northwind40DataSet.OrdersDataTable
   Dim orderDetailsTable As Northwind40DataSet.Order_DetailsDataTable
   Dim productsTable As Northwind40DataSet.ProductsDataTable
   
   'Declare the data table adapters for each table.
   
   Dim customersTableAdapter As CustomersTableAdapter = New CustomersTableAdapter()
   Dim ordersTableAdapter As OrdersTableAdapter = New OrdersTableAdapter()
   Dim detailsTableAdapter As Order_DetailsTableAdapter = New Order_DetailsTableAdapter()
   Dim productsTableAdapter As ProductsTableAdapter = New ProductsTableAdapter()
   

7. Fügen Sie der Klasse CustomerRibbon den folgenden Codeblock hinzu. Dieser Code fügt drei Hilfsmethoden hinzu, mit denen Steuerelemente für das Menüband zur Laufzeit erstellt werden.

   C#

   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;
   }
   

   VB

   
   Private Function CreateRibbonDropDownItem() As RibbonDropDownItem
       Return Me.Factory.CreateRibbonDropDownItem()
   End Function
   
   Private Function CreateRibbonMenu() As RibbonMenu
       Return Me.Factory.CreateRibbonMenu()
   End Function
   
   Private Function CreateRibbonButton() As RibbonButton
       Dim button As RibbonButton = Me.Factory.CreateRibbonButton()
       AddHandler (button.Click), AddressOf Button_Click
       Return button
   End Function
   

8. Ersetzen Sie die CustomerRibbon_Load-Ereignishandlermethode durch den folgenden Code. Dieser Code verwendet eine LINQ-Abfrage, um die folgenden Aufgaben auszuführen:

   • Füllen Sie das Kombinationsfeld "Kunden " mit der ID und dem Namen von 20 Kunden in der Northwind-Datenbank auf.

   • Aufrufen der Hilfsmethode PopulateSalesOrderInfo. Diese Methode aktualisiert das Menü "ProductsPurchased " mit Verkaufsauftragsnummern, die sich auf den aktuell ausgewählten Kunden beziehen.

     C#

     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();
     }
     

     VB

      Private Sub CustomerRibbon_Load(ByVal sender As System.Object, _
     ByVal e As Microsoft.Office.Tools.Ribbon.RibbonUIEventArgs) _
         Handles MyBase.Load
     
          customerTable = nwDataSet.Customers
          customersTableAdapter.Fill(customerTable)
     
          Dim customerQuery = From customers In customerTable.AsEnumerable.Take(20) _
                  Select CustomerID = customers.Customer_ID, _
                  CustomerName = customers.Contact_Name
     
          ' Execute the query.
          For Each item In customerQuery
              Me.ComboBox1.Items.Add(CreateRibbonDropDownItem())
     
              Me.ComboBox1.Items.Last().Label = item.CustomerID.ToString() _
                  + "|" + item.CustomerName
          Next item
     
          Me.ComboBox1.Text = Me.ComboBox1.Items.First().Label
          PopulateSalesOrderInfo()
      End Sub
     

   ---

9. Fügen Sie der CustomerRibbon -Klasse den folgenden Code hinzu. Dieser Code verwendet LINQ-Abfragen, um die folgenden Aufgaben auszuführen:

   • Fügt dem Menü "ProductsPurchased" für jeden Verkaufsauftrag, der mit dem ausgewählten Kunden verknüpft ist, ein Untermenü hinzu.

   • 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.

     C#

     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);
             }
         }
     }
     

     VB

     Private Sub PopulateSalesOrderInfo()
     
         Dim tempArray As [String]() = comboBox1.Text.Split(New [Char]() {"|"c})
         Menu1.Items.Clear()
     
         orderTable = nwDataSet.Orders
         orderDetailsTable = nwDataSet.Order_Details
         productsTable = nwDataSet.Products
     
         ordersTableAdapter.Fill(orderTable)
         detailsTableAdapter.Fill(orderDetailsTable)
         productsTableAdapter.Fill(productsTable)
     
         Dim orderQuery = From order In orderTable.AsEnumerable() _
                          Where order.Customer_ID.ToString() = tempArray(0) _
                          Select New With {.SalesOrderID = order.Order_ID}
     
         For Each orderItem In orderQuery
             Me.Menu1.Items.Add(CreateRibbonMenu())
     
             Dim orderMenu As RibbonMenu = CType(Menu1.Items.Last(), RibbonMenu)
             orderMenu.Dynamic = True
             orderMenu.Label = orderItem.SalesOrderID.ToString()
             orderMenu.Tag = orderItem.SalesOrderID
     
             Dim productQuery = From orderDetail In orderDetailsTable.AsEnumerable(), _
                                    product In productsTable.AsEnumerable() _
                                Where orderDetail.Product_ID = _
                                    product.Product_ID _
                                And orderDetail.Order_ID = _
                                orderMenu.Tag _
             Select productName = product.Product_Name
     
             For Each productItem In productQuery
                 Dim button As RibbonButton = CreateRibbonButton()
                 button.Label = productItem
                 orderMenu.Items.Add(button)
             Next productItem
         Next orderItem
     End Sub
     

   ---

10. Doppelklicken Sie in Projektmappen-Explorer auf die Codedatei des Menübands.

    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 durchgeführt:

    • Aufrufen der Hilfsmethode PopulateSalesOrderInfo. Diese Methode aktualisiert das Menü "Gekaufte Produkte" mit Verkaufsaufträgen, die sich auf den ausgewählten Kunden beziehen.

    • Aufrufen der Hilfsmethode PopulateMailItem und Übergeben des aktuellen Texts, der den Namen des ausgewählten Kunden darstellt. Diese Methode füllt die Felder "An", "Betreff" und "Textkörper" von neuen E-Mail-Nachrichten auf.

      C#

      private void comboBox1_TextChanged(object sender,
          RibbonControlEventArgs e)
      {
          PopulateSalesOrderInfo();
          PopulateMailItem(comboBox1.Text);
      }
      

      VB

      Private Sub ComboBox1_TextChanged(ByVal sender As System.Object, _
          ByVal e As Microsoft.Office.Tools.Ribbon.RibbonControlEventArgs) _
              Handles ComboBox1.TextChanged
          PopulateSalesOrderInfo()
          PopulateMailItem(ComboBox1.Text)
      End Sub
      

    ---

13. Fügen Sie der Click -Klasse den folgenden CustomerRibbon -Ereignishandler hinzu. Dieser Code fügt dem Feld "Textkörper" der neuen E-Mail-Nachrichten den Namen der ausgewählten Produkte hinzu.

    C#

    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;
    }
    

    VB

    Private Sub Button_Click(ByVal sender As System.Object, _
        ByVal e As Microsoft.Office.Tools.Ribbon.RibbonControlEventArgs)
        Dim application As Outlook.Application = Globals.ThisAddIn.Application
        Dim inspector As Outlook.Inspector = application.ActiveInspector()
        Dim myMailItem As Outlook.MailItem = CType(inspector.CurrentItem,  _
            Outlook.MailItem)
        Dim myButton As RibbonButton = CType(sender, RibbonButton)
        myMailItem.Subject = "Following up on your order"
        myMailItem.Body = myMailItem.Body + ControlChars.Lf + "* " _
            + myButton.Label
    End Sub
    

14. Fügen Sie der CustomerRibbon -Klasse den folgenden Code hinzu. Mit diesem Code werden die folgenden Aufgaben durchgeführt:

    • Füllt die Zeile "An" von neuen E-Mail-Nachrichten mithilfe der E-Mail-Adresse des aktuell ausgewählten Kunden auf.

    • Fügt Den Feldern "Betreff" und "Textkörper" von neuen E-Mail-Nachrichten Text hinzu.

      C#

      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: ";
      }
      

      VB

      Private Sub PopulateMailItem(ByVal addressToLine As String)
          Dim application As Outlook.Application = Globals.ThisAddIn.Application
          Dim inspector As Outlook.Inspector = application.ActiveInspector()
          Dim myMailItem As Outlook.MailItem = _
              CType(inspector.CurrentItem, Outlook.MailItem)
      
          myMailItem.To = ""
          Dim tempArray As [String]() = addressToLine.Split(New [Char]() {"|"c})
          myMailItem.To = tempArray(1) + "@example.com"
          myMailItem.Subject = "Following up on your order"
          myMailItem.Body = "Hello " + tempArray(1) + "," _
              + ControlChars.Lf + "We would like to get your feedback" + _
              "on the following products that you recently ordered: "
      End Sub
      

    ---

Testen der Steuerelemente in der benutzerdefinierten Gruppe

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

Um eine Kunden-Nachverfolgungs-E-Mail-Nachricht zu erstellen, wählen Sie einen Kunden aus, und wählen Sie dann Produkte aus, die vom Kunden erworben wurden. Die Steuerelemente in der Gruppe "Kundenkäufe " werden zur Laufzeit mit Daten aus der Northwind-Datenbank 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 treten auf:

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

   • Auf der Registerkarte "Nachricht " im Menüband wird die Gruppe "Kundenkäufe " vor der Gruppe "Zwischenablage " angezeigt.

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

3. Wählen Sie auf der Registerkarte "Nachricht" im Menüband in der Gruppe "Kundenkäufe" im Kombinationsfeld "Kunden" einen Kunden aus.

   Die folgenden Aktionen treten auf:

   • Das Menü " Gekaufte Produkte" wird aktualisiert, um jeden Verkaufsauftrag für den ausgewählten Kunden anzuzeigen.

   • 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 Text der E-Mail-Nachricht werden mit Text aufgefüllt.

4. Klicken Sie auf das Menü "Artikelkäufe ", zeigen Sie auf einen beliebigen Verkaufsauftrag, und klicken Sie dann auf ein Produkt aus dem Verkaufsauftrag.

   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:

• Fügen Sie jeder Anpassung auf Dokumentebene kontextbasierte Benutzeroberfläche hinzu. Weitere Informationen finden Sie im Übersichtsbereich "Aktionen".

• Erweitern Sie ein standardmäßiges oder benutzerdefiniertes Microsoft Office Outlook-Formular. Weitere Informationen finden Sie unter Exemplarische Vorgehensweise: Entwerfen eines Outlook-Formularbereichs.

• Hinzufügen eines benutzerdefinierten Aufgabenbereichs zu Outlook. Weitere Informationen finden Sie unter "Benutzerdefinierte Aufgabenbereiche".

Zugehöriger Inhalt

• Zugreifen auf das Menüband zur Laufzeit
• Übersicht über das Menüband
• Language-Integrated Query (LINQ)
• Gewusst wie: Erste Schritte beim Anpassen des Menübands
• Menüband-Designer
• Exemplarische Vorgehensweise: Erstellen einer benutzerdefinierten Registerkarte mithilfe des Menüband-Designers
• Übersicht über das Menübandobjektmodell
• Anpassen eines Menübands für Outlook
• Vorgehensweise: Ändern der Position einer Registerkarte im Menüband
• Vorgehensweise: Anpassen einer integrierten Registerkarte
• Vorgehensweise: Hinzufügen von Steuerelementen zur Backstage-Ansicht
• Vorgehensweise: Exportieren eines Menübands aus dem Menüband-Designer in Menüband-XML
• Vorgehensweise: Anzeigen von Add-In-Benutzeroberflächenfehlern