Exemplarische Vorgehensweise: Aktualisieren der Steuerelemente in einer Multifunktionsleiste zur Laufzeit

Artikel
08/10/2011

In dieser exemplarischen Vorgehensweise wird gezeigt, wie mit dem Menüband-Objektmodell die Steuerelemente auf einem Menüband nach dem Laden des Menübands in die Office-Anwendung aktualisiert werden.

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

In dem Beispiel werden die Daten der Northwind-Beispieldatenbank entnommen, um ein Kombinationsfeld und ein Menü in Microsoft Office Outlook auszufüllen. Elemente, die Sie in diesen Steuerelementen auswählen, füllen automatisch Felder wie Zu und Betreff in einer E-Mail.

In dieser exemplarischen Vorgehensweise werden die folgenden Aufgaben veranschaulicht:

Erstellen eines neuen Outlook-Add-In-Projekts
Entwerfen einer benutzerdefinierten Menübandgruppe
Hinzufügen der benutzerdefinierten Gruppe zu einer integrierten Registerkarte
Aktualisieren von Steuerelementen auf dem Menüband während der Laufzeit

Tipp

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. Die von Ihnen verwendete Visual Studio-Edition und die Einstellungen legen diese Elemente fest. Weitere Informationen finden Sie unter Arbeiten mit Einstellungen.

Vorbereitungsmaßnahmen

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

Eine Version von Visual Studio 2010, die die Microsoft Office-Entwicklungstools einschließt. Weitere Informationen finden Sie unter [Konfigurieren eines Computers zum Entwickeln von Office-Lösungen](bb398242\(v=vs.100\).md).

Microsoft Office Outlook 2007 oder Microsoft Outlook 2010.

Erstellen eines neuen Outlook-Add-In-Projekts

Erstellen Sie zuerst ein Outlook-Add-In-Projekt.

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

Erstellen Sie in Visual Studio ein Outlook 2007- oder Outlook 2010-Add-In-Projekt mit dem Namen "Ribbon_Update_At_Runtime".
Wählen Sie im Dialogfeld Neues Projekt die Option Projektmappenverzeichnis erstellen.
Speichern Sie das Projekt im Standardprojektverzeichnis.

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

Entwerfen einer benutzerdefinierten Menübandgruppe

Das Menüband für dieses Beispiel wird angezeigt, wenn ein Benutzer eine neue E-Mail verfasst. Wenn Sie eine benutzerdefinierte Gruppe für das Menüband erstellen möchten, fügen Sie dem Projekt zuerst ein Menüband hinzu, und entwerfen Sie anschließend die Gruppe im Menüband-Designer. Mithilfe dieser benutzerdefinierten Gruppe können Sie Folge-E-Mail-Nachrichten für Kunden generieren, indem Sie einer Datenbank Namen und die bisherigen Bestellungen entnehmen.

So entwerfen Sie eine benutzerdefinierte Gruppe

Klicken Sie im Menü Projekt auf Neues Element hinzufügen.
Wählen Sie im Dialogfeld Neues Element hinzufügen die Option Menüband (Visual Designer) aus.
Ändern Sie den Namen des neuen Menübands in CustomerRibbon, und klicken Sie anschließend auf Hinzufügen.

Die Datei CustomerRibbon.cs oder CustomerRibbon.vb wird im Menüband-Designer geöffnet. Sie beinhaltet eine Standardregisterkarte und eine Gruppe.
Klicken Sie auf den Menüband-Designer, um diesen auszuwählen.
Klicken Sie im Fenster Eigenschaften auf den Dropdownpfeil neben der RibbonType-Eigenschaft, und klicken Sie anschließend af Microsoft.Outlook.Mail.Compose.

Beim Erstellen einer neuen E-Mail-Nachricht in Outlook wird daraufhin wird das Menüband angezeigt.
Klicken Sie im Menüband-Designer auf Group1, um diese Option auszuwählen.
Legen Sie im Fenster Eigenschaften die Label-Eigenschaft auf "Customer Purchases" fest.
Ziehen Sie von der Registerkarte Steuerelemente für Office-Menübänder der Toolbox ein Steuerelement mit der Bezeichnung ComboBox zur Gruppe Customer Purchases.
Klicken Sie auf ComboBox1, um das Element auszuwählen.
Legen Sie im Fenster Eigenschaften die Label-Eigenschaft auf "Customers" fest.
Ziehen Sie von der Registerkarte Steuerelemente für Office-Menübänder der Toolbox ein Menü zur Gruppe Customer Purchases.
Legen Sie im Fenster Eigenschaften die Label-Eigenschaft auf "Product Purchased" fest.
Legen Sie Dynamic auf true fest.

