Procedura dettagliata: aggiornamento dei controlli di una barra multifunzione in fase di esecuzione

Articolo
02/19/2013

In questa procedura dettagliata viene illustrato come utilizzare il modello a oggetti della barra multifunzione per aggiornare i controlli di una barra multifunzione dopo che la barra multifunzione è stata caricata nell'applicazione Office.

Si applica a: le informazioni fornite in questo argomento sono valide per i progetti a livello di documento e di applicazione per Excel 2013, Excel 2010, InfoPath 2013, InfoPath 2010, Outlook 2013, Outlook 2010, PowerPoint 2013, PowerPoint 2010, Project 2013, Project 2010, Visio 2013, Visio 2010, Word 2013, Word 2010. Per ulteriori informazioni, vedere Funzionalità disponibili in base ai tipi di progetto e applicazioni di Office.

Nell'esempio vengono utilizzati i dati del database di esempio Northwind per popolare una casella combinata e un menu in Microsoft Office Outlook.Gli elementi che si selezionano in questi controlli popolano automaticamente campi quali A e Oggetto in un messaggio di posta elettronica.

In questa procedura dettagliata vengono illustrate le attività seguenti:

Creazione di un nuovo progetto di componente aggiuntivo per Outlook.
Progettazione di un gruppo personalizzato della barra multifunzione.
Aggiunta del gruppo personalizzato a una scheda predefinita.
Aggiornamento dei controlli della barra multifunzione in fase di esecuzione.

[!NOTA]

Il computer potrebbe mostrare nomi o percorsi diversi per alcuni elementi dell'interfaccia utente di Visual Studio nelle istruzioni seguenti.Questi elementi sono determinati dall'edizione di Visual Studio in uso e dalle impostazioni utilizzate.Per ulteriori informazioni, vedere Impostazioni di Visual Studio.

Prerequisiti

Per completare la procedura dettagliata, è necessario disporre dei componenti seguenti:

Una versione di Visual Studio 2012 che include gli strumenti per sviluppatori di Microsoft Office. Per ulteriori informazioni, vedere [Configurazione di un computer per sviluppare soluzioni Office](bb398242\(v=vs.110\).md).

Microsoft Outlook 2010 o Office 2013.

Creazione di un nuovo progetto di componente aggiuntivo per Outlook

Per creare per prima cosa un nuovo progetto di componente aggiuntivo per Outlook.

Per creare un nuovo progetto di componente aggiuntivo per Outlook

In Visual Studio, creare un progetto componente aggiuntivo Outlook 2013 o Outlook 2010 con il nome Ribbon_Update_At_Runtime.
Selezionare Crea directory per soluzione nella finestra di dialogo Nuovo progetto.
Salvare il progetto nella directory di progetto predefinita.

Per ulteriori informazioni, vedere Procedura: creare progetti di Office in Visual Studio.

Progettazione di un gruppo personalizzato della barra multifunzione

La barra multifunzione per questo esempio verrà visualizzata quando un utente compone un nuovo messaggio di posta.Per creare un gruppo personalizzato per la barra multifunzione, aggiungere prima un elemento barra multifunzione al progetto, quindi progettare il gruppo nella finestra di progettazione della barra multifunzione.Questo gruppo personalizzato consente di generare messaggi di posta elettronica da completare per i clienti utilizzando nomi e cronologie di ordine di un database.

Per progettare un gruppo personalizzato

Scegliere Aggiungi nuovo elemento dal menu Progetto.
Nella finestra di dialogo Aggiungi nuovo elemento selezionare Barra multifunzione (finestra di progettazione visiva).
Modificare il nome della nuova barra multifunzione in CustomerRibbon, quindi fare clic su Aggiungi.

Nella finestra di progettazione della barra multifunzione viene aperto un file CustomerRibbon.cs o CustomerRibbon.vb, che visualizza una scheda e un gruppo predefiniti.
Fare clic sulla finestra di progettazione della barra multifunzione per selezionarlo.
Nella finestra Proprietà, fare clic sulla freccia a discesa accanto alla proprietà RibbonType e selezionare Microsoft.Outlook.Mail.Compose.

In tal modo, la barra multifunzione viene visualizzata quando l'utente compone un nuovo messaggio di posta in Outlook.
Nella finestra di progettazione della barra multifunzione, fare clic su Group1 per selezionarlo.
Nella finestra Proprietà impostare Etichetta su Customer Purchases.
Dalla scheda Controlli barra multifunzione di Office della Casella degli strumenti, trascinare una casella combinata sul gruppo Customer Purchases.
Fare clic su ComboBox1 per selezionarla.
Nella finestra Proprietà impostare Etichetta su Customers.
Dalla scheda Controlli barra multifunzione di Office della Casella degli strumenti, trascinare una menu sul gruppo Customer Purchases.
Nella finestra Proprietà impostare Etichetta su Products Purchased.
Impostare Dinamico su true.

