Procédure pas à pas : programmation Office (C# et Visual Basic)

Article
08/10/2011

Visual Studio 2010 introduit de nouvelles fonctionnalités en C# et Visual Basic qui améliorent la programmation Microsoft Office. Chaque langage dispose de fonctionnalités supplémentaires qui existent déjà dans l'autre langage.

Les nouvelles fonctionnalités disponibles en C# incluent des arguments nommés et facultatifs, des valeurs de retour ayant le type dynamic, et en programmation COM, la possibilité d'omettre le mot clé ref et d'accéder à des propriétés indexées. Les nouvelles fonctionnalités disponibles en Visual Basic incluent des propriétés implémentées automatiquement, des instructions d'expressions lambda et des initialiseurs de collection.

Les deux langages autorisent l'incorporation d'informations de type, ce qui permet de déployer les assemblys interagissant avec les composants COM sans déployer les assemblys PIA (Primary Interop Assembly) sur l'ordinateur de l'utilisateur. Pour plus d'informations, consultez Procédure pas à pas : incorporation de types provenant d'assemblys managés (C# et Visual Basic).

Cette procédure pas à pas montre les nouvelles fonctionnalités dans le contexte de la programmation Office, mais un grand nombre d'entre elles sont également utiles pour la programmation générale. Dans la procédure pas à pas, vous utiliserez d'abord une application de type Complément Excel pour créer un classeur Excel. Vous créerez ensuite un document Word qui contient un lien vers le classeur. Enfin, vous découvrirez comment la dépendance d'assembly PIA peut être activée et désactivée.

Composants requis

Vous devez avoir installé Microsoft Office Excel 2010 ou 2007 et Microsoft Office Word 2010 ou 2007 sur votre ordinateur pour pouvoir exécuter cette procédure pas à pas.

Si vous utilisez un système d'exploitation plus ancien que Windows Vista, vérifiez que le .NET Framework 2.0 est installé.

Notes

Il est possible que votre ordinateur affiche des noms ou des emplacements différents pour certains des éléments d'interface utilisateur de Visual Studio dans les instructions suivantes. L'édition de Visual Studio dont vous disposez et les paramètres que vous utilisez déterminent ces éléments. Pour plus d'informations, consultez Paramètres Visual Studio.

Pour installer une application de type Complément Excel

Démarrez Visual Studio.
Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.
Dans le volet Modèles installés, développez Visual Basic ou Visual C#, développez Office, puis cliquez sur 2010 (ou 2007 si vous utilisez Office 2007).
Dans le volet Modèles, cliquez sur Complément Excel 2010 (ou Complément Excel 2007).
Vérifiez en haut du volet Modèles que .NET Framework 4 apparaît dans la zone Framework cible.
Tapez un nom pour votre projet dans la zone Nom, si vous le souhaitez.
Cliquez sur OK.
Le nouveau projet s'affiche dans l'Explorateur de solutions.

Pour ajouter des références

Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nom du projet, puis cliquez sur Ajouter une référence. La boîte de dialogue Ajouter une référence s'affiche.
Sous l'onglet .NET, sélectionnez Microsoft.Office.Interop.Excel, version 14.0.0.0 (ou version 12.0.0.0 pour Excel 2007), dans la liste Nom du composant, puis maintenez la touche CTRL enfoncée et sélectionnez Microsoft.Office.Interop.Word, version 14.0.0.0 (ou version 12.0.0.0 pour Word 2007).
Cliquez sur OK.

Pour ajouter les instructions Imports ou les directives using requises

Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le fichier ThisAddIn.vb ou ThisAddIn.cs, puis cliquez sur Afficher le code.

Ajoutez les instructions Imports (Visual Basic) ou les directives using (C#) suivantes en haut du fichier de code, le cas échéant.

Imports Microsoft.Office.Interop

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

Pour créer une liste de comptes bancaires

Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nom de votre projet, puis cliquez sur Ajouter et sur Classe. Nommez le classe Account.vb si vous utilisez Visual Basic ou Account.cs si vous employez C#. Cliquez sur Ajouter.
Remplacez la définition de la classe Account par le code suivant. Les définitions de classe utilisent des propriétés implémentées automatiquement, une nouvelle fonctionnalité Visual Basic disponible dans Visual Studio 2010. Pour plus d'informations, consultez Propriétés implémentées automatiquement (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; }
}
```

Pour créer une liste bankAccounts qui contient deux comptes, ajoutez le code suivant à la méthode ThisAddIn_Startup dans ThisAddIn.vb ou ThisAddIn.cs. Les déclarations de liste utilisent des initialiseurs de collection, une nouvelle fonctionnalité Visual Basic disponible dans Visual Studio 2010. Pour plus d'informations, consultez Vue d'ensemble des initialiseurs de collections (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
    }
};

Pour exporter des données vers Excel

Dans le même fichier, ajoutez la méthode suivante à la classe ThisAddIn. La méthode configure un classeur Excel et exporte les données vers ce dernier.
```
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();
}
```
Deux nouvelles fonctionnalités C# sont utilisées dans cette méthode. Ces deux fonctionnalités existent déjà en Visual Basic.
- La méthode Add comporte un paramètre optionnel permettant de spécifier un modèle particulier. Les paramètres optionnels, qui sont des nouveautés de Visual C# 2010, vous permettent d'omettre l'argument qui leur est associé si vous voulez utiliser leur valeur par défaut. Étant donné qu'aucun argument n'est envoyé dans l'exemple précédent, Add utilise le modèle par défaut et crée un classeur. L'instruction équivalente des versions antérieures de C# requiert un argument d'espace réservé : excelApp.Workbooks.Add(Type.Missing).
  
  Pour plus d'informations, consultez Arguments nommés et facultatifs (Guide de programmation C#).
- Les propriétés Range et Offset de l'objet Range utilisent la fonctionnalité Propriétés indexées. Cette fonctionnalité vous permet d'utiliser ces propriétés des types COM à l'aide de la syntaxe C# standard suivante. Les propriétés indexées vous permettent également d'utiliser la propriété Value de l'objet Range, en supprimant le besoin d'utiliser la propriété Value2. La propriété Value est indexée, mais l'index est facultatif. Les arguments facultatifs et les propriétés indexées fonctionnent ensemble dans l'exemple suivant.
```
// Visual C# 2010 provides indexed properties for COM programming.
excelApp.Range["A1"].Value = "ID";
excelApp.ActiveCell.Offset[1, 0].Select();
```
  Dans les versions antérieures du langage, la syntaxe spéciale suivante est requise :
```
// 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();
```
  Vous ne pouvez pas créer vos propres propriétés indexées. La fonctionnalité prend en charge uniquement l'utilisation des propriétés indexées existantes.
  
  Pour plus d'informations, consultez Comment : utiliser des propriétés indexées dans la programmation COM Interop (Guide de programmation C#).
Ajoutez le code suivant à la fin de DisplayInExcel pour ajuster les largeurs de colonne en fonction du contenu.
```
' 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();
```
Ces ajouts illustrent une autre nouveauté de C# 2010 : le traitement des valeurs Object retournées par les hôtes COM tels qu'Office comme si elles étaient de type dynamic. Cette situation se produit automatiquement lorsque la propriété Incorporer les types d'interopérabilité est définie à sa valeur par défaut, True, ou, de façon équivalente, lorsque l'assembly est référencé par l'option de compilateur /link. Le type dynamic autorise une liaison tardive, déjà disponible en Visual Basic, et évite le cast explicite requis en Visual C# 2008 et les versions antérieures du langage.

Par exemple, excelApp.Columns[1] retourne un Object et AutoFit est une méthode Range Excel. Sans le type dynamic, vous devez effectuer un cast de l'objet retourné par excelApp.Columns[1] en tant qu'instance de Range avant d'appeler la méthode 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();
```
Pour plus d'informations sur l'incorporation des types d'interopérabilité, consultez les procédures « Pour rechercher la référence d'assembly PIA » et « Pour restaurer la dépendance d'assembly PIA » ultérieurement dans cette rubrique. Pour plus d'informations sur le type dynamic, consultez dynamic (Référence C#) ou Utilisation du type dynamic (Guide de programmation C#).

Pour appeler DisplayInExcel

Ajoutez le code suivant à la fin de la méthode ThisAddIn_StartUp. L'appel à DisplayInExcel contient deux arguments. Le premier argument correspond au nom de la liste de comptes à traiter. Le deuxième argument est une expression lambda multiligne qui détermine comment les données seront traitées. Les valeurs balance et ID de chaque compte s'affichent dans des cellules adjacentes et la ligne s'affiche en rouge si le solde est inférieur à zéro. Les expressions lambda multilignes représentent une nouvelle fonctionnalité de Visual Basic 2010. Pour plus d'informations, consultez Expressions 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;
    }
});

