Procedura dettagliata: programmazione di Office (C# e Visual Basic)

Articolo
06/10/2015

In Visual Studio 2010sono state introdotte nuove funzionalità di C# e Visual Basic che migliorano la programmazione di Microsoft Office. A ogni linguaggio sono state aggiunte funzionalità già presenti nell'altro linguaggio.

Le nuove funzionalità di C# includono gli argomenti denominati e facoltativi, i valori restituiti di tipo dynamic e, nella programmazione COM, la possibilità di omettere la parola chiave ref e di accedere alle proprietà indicizzate. Le nuove funzionalità in Visual Basic includono le proprietà implementate automaticamente, le istruzioni nelle espressioni lambda e gli inizializzatori di raccolta.

Entrambi i linguaggi consentono di incorporare informazioni sul tipo, in modo da distribuire gli assembly che interagiscono con i componenti COM senza distribuire assembly di interoperabilità primari (PIA) al computer dell'utente. Per altre informazioni, vedere Procedura dettagliata: incorporamento dei tipi da assembly gestiti (C# e Visual Basic).

In questa procedura dettagliata vengono illustrate le nuove funzionalità nel contesto della programmazione di Office, ma molti di essi sono utili anche nella programmazione generale. Nella procedura dettagliata, si userà innanzitutto un componente aggiuntivo di Excel per creare una cartella di lavoro di Excel. Si creerà quindi un documento di Word contenente un collegamento alla cartella di lavoro. Infine, si noterà come la dipendenza di assembly di interoperabilità primario può essere attivata e disattivata.

Prerequisiti

Per completare questa procedura dettagliata è necessario aver installato Microsoft Office Excel 2013 (o versione 2007 o versione successiva) e Microsoft Office Word 2013 (o versione 2007 o versione successiva) nel computer.

Se si usa un sistema operativo precedente a Windows Vista, assicurarsi che .NET Framework 2.0 sia installato.

Nota

Nomi o percorsi visualizzati per alcuni elementi dell'interfaccia utente di Visual Studio nelle istruzioni seguenti potrebbero essere diversi nel computer in uso. La versione di Visual Studio in uso e le impostazioni configurate determinano questi elementi. Per altre informazioni vedere Personalizzazione delle impostazioni di sviluppo in Visual Studio.

Per impostare un componente aggiuntivo di Excel

Avviare Visual Studio.
Scegliere Nuovo dal menu File, quindi fare clic su Progetto.
Nel riquadro Modelli installati, espandere Visual Basic o Visual C#, espandere Office e quindi fare clic su 2013 (o 2010 o 2007).
Nel riquadro Modelli selezionare Componente aggiuntivo per Excel 2013 (o Componente aggiuntivo per Excel 2010 o Componente aggiuntivo per Excel 2007).
Verificare che nella parte superiore del riquadro Modelli sia visualizzato .NET Framework 4, o una versione successiva, nel campo Framework di destinazione.
Se opportuno, digitare un nome per il progetto nel campo Nome.
Fare clic su OK.
Il nuovo progetto verrà visualizzato in Esplora soluzioni.

Per aggiungere riferimenti

In Esplora soluzioni fare clic con il pulsante destro del mouse sul nome del progetto, quindi scegliere Aggiungi riferimento. Viene visualizzata la finestra di dialogo Aggiungi riferimento.
Nella scheda Assembly, selezionare Microsoft.Office.Interop.Excel, versione 15.0.0.0 (o versione 14.0.0.0 per Excel 2010 o versione 12.0.0.0 per Excel 2007), nell'elenco Nome componente, quindi tenere premuto il tasto CTRL e selezionare Microsoft.Office.Interop.Word, versione 15.0.0.0 (o versione 14.0.0.0 per Word 2010 o 12.0.0.0 per Word 2007). Se gli assembly non sono visibili, può essere necessario assicurarsi che siano installati e visualizzati (vedere Procedura: installare assembly di interoperabilità primari di Office)
Fare clic su OK.

Per aggiungere istruzioni Imports o le direttive using necessarie

In Esplora soluzioni, fare clic con il pulsante destro del mouse sui file ThisAddIn.vb o ThisAddIn.cs e quindi scegliere Visualizza codice.

Aggiungere le seguenti istruzioni Imports (Visual Basic) o direttive using (C#) all'inizio del file di codice, se non sono già presenti.

Imports Microsoft.Office.Interop

using System.Collections.Generic;
using Excel = Microsoft.Office.Interop.Excel;
using Word = Microsoft.Office.Interop.Word;

Per creare un elenco di conti correnti bancari

In Esplora soluzioni fare clic con il pulsante destro del mouse sul nome del progetto, fare clic su Aggiungi e quindi su Classe. Denominare la classe Account.vb se si usa Visual Basic, Account.cs se si usa C#. Fare clic su Aggiungi.
Sostituire la definizione della classe Account con il codice seguente. Le definizioni di classe usano le proprietà implementate automaticamente, una novità di Visual Basic in Visual Studio 2010. Per altre informazioni, vedere Proprietà implementate automaticamente (Visual Basic).
```
Public Class Account
    Property ID As Integer = -1
    Property Balance As Double 
End Class
```
```
class Account
{
    public int ID { get; set; }
    public double Balance { get; set; }
}
```

Per creare un elenco bankAccounts contenente due conti, aggiungere il seguente codice al metodo ThisAddIn_Startup nei file ThisAddIn.vb o ThisAddIn.cs. Le dichiarazioni dell'elenco usano gli inizializzatori di raccolta, una novità di Visual Basic in Visual Studio 2010. Per altre informazioni, vedere Inizializzatori di raccolte (Visual Basic).

Dim bankAccounts As New List(Of Account) From {
    New Account With {
                          .ID = 345,
                          .Balance = 541.27
                     },
    New Account With {
                          .ID = 123,
                          .Balance = -127.44
                     }
    }

var bankAccounts = new List<Account> 
{
    new Account 
    {
        ID = 345,
        Balance = 541.27
    },
    new Account 
    {
        ID = 123,
        Balance = -127.44
    }
};

Per esportare dati in Excel

Nello stesso file, aggiungere il metodo seguente alla classe ThisAddIn. Il metodo configura una cartella di lavoro di Excel e vi esporta i dati.
```
Sub DisplayInExcel(ByVal accounts As IEnumerable(Of Account),
               ByVal DisplayAction As Action(Of Account, Excel.Range))

    With Me.Application
        ' Add a new Excel workbook.
        .Workbooks.Add()
        .Visible = True
        .Range("A1").Value = "ID"
        .Range("B1").Value = "Balance"
        .Range("A2").Select()

        For Each ac In accounts
            DisplayAction(ac, .ActiveCell)
            .ActiveCell.Offset(1, 0).Select()
        Next 

        ' Copy the results to the Clipboard.
        .Range("A1:B3").Copy()
    End With 
End Sub
```
```
void DisplayInExcel(IEnumerable<Account> accounts,
           Action<Account, Excel.Range> DisplayFunc)
{
    var excelApp = this.Application;
    // Add a new Excel workbook.
    excelApp.Workbooks.Add();
    excelApp.Visible = true;
    excelApp.Range["A1"].Value = "ID";
    excelApp.Range["B1"].Value = "Balance";
    excelApp.Range["A2"].Select();

    foreach (var ac in accounts)
    {
        DisplayFunc(ac, excelApp.ActiveCell);
        excelApp.ActiveCell.Offset[1, 0].Select();
    }
    // Copy the results to the Clipboard.
    excelApp.Range["A1:B3"].Copy();
}
```
In questo metodo vengono usati due nuove funzionalità di C#. Entrambe queste funzionalità sono già esistenti in Visual Basic.
- Il metodo Add ha un parametro facoltativo per specificare un modello particolare. I parametri facoltativi, una novità di Visual C# 2010, consentono di omettere l'argomento per il parametro se si vuole usare il valore predefinito del parametro. Poiché nessun argomento viene inviato nell'esempio precedente, Add usa il modello predefinito e crea una nuova cartella di lavoro. L'istruzione equivalente nelle precedenti versioni di C# richiede un argomento segnaposto: excelApp.Workbooks.Add(Type.Missing).
  
  Per altre informazioni, vedere Argomenti denominati e facoltativi (Guida per programmatori C#).
- Le proprietà Range e Offset dell'oggetto Range usano le funzionalità delle proprietà indicizzate. Questa funzionalità consente di usare tali proprietà dai tipi COM con la tipica sintassi di C# seguente. Le proprietà indicizzate consentono anche di usare la proprietà Value dell'oggetto Range, eliminando la necessità di usare la proprietà Value2. La proprietà Value è indicizzata, ma l'indice è facoltativo. Nell'esempio seguente sono presenti sia argomenti facoltativi sia proprietà indicizzate.
```
// Visual C# 2010 provides indexed properties for COM programming.
excelApp.Range["A1"].Value = "ID";
excelApp.ActiveCell.Offset[1, 0].Select();
```
  Nelle versioni precedenti del linguaggio, è necessaria la seguente sintassi speciale.
```
// In Visual C# 2008, you cannot access the Range, Offset, and Value 
// properties directly.
excelApp.get_Range("A1").Value2 = "ID";
excelApp.ActiveCell.get_Offset(1, 0).Select();
```
  Non è possibile creare proprietà indicizzate personalizzate. La funzionalità supporta solo l'utilizzo di proprietà indicizzate esistenti.
  
  Per altre informazioni, vedere Procedura: utilizzare proprietà indicizzate nella programmazione dell'interoperabilità COM (Guida per programmatori C#).
Aggiungere il seguente codice alla fine di DisplayInExcel per regolare la larghezza delle colonne in modo da adattarle al contenuto.
```
' Add the following two lines at the end of the With statement.
.Columns(1).AutoFit()
.Columns(2).AutoFit()
```
```
excelApp.Columns[1].AutoFit();
excelApp.Columns[2].AutoFit();
```
Queste aggiunte dimostrano un'altra nuova funzionalità di C# 2010: considerare i valori Object restituiti dagli host COM, ad esempio Office, come se fossero di tipo dynamic. Ciò avviene automaticamente quando l'opzione Incorpora tipi di interoperabilità è impostata sul valore predefinito, True, o allo stesso modo, quando si fa riferimento all'assembly con l'opzione del compilatore /link. Il tipo dynamic consente l'associazione tardiva, già disponibile in Visual Basic, ed evita il cast esplicito richiesto in Visual C# 2008 e versioni precedenti del linguaggio.

Ad esempio, excelApp.Columns[1] restituisce un Object e AutoFit è un metodo Range di Excel. In assenza di dynamic, è necessario eseguire il cast dell'oggetto restituito da excelApp.Columns[1] come istanza di Range prima di chiamare il metodo AutoFit.
```
// Casting is required in Visual C# 2008.
((Excel.Range)excelApp.Columns[1]).AutoFit();

// Casting is not required in Visual C# 2010.
excelApp.Columns[1].AutoFit();
```
Per altre informazioni sull'incorporamento di tipi di interoperabilità, vedere le procedure "Per trovare il riferimento all'assembly di interoperabilità primari" e "Per ripristinare la dipendenza di assembly di interoperabilità primario" più avanti in questo argomento. Per altre informazioni su dynamic, vedere dynamic (Riferimenti per C#) o Utilizzo del tipo dinamico (Guida per programmatori C#).

Per richiamare DisplayInExcel

Aggiungere il codice seguente alla fine del metodo ThisAddIn_StartUp. La chiamata a DisplayInExcel contiene due argomenti. Il primo argomento è il nome dell'elenco di conti da elaborare. Il secondo argomento è un'espressione lambda su più righe che definisce la modalità con cui i dati saranno elaborati. I valori ID e balance per ogni conto vengono visualizzati in celle adiacenti e la riga viene visualizzata in rosso se il saldo è inferiore a zero. Le espressioni lambda su più righe sono una nuova funzionalità di Visual Basic 2010. Per altre informazioni, vedere Espressioni lambda (Visual Basic).

DisplayInExcel(bankAccounts,
       Sub(account, cell)
           ' This multiline lambda expression sets custom 
           ' processing rules for the bankAccounts.
           cell.Value = account.ID
           cell.Offset(0, 1).Value = account.Balance

           If account.Balance < 0 Then
               cell.Interior.Color = RGB(255, 0, 0)
               cell.Offset(0, 1).Interior.Color = RGB(255, 0, 0)
           End If 
       End Sub)

DisplayInExcel(bankAccounts, (account, cell) =>
// This multiline lambda expression sets custom processing rules   
// for the bankAccounts.
{
    cell.Value = account.ID;
    cell.Offset[0, 1].Value = account.Balance;
    if (account.Balance < 0)
    {
        cell.Interior.Color = 255;
        cell.Offset[0, 1].Interior.Color = 255;
    }
});

Premere F5 per eseguire il programma. Viene visualizzato un foglio di lavoro di Excel che contiene i dati dei conti.

Per aggiungere un documento di Word

Aggiungere il seguente codice alla fine del metodo ThisAddIn_StartUp per creare un documento di Word contenente un collegamento alla cartella di lavoro di Excel.
```
Dim wordApp As New Word.Application
wordApp.Visible = True
wordApp.Documents.Add()
wordApp.Selection.PasteSpecial(Link:=True, DisplayAsIcon:=True)
```
```
var wordApp = new Word.Application();
wordApp.Visible = true;
wordApp.Documents.Add();
wordApp.Selection.PasteSpecial(Link: true, DisplayAsIcon: true);
```
In questo codice vengono illustrate diverse nuove funzionalità di C#: la possibilità di omettere la parola chiave ref nella programmazione COM, gli argomenti denominati e gli argomenti facoltativi. Queste funzionalità sono già esistenti in Visual Basic. Il metodo PasteSpecial presenta sette parametri, ognuno dei quali è definito come parametro di riferimento facoltativo. Prima di Visual C# 2010, era necessario definire le variabili di oggetto da usare come argomenti per i sette parametri, anche quando non si aveva alcun valore significativo da inviare. Gli argomenti denominati e facoltativi consentono di indicare i parametri a cui si vuol accedere per nome e di inviare argomenti solo a tali parametri. In questo esempio, gli argomenti vengono inviati per indicare che deve essere creato un collegamento alla cartella di lavoro negli Appunti (parametro Link), e che il collegamento verrà visualizzato nel documento di Word come un'icona (parametro DisplayAsIcon). Visual C# 2010 consente anche di omettere la parola chiave ref per questi argomenti. Confrontare il seguente segmento di codice da Visual C# 2008 con la riga singola richiesta in Visual C# 2010:
```
// Call to PasteSpecial in Visual C# 2008. 
object iconIndex = Type.Missing;
object link = true;
object placement = Type.Missing;
object displayAsIcon = true;
object dataType = Type.Missing;
object iconFileName = Type.Missing;
object iconLabel = Type.Missing;
wordApp.Selection.PasteSpecial(ref iconIndex,
                               ref link,
                               ref placement,
                               ref displayAsIcon,
                               ref dataType,
                               ref iconFileName,
                               ref iconLabel);

// Call to PasteSpecial in Visual C# 2010.
wordApp.Selection.PasteSpecial(Link: true, DisplayAsIcon: true);
```

Per eseguire l'applicazione

Premere F5 per eseguire l'applicazione. Excel viene avviato e viene visualizzata una tabella che contiene le informazioni dei due conti in bankAccounts. Quindi verrà visualizzato un documento di Word contenente un collegamento alla tabella di Excel.

Per pulire il progetto completato

In Visual Studio, fare clic su Pulisci soluzione nel menu Compila. In caso contrario, il componente aggiuntivo verrà eseguito ogni volta che si apre Excel nel computer.

Per trovare il riferimento all'assembly di interoperabilità primario

Eseguire nuovamente l'applicazione, ma non fare clic Pulisci soluzione.
Dal menu Start fare clic su Tutti i programmi. Fare clic su Microsoft Visual Studio 2013, quindi su Strumenti di Visual Studio, quindi Prompt dei comandi di Visual Studio (2013).
Digitare ildasm nella finestra del prompt dei comandi di Visual Studio (2013) e quindi premere INVIO. Verrà visualizzata la finestra IL DASM.
Nel menu File della finestra IL DASM fare clic su Apri. Fare doppio clic su Visual Studio 2013 e quindi fare doppio clic su Progetti. Aprire la cartella per il progetto e cercare nella cartella bin/Debug il file nome progetto.dll. Fare doppio clic su nome progetto.dll. Una nuova finestra consente di visualizzare gli attributi del progetto, oltre ai riferimenti ad altri moduli e assembly. Notare che gli spazi dei nomi Microsoft.Office.Interop.Excel e Microsoft.Office.Interop.Word sono inclusi nell'assembly. Per impostazione predefinita in Visual Studio 2013, il compilatore importa i tipi necessari da un assembly di interoperabilità primario di cui viene fatto riferimento nell'assembly.

Per altre informazioni, vedere Procedura: visualizzare il contenuto dell'assembly.
Fare doppio clic sull'icona MANIFESTO. Viene visualizzata una finestra che include un elenco di assembly che contengono gli elementi a cui fa riferimento il progetto. Microsoft.Office.Interop.Excel e Microsoft.Office.Interop.Word non sono inclusi nell'elenco. Poiché i tipi che è necessario importare nell'assembly per il progetto, i riferimenti a un assembly di interoperabilità primario non sono necessari. Ciò rende più semplice la distribuzione. Gli assembly di interoperabilità primari non devono essere presenti nel computer dell'utente e, poiché un'applicazione non richiede la distribuzione di una versione specifica di un assembly di interoperabilità primario, è possibile progettare applicazioni compatibili con più versioni di Office, a condizione che le API necessarie siano presenti in tutte le versioni.

Poiché la distribuzione di assembly di interoperabilità primari non è più necessaria, è possibile creare un'applicazione in scenari avanzati che sia compatibile con più versioni di Office, incluse le versioni precedenti. Tuttavia, questo metodo funziona solo se il codice non usa alcuna API che non sia disponibile nella versione di Office che si sta usando. Non è sempre chiaro se una particolare API fosse disponibile in una versione precedente e per tale motivo l'utilizzo di versioni precedenti di Office non è consigliato.

Nota

Non sono stati pubblicati PIA prima di Office 2003.Di conseguenza, l'unico modo per generare un assembly di interoperabilità per Office 2002 o versioni precedenti consiste nell'importare il riferimento COM.
Chiudere la finestra del manifesto e l'assembly.

Per ripristinare la dipendenza di assembly di interoperabilità primario

In Esplora soluzioni, fare clic su Mostra tutti i file. Espandere la cartella Riferimenti e scegliere Microsoft.Office.Interop.Excel. Premere F4 per visualizzare la finestra Proprietà.
Nella finestra Proprietà, impostare la proprietà Incorpora tipi di interoperabilità da True a False.
Ripetere i passaggi 1 e 2 di questa procedura per Microsoft.Office.Interop.Word.
In C#, commentare le due chiamate Autofit alla fine del metodo DisplayInExcel.
Premere F5 per verificare che il progetto sia ancora eseguito correttamente.
Ripetere i passaggi da 1 a 3 della procedura precedente per aprire la finestra dell'assembly. Notare che Microsoft.Office.Interop.Word e Microsoft.Office.Interop.Excel non sono più presenti nell'elenco di assembly incorporati.
Fare doppio clic sull'icona MANIFESTO e scorrere l'elenco degli assembly di riferimento. Sia Microsoft.Office.Interop.Word sia Microsoft.Office.Interop.Excel sono inclusi nell'elenco. Poiché l'applicazione fa riferimento a Excel e assembly di interoperabilità primari di Word e la proprietà Incorpora tipi di interoperabilità è impostata su False, entrambi gli assembly devono esistere nel computer dell'utente finale.
In Visual Studio, fare clic su Pulisci soluzione nel menu Compila per pulire il progetto completato.

Vedere anche

Condividi tramite