Dadurch können Sie Steuerelemente für das Menü während der Laufzeit hinzufügen und entfernen, nachdem das Menüband in die Office-Anwendung geladen wurde.

Hinzufügen der benutzerdefinierten Gruppe zu einer integrierten Registerkarte

Eine integrierte Registerkarte ist eine Registerkarte, die sich bereits auf dem Menüband eines Outlook Explorers oder -Inspektors befindet. In dieser Prozedur wird die benutzerdefinierte Gruppe einer integrierten Registerkarte hinzugefügt und anschließend die Position der benutzerdefinierten Gruppe auf der Registerkarte angegeben.

So fügen die benutzerdefinierte Gruppe einer integrierten Registerkarte hinzu

Klicken Sie auf die Registerkarte TabAddins (Integriert), um diese auszuwählen.
Erweitern Sie im Fenster Eigenschaften die ControlId-Eigenschaft, und legen Sie die OfficeId-Eigenschaft auf "TabNewMailMessage" fest.

Dadurch wird die Gruppe Customer Purchases der Registerkarte Nachrichten des Menübands hinzugefügt, das in einer neuen E-Mail-Nachricht angezeigt wird.
Klicken Sie auf die Gruppe Customer Purchases, um diese auszuwählen.
Erweitern Sie im Fenster Eigenschaften die Position-Eigenschaft, klicken Sie zuerst auf den Dropdownpfeil neben der PositionType-Eigenschaft und anschließend auf Microsoft.Outlook.Mail.Compose.
Legen Sie die OfficeId-Eigenschaft auf "GroupClipboard" fest.

Dadurch wird die Gruppe Customer Purchases vor der Gruppe Zwischenablage der Registerkarte Nachrichten angeordnet.

Erstellen der Datenquelle

Verwenden Sie das Datenquellenfenster, um dem Projekt ein typisiertes Dataset hinzuzufügen.

So erstellen Sie die Datenquelle

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

Der Assistent zum Konfigurieren von Datenquellen wird gestartet.
Wählen Sie Datenbank aus, und klicken Sie auf Weiter.
Wählen Sie Dataset aus, und klicken Sie auf Weiter.
Wählen Sie eine Datenverbindung zur Northwind-Beispieldatenbank für Microsoft SQL Server Compact 3.5 aus, oder fügen Sie mithilfe der Schaltfläche Neue Verbindung eine neue Verbindung hinzu.
Klicken Sie nach dem Auswählen oder Erstellen einer Verbindung auf Weiter.
Klicken Sie auf Weiter, um die Verbindungszeichenfolge zu speichern.
Erweitern Sie auf der Seite Datenbankobjekte auswählen den Knoten Tabellen.
Aktivieren Sie das Kontrollkästchen neben jeden der folgenden Tabellen:
1. Customers
2. Order Details
3. Orders
4. Products
Klicken Sie auf Fertig stellen.

Aktualisieren der Steuerelemente in der benutzerdefinierten Gruppe während der Laufzeit

Verwenden Sie das Menüband-Objektmodell zum Ausführen der folgenden Aufgaben:

Fügen Sie im Kombinationsfeld Customers Kundennamen hinzu.
Fügen Sie dem Menü Products Purchased Menü- und Schaltflächensteuerelemente hinzu, die Bestellungen und verkaufte Produkte darstellen.
Füllen Sie das To, Subject-Feld und das Body-Feld neuer E-Mail-Nachrichten aus. Verwenden Sie dabei Daten aus dem Kombinationsfeld Customers und dem Menü Products Purchased.

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

Klicken Sie im Menü Projekt auf Verweis hinzufügen.
Wählen Sie im Dialogfeld Verweis hinzufügen auf der Registerkarte .NET die System.Data.Linq aus-Assembly aus, und klicken Sie anschließend auf OK.