Pour exécuter le programme, appuyez sur F5. Une feuille de calcul Excel contenant les données des comptes s'affiche.

Pour ajouter un document Word

Ajoutez le code suivant à la fin de la méthode ThisAddIn_StartUp pour créer un document Word qui contient un lien vers le classeur 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);
```
Ce code illustre plusieurs nouvelles fonctionnalités de C# : la possibilité d'omettre le mot clé ref en programmation COM, les arguments nommés et les arguments facultatifs. Ces fonctionnalités existent déjà en Visual Basic. La méthode PasteSpecial comporte sept paramètres qui sont tous définis en tant que paramètres de référence optionnels. Avant Visual C# 2010, vous deviez définir les variables objets à utiliser comme arguments pour les sept paramètres, même si vous n'aviez pas de valeurs significatives à envoyer. Les arguments nommés et facultatifs vous permettent de désigner les paramètres auxquels vous voulez accéder par nom et d'envoyer des arguments uniquement à ces paramètres. Dans cet exemple, les arguments sont envoyés pour indiquer qu'un lien vers le classeur se trouvant dans le Presse-papiers doit être créé (paramètre Link) et que ce lien doit être affiché dans le document Word sous la forme d'une icône (paramètre DisplayAsIcon). Visual C# 2010 vous permet également d'omettre le mot clé ref pour ces arguments. Comparez le segment de code suivant de Visual C# 2008 à la ligne unique requise en 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);
```