In tal modo, è possibile aggiungere e rimuovere i controlli nel menu in fase di esecuzione dopo che la barra multifunzione è stata caricata nell'applicazione Office.

Aggiunta del gruppo personalizzato a una scheda predefinita

Una scheda incorporata rappresenta una scheda già presente sulla barra multifunzione di una finestra di esplorazione o di un controllo di Outlook.In questa procedura, si aggiunge il gruppo personalizzato a una scheda predefinita e quindi si specifica la posizione del gruppo personalizzato nella scheda.

Per aggiungere il gruppo personalizzato a una scheda predefinita

Fare clic sulla scheda TabAddins (Built-In) per selezionarla.
Nella finestra Proprietà espandere la proprietà ControlId, quindi impostare OfficeId su TabNewMailMessage.

Il gruppo Customer Purchases viene così aggiunto alla scheda Messaggi della barra multifunzione che viene visualizzata in un nuovo messaggio di posta.
Fare clic sul gruppo Customer Purchases per selezionarlo.
Nella finestra Proprietà, espandere la proprietà Posizione, fare clic sulla freccia a discesa accanto alla proprietà PositionType, quindi fare clic su BeforeOfficeId.
Impostare la proprietà OfficeId su GroupClipboard.

Il gruppo Customer Purchases viene così posizionato prima del gruppo Appunti della scheda Messaggi.

Creazione dell'origine dati

Utilizzare la finestra Origini dati per aggiungere un DataSet tipizzato al progetto.

Per creare l'origine dati

Scegliere Aggiungi nuova origine dati dal menu Dati.

Verrà avviata la Configurazione guidata origine dati.
Selezionare Database e fare clic su Avanti.
Selezionare DataSet e fare clic su Avanti.
Selezionare una connessione dati al database di esempio Northwind di Microsoft SQL Server Compact 4.0 oppure aggiungere una nuova connessione tramite il pulsante Nuova connessione.
Dopo aver selezionato o creato una connessione, scegliere Avanti.
Fare clic su Avanti per salvare la stringa di connessione.
Nella pagina Seleziona oggetti di database espandere Tabelle.
Selezionare la casella di controllo accanto a ciascuna delle seguenti tabelle:
1. Clienti
2. Dettagli sugli ordini
3. Ordini
4. Prodotti
Fare clic su Fine.

Aggiornamento dei controlli nel gruppo personalizzato in fase di esecuzione

Utilizzare il modello a oggetti della barra multifunzione per effettuare le seguenti attività:

Aggiungere nomi di clienti nella casella combinata Customers.
Aggiungere menu e controlli di pulsanti al menu Products Purchased che rappresenta gli ordini di vendita e i prodotti venduti.
Popolare i campi To, Subject e Body dei nuovi messaggi di posta utilizzando i dati della casella combinata Customers e del menu Products Purchased.

Per aggiornare i controlli nel gruppo personalizzato utilizzando il modello a oggetti della barra multifunzione

Scegliere Aggiungi riferimento dal menu Progetto.
Nella finestra di dialogo Aggiungi riferimento fare clic sulla scheda .NET, selezionare l'assembly System.Data.Linq, quindi scegliere OK.

Questo assembly contiene le classi per l'utilizzo di Language-Integrated Queries (LINQ).LINQ viene utilizzato per popolare i controlli nel gruppo personalizzato con i dati del database Northwind.
In Esplora soluzioni, fare clic su CustomerRibbon.cs o CustomerRibbon.vb per selezionarlo.
Scegliere Codice dal menu Visualizza.

Il file di codice della barra multifunzione viene aperto nell'editor di codice.

Aggiungere le seguenti istruzioni all'inizio del file di codice della barra multifunzione.Queste istruzioni forniscono l'accesso agli spazi dei nomi LINQ e allo spazio dei nomi dell'assembly di interoperabilità primario (PIA) di 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.Northwind40DataSetTableAdapters

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;

Aggiungere il codice riportato di seguito all'interno della classe CustomerRibbon.Il codice dichiara la tabella dati e gli adattatori di tabella che verranno utilizzati per archiviare le informazioni delle tabelle Clienti, Ordini, Dettagli sugli ordini e Prodotti del database Northwind.

    '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()

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

Aggiungere il seguente blocco di codice alla classe CustomerRibbon.Questo codice aggiunge tre metodi di supporto che creano i controlli per la barra multifunzione in fase di esecuzione.


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

Sostituire il metodo del gestore eventi CustomerRibbon_Load con il codice riportato di seguito.Questo codice utilizza una query LINQ per eseguire le attività seguenti:

Popolare la casella combinata Customers utilizzando l'ID e il nome di 20 clienti del database Northwind.
Chiama il metodo di supporto PopulateSalesOrderInfo.Questo metodo aggiorna il menu ProductsPurchased con i numeri degli ordini di vendita relativi al cliente attualmente selezionato.

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

Aggiungere il codice seguente alla classe CustomerRibbon.Questo codice utilizza le query LINQ per eseguire le attività seguenti:

Aggiungere un sottomenu al menu ProductsPurchased per ogni ordine di vendita relativo al cliente selezionato.
Aggiungere pulsanti a ogni sottomenu per i prodotti relativi all'ordine di vendita.
Aggiungere gestori eventi a ogni pulsante.

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

In Esplora soluzioni fare doppio clic sul file di codice della barra multifunzione.

La finestra di progettazione della barra multifunzione viene aperta.
Nella finestra di progettazione della barra multifunzione, fare doppio clic sulla casella di controllo Customers.

Nell'editor di codice viene aperto il file di codice della barra multifunzione e viene visualizzato il gestore eventi ComboBox1_TextChanged.
Sostituire il gestore eventi ComboBox1_TextChanged con il codice riportato di seguito.Mediante il codice vengono effettuate le seguenti attività:
- Chiama il metodo di supporto PopulateSalesOrderInfo.Questo metodo aggiorna il menu ProductsPurchased con gli ordini di vendita relativi al cliente selezionato.
- Chiama il metodo di supporto PopulateMailItem e passa al testo corrente, ossia il nome del cliente selezionato.Questo metodo popola i campi To, Subject e Body dei nuovi messaggi di posta.
```
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);
}
```

Aggiungere il gestore dell'evento Click indicato di seguito alla classe CustomerRibbon.Questo codice aggiunge il nome dei prodotti selezionati nel campo Body dei nuovi messaggi di posta.

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

Aggiungere il codice seguente alla classe CustomerRibbon.Mediante il codice vengono effettuate le seguenti attività:

Inserisce la riga To dei nuovi messaggi di posta utilizzando l'indirizzo di posta elettronica del cliente attualmente selezionato.
Aggiunge il testo nei campi Subject e Body dei nuovi messaggi di posta.

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

Test dei controlli nel gruppo personalizzato

Quando si apre un nuovo modulo di posta in Outlook, un gruppo personalizzato denominato Customer Purchases viene visualizzato nella scheda Messaggi della barra multifunzione.

Per creare un messaggio di posta elettronica da completare per il cliente, selezionare un cliente e quindi selezionare i prodotti acquistati dal cliente.I controlli nel gruppo Customer Purchases vengono aggiornati in fase di esecuzione con i dati del database Northwind.

Per testare i controlli nel gruppo personalizzato

Premere F5 per eseguire il progetto.

Viene avviato Outlook.
In Outlook scegliere Nuovo dal menu File, quindi fare clic su Messaggio di posta.

Si verificano le seguenti operazioni:
- Viene visualizzata una nuova finestra di controllo del messaggio di posta.
- Il gruppo Customer Purchases viene posizionato prima del gruppo Appunti della scheda Messaggio della barra multifunzione.
- La casella combinata Customers nel gruppo viene aggiornata con i nomi dei clienti del database Northwind.
Nella scheda Messaggio della barra multifunzione, nel gruppo Customer Purchases, selezionare un cliente dalla casella combinata Customers.

Si verificano le seguenti operazioni:
- Il menu Products Purchased viene aggiornato per visualizzare ogni ordine di vendita per il cliente selezionato.
- Ogni sottomenu dell'ordine di vendita viene aggiornato per visualizzare i prodotti acquistati in quell'ordine.
- L'indirizzo di posta elettronica del cliente selezionato viene aggiunto nella riga A del messaggio di posta e l'oggetto e il corpo del messaggio di posta vengono popolati con un testo.
Fare clic sul menu Products Purchases, selezionare un ordine di vendita e quindi fare clic su un prodotto dall'ordine di vendita.

Il nome di prodotto viene aggiunto al corpo del messaggio di posta.

Passaggi successivi

È possibile trovare ulteriori informazioni sulla personalizzazione dell'interfaccia utente di Office nei seguenti argomenti:

Aggiunta di un'interfaccia utente basata sul contesto a una personalizzazione a livello di documento.Per ulteriori informazioni, vedere Cenni preliminari sul riquadro delle azioni.
Estensione di un modulo standard o personalizzato di Microsoft Office Outlook.Per ulteriori informazioni, vedere Procedura dettagliata: progettazione di un'area del modulo di Outlook.
Aggiungere un riquadro attività personalizzato a Outlook.Per ulteriori informazioni, vedere Riquadri attività personalizzati.

Vedere anche

Condividi tramite