Diese Assembly beinhaltet Klassen für die Verwendung von Language-Integrated Queries (LINQ). Mit LINQ werden Steuerelemente in der benutzerdefinierten Gruppe mit Daten aus der Northwind-Datenbank ausgefüllt.
Klicken Sie im Projektmappen-Explorer auf CustomerRibbon.cs oder CustomerRibbon.vb, um diese Dateien auszuwählen.
Klicken Sie im Menü Ansicht auf Code.

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

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

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

using System.Data.Linq;
using System.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.NorthwindDataSetTableAdapters;

Fügen Sie innerhalb der CustomerRibbon-Klasse den folgenden Code hinzu. In diesem Code werden die Datentabellen- und Tabellenadapter deklariert, mit denen Sie Informationen aus den Tabellen "Customer", "Orders", "Order Details" und "Product" der Northwind-Datenbank speichern.

    'Declare the Northwind data set.

    Dim nwDataSet As NorthwindDataSet = New NorthwindDataSet()

    'Declare the data tables.

    Dim customerTable As NorthwindDataSet.CustomersDataTable
    Dim orderTable As NorthwindDataSet.OrdersDataTable
    Dim orderDetailsTable As NorthwindDataSet.Order_DetailsDataTable
    Dim productsTable As NorthwindDataSet.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()

//Declare the Northwind dataset.
NorthwindDataSet nwDataSet = new NorthwindDataSet();

//Declare the data tables.

NorthwindDataSet.CustomersDataTable customerTable;
NorthwindDataSet.OrdersDataTable orderTable;
NorthwindDataSet.Order_DetailsDataTable orderDetailsTable;
NorthwindDataSet.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();

Fügen Sie der CustomerRibbon-Klasse einen der folgenden Codeblöcke hinzu: Durch diesen Code werden drei Hilfsmethoden hinzugefügt, die zur Laufzeit Steuerelemente für das Menüband erstellen.

Wenn das Projekt auf .NET Framework 4 abzielt, fügen Sie den folgenden Code hinzu.


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

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

Wenn das Projekt auf .NET Framework 3,5 abzielt, fügen Sie folgenden Code hinzu.


Private Function CreateRibbonDropDownItem() As RibbonDropDownItem
    Return New RibbonDropDownItem()
End Function

Private Function CreateRibbonMenu() As RibbonMenu
    Return New RibbonMenu()
End Function

Private Function CreateRibbonButton() As RibbonButton
    Dim button As RibbonButton = New RibbonButton()
    AddHandler (button.Click), AddressOf Button_Click
    Return button
End Function

private RibbonDropDownItem CreateRibbonDropDownItem()
{
    return new RibbonDropDownItem();
}
private RibbonMenu CreateRibbonMenu()
{
    return new RibbonMenu();
}
private RibbonButton CreateRibbonButton()
{
    RibbonButton button = new RibbonButton();
    button.Click += new EventHandler<RibbonControlEventArgs>(button_Click);
    return button;
}

Ersetzen Sie die CustomerRibbon_Load-Ereignishandlermethode durch folgenden Code. In diesem Code wird für die folgenden Aufgaben eine LINQ-Abfrage verwendet:

Füllen Sie das Kombinationsfeld Customers mithilfe der ID und des Namens von 20 Kunden aus der Northwind-Datenbank aus.
Ruft die PopulateSalesOrderInfo-Hilfsmethode auf. Mit dieser Methode wird das Menü ProductsPurchased mit Verkaufauftragsnummern aktualisiert, die sich auf den derzeit ausgewählten Kunden beziehen.

    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

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

Fügen Sie der CustomerRibbon-Klasse folgenden Code hinzu. In diesem Code werden für die folgenden Aufgaben LINQ-Abfragen verwendet:

Fügt dem Menü ProductsPurchased für jeden Verkaufsauftrag in Zusammenhang mit dem ausgewählten Kunden ein Untermenü hinzu.
Fügt jedem Untermenü Schaltflächen für die Produkte in Zusammenhang mit dem Verkaufsauftrag hinzu.
Fügt jeder Schaltfläche Ereignishandler hinzu.

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

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

Doppelklicken Sie im Projektmappen-Explorer auf die Menüband-Codedatei.

Der Menüband-Designer wird geöffnet.
Doppelklicken Sie im Menüband-Designer auf das Kombinationsfeld Customers.