Pour exécuter l'application

Appuyez sur F5 pour exécuter l'application. Excel démarre et affiche un tableau contenant les informations des deux comptes de la liste bankAccounts. Un document Word contenant un lien vers le tableau Excel s'affiche ensuite.

Pour nettoyer le projet terminé

Dans Visual Studio, cliquez sur Nettoyer la solution dans le menu Générer. Sinon, le complément s'exécutera chaque fois que vous ouvrez Excel sur votre ordinateur.

Pour rechercher la référence d'assembly PIA

Exécutez de nouveau l'application, mais ne cliquez pas sur Nettoyer la solution.
Dans le menu Démarrer, cliquez sur Tous les programmes. Cliquez ensuite sur Microsoft Visual Studio 2010, puis sur Visual Studio Tools et sur Invite de commandes de Visual Studio (2010).
Tapez ildasm dans la fenêtre Invite de commandes de Visual Studio (2010), puis appuyez sur ENTRÉE. La fenêtre IL DASM s'affiche.
Dans le menu Fichier dans la fenêtre IL DASM, cliquez sur Ouvrir. Double-cliquez sur Visual Studio 2010, puis sur Projets. Ouvrez le dossier de votre projet et recherchez votre nom de projet.dll dans le dossier bin/Debug. Double-cliquez sur votre nom de projet.dll. Une nouvelle fenêtre affiche les attributs de votre projet, en plus des références aux autres modules et assemblys. Notez que les espaces de noms Microsoft.Office.Interop.Excel et Microsoft.Office.Interop.Word sont inclus dans l'assembly. Par défaut, dans Visual Studio 2010, le compilateur importe les types requis dans votre assembly à partir d'un assembly PIA référencé.

Pour plus d'informations, consultez Comment : afficher le contenu d'un assembly.
Double-cliquez sur l'icône MANIFEST. Une fenêtre s'affiche, contenant une liste des assemblys qui comportent les éléments référencés par le projet. Microsoft.Office.Interop.Excel et Microsoft.Office.Interop.Word ne sont pas inclus dans la liste. Étant donné que les types requis par votre projet ont été importés dans votre assembly, les références à un assembly PIA ne sont pas nécessaires. Le déploiement est ainsi simplifié. Il n'est pas utile que les assemblys PIA soient présents sur l'ordinateur de l'utilisateur et, étant donné que les applications ne requièrent pas le déploiement d'une version spécifique d'un assembly PIA, elles peuvent être conçues pour utiliser plusieurs versions d'Office, à condition que les API nécessaires existent dans toutes les versions.

Étant donné que le déploiement d'assemblys PIA n'est plus nécessaire, vous pouvez créer dans des scénarios avancés une application qui fonctionne avec plusieurs versions d'Office, y compris avec les versions antérieures. Toutefois, cela n'est possible que si votre code utilise seulement des API disponibles dans la version d'Office que vous employez. Il n'est pas toujours facile de savoir si une API particulière est disponible dans une version antérieure ; c'est pour cette raison qu'il n'est pas recommandé d'utiliser les versions antérieures d'Office.

Notes

Aucun assembly PIA n'a été publié avant Office 2003. Par conséquent, la seule méthode permettant de générer un assembly d'interopérabilité pour Office 2002 ou les versions antérieures consiste à importer la référence COM.
Fermez la fenêtre de manifeste et la fenêtre d'assembly.

Pour restaurer la dépendance d'assembly PIA

Dans l'Explorateur de solutions, cliquez sur le bouton Afficher tous les fichiers. Développez le dossier Références et sélectionnez Microsoft.Office.Interop.Excel. Appuyez sur F4 pour afficher la fenêtre Propriétés.
Dans la fenêtre Propriétés, remplacez la valeur True de la propriété Incorporer les types d'interopérabilité par False.
Répétez les étapes 1 et 2 de cette procédure pour Microsoft.Office.Interop.Word.
En C#, commentez les deux appels à Autofit à la fin de la méthode DisplayInExcel.
Appuyez sur F5 pour vérifier que le projet s'exécute toujours correctement.
Répétez les étapes 1 à 3 de la procédure précédente pour ouvrir la fenêtre d'assembly. Notez que Microsoft.Office.Interop.Word et Microsoft.Office.Interop.Excel ne figurent plus dans la liste d'assemblys incorporés.
Double-cliquez sur l'icône MANIFEST et faites défiler la liste d'assemblys référencés. Microsoft.Office.Interop.Word et Microsoft.Office.Interop.Excel figurent tous deux dans la liste. Étant donné que l'application référence les assemblys PIA Excel et Word, et que la propriété Incorporer les types d'interopérabilité a la valeur False, les deux assemblys doivent exister sur l'ordinateur de l'utilisateur final.
Dans Visual Studio, cliquez sur Nettoyer la solution dans le menu Générer pour nettoyer le projet terminé.

Voir aussi

Partager via