Die Menüband-Codedatei wird im Code-Editor geöffnet, und der ComboBox1_TextChanged-Ereignishandler wird angezeigt.
Ersetzen Sie den ComboBox1_TextChanged-Ereignishandler durch folgenden Code. Mit diesem Code werden die folgenden Aufgaben ausgeführt:
- Ruft die PopulateSalesOrderInfo-Hilfsmethode auf. Mit dieser Methode wird das Menü Products Purchased mit Verkaufsauftragsnummern aktualisiert, die sich auf den derzeit ausgewählten Kunden beziehen.
- Ruft die PopulateMailItem-Hilfsmethode auf und übergibt den aktuellen Text (der ausgewählte Kundenname). Mit dieser Methode wird das To-Feld, das Subject-Feld und das Body-Feld von neuen E-Mail-Nachrichten ausgefüllt.
```
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
```
```
private void comboBox1_TextChanged(object sender,
    RibbonControlEventArgs e)
{
    PopulateSalesOrderInfo();
    PopulateMailItem(comboBox1.Text);
}
```

Fügen Sie der CustomerRibbon-Klasse den Click-Ereignishandler hinzu. Mit diesem Code wird der Name der ausgewählten Produkte dem Body-Feld neuer E-Mail-Nachrichten hinzugefügt.

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

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

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

Füllt die To-Zeile neuer E-Mail-Nachrichten mithilfe der E-Mail-Adresse des derzeit ausgewählten Kunden aus.
Fügt dem Subject-Feld und dem Body-Feld neuer E-Mail-Nachrichten Text hinzu.

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

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

Testen der Steuerelemente in der benutzerdefinierten Gruppe

Beim Öffnen eines neuen E-Mail-Formulars in Outlook wird auf der Registerkarte Nachrichten des Menübands eine benutzerdefinierte Gruppe mit der Bezeichnung Customer Purchases angezeigt.

Wählen Sie zum Erstellen einer Folge-E-Mail-Nachricht für Kunden einen Kunden und anschließend vom Kunden erworbene Produkte aus. Die Steuerelemente in der Gruppe Customer Purchases werden während der Laufzeit mit Daten aus der Northwind-Datenbank aktualisiert.

So testen Sie die Steuerelemente in der benutzerdefinierten Gruppe

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

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

Folgende Aktionen werden ausgeführt:
- Ein neues Inspektorfenster für E-Mail-Nachrichten wird angezeigt.
- Auf der Registerkarte Nachrichten des Menübands wird die Gruppe Customer Purchases vor der Gruppe Zwischenablage angezeigt.
- Das Kombinationsfeld Customers in der Gruppe wird mit den Namen der Kunden in der Northwind-Datenbank aktualisiert.
Wählen Sie auf der Registerkarte Nachrichten des Menübands in der Gruppe Customer Purchases im Kombinationsfeld Customers einen Kunden aus.

Folgende Aktionen werden ausgeführt:
- Das Menü Products Purchased wird so aktualisiert, dass jeder Auftrag für den ausgewählten Kunden angezeigt wird.
- Jedes Auftragsuntermenü wird so aktualisiert, dass die in dieser Reihenfolge gekauften Produkte angezeigt werden.
- Die E-Mail-Adresse des ausgewählten Kunden wird der Zeile An der E-Mail-Nachricht hinzugefügt, und die Betreffzeile und der Textkörper der E-Mail-Nachricht werden mit Text ausgefüllt.
Klicken Sie im Menü Products Purchased auf einen beliebigen Verkaufsauftrag, und klicken Sie anschließend auf ein Produkt im Verkaufsauftrag.

Der Produktname wird dem Textkörper der E-Mail-Nachricht hinzugefügt.

Nächste Schritte

Weitere Informationen über das 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 unter Aktionsbereichsübersicht.
Erweitern Sie ein standardmäßiges oder benutzerdefiniertes Microsoft Office Outlook-Formular. Weitere Informationen finden Sie unter Exemplarische Vorgehensweise: Entwerfen eines Outlook-Formularbereichs.
Fügen Sie Outlook einen benutzerdefinierten Aufgabenbereich hinzu. Weitere Informationen finden Sie unter Übersicht über benutzerdefinierte Aufgabenbereiche.

Siehe auch

Freigeben über