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

Article
06/10/2015

Visual Studio 2010 présente les nouvelles fonctionnalités de C# et de Visual Basic qui améliorent la programmation Microsoft Office. Chaque langage a ajouté des fonctionnalités déjà existantes dans l'autre langage.

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

Les deux langages autorisent l'incorporation d'informations de type, qui permet de déployer des assemblys interagissant avec les composants COM sans déployer les assemblys PIA (Primary Interop Assemblies) 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 beaucoup d'entre elles sont aussi utiles en 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 allez ensuite créer un document Word contenant un lien vers le classeur. Enfin, vous découvrirez comment activer ou désactiver la dépendance d'assembly PIA.

Composants requis

Microsoft Office Excel 2013 (ou version 2007 ou ultérieure) et Microsoft Office Word 2013 (ou version 2007 ou ultérieure) doivent être installés sur votre ordinateur pour que vous puissiez exécuter cette procédure pas à pas.

Si vous utilisez un système d'exploitation antérieur à Windows Vista, assurez-vous que .NET Framework 2,0 est installé.

Notes

Il est possible que pour certains des éléments de l'interface utilisateur de Visual Studio, votre ordinateur affiche des noms ou des emplacements différents de ceux indiqués 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, voir Paramètres Visual Studio.

Pour configurer 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 2013 (ou 2010 ou 2007).
Dans le volet Modèles, cliquez sur Complément Excel 2013 (ou Complément Excel 2010 ou Complément Excel 2007).
Regardez en haut du volet Modèles pour vous assurer que .NET Framework 4, ou version ultérieure, apparaît dans la zone Framework cible.
Si vous le désirez, entrez un nom pour votre projet dans la zone Nom.
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 de votre projet, puis cliquez sur Ajouter une référence. La boîte de dialogue Ajouter une référence s'affiche.
Sous l'onglet Assemblys, sélectionnez Microsoft.Office.Interop.Excel, version 15.0.0.0 (ou version 14.0.0.0 pour Excel 2010 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 15.0.0.0 (ou version 14.0.0.0 pour Word 2010 ou 12.0.0.0 pour Word 2007). Si les assemblys n'apparaissent pas, vous devez vous assurer qu'ils sont installés et s'affichent (voir Comment : installer les assemblys PIA (Primary Interop Assembly) d'Office).
Cliquez sur OK.

Pour ajouter les instructions Imports ou les directives using nécessaires

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 suivantes (Visual Basic) ou les directives using (C#) en haut du fichier de code, si elles ne sont pas déjà présentes.

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, cliquez sur Ajouter, puis sur Classe. Nommez la classe Account.vb si vous utilisez Visual Basic ou Account.cs si vous utilisez C#. Cliquez sur Ajouter.
Remplacez la définition de la classe Account par le code suivant : Les définitions de classe utilisent les propriétés implémentées automatiquement (nouveauté en Visual Basic 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 les initialiseurs de collection (nouveauté en Visual Basic dans Visual Studio 2010). Pour plus d'informations, consultez 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, vers lequel elle exporte les données.
```
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 possède un paramètre facultatif pour spécifier un modèle particulier. Les paramètres optionnels, introduits dans Visual C# 2010, vous permettent d'omettre l'argument du paramètre, si vous souhaitez utiliser la valeur par défaut de ce dernier. Dans la mesure où 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 dans les versions antérieures de C# nécessite 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é des propriétés indexées. Cette fonctionnalité vous permet de consommer ces propriétés à partir 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, ce qui rend superflue l'utilisation de la propriété Value2. La propriété Value est indexée, mais l'index est optionnel. 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 uniquement en charge la consommation de 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#).
À la fin de DisplayInExcel, ajoutez le code suivant pour ajuster les largeurs de colonne au 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 fonctionnalité nouvelle de C# 2010 : traiter les valeurs Object retournées par les hôtes COM tels qu'Office comme si leur type était dynamic. Cela se produit automatiquement quand incorporer les types interop est défini à sa valeur par défaut, True, ou, de façon équivalente, lorsque l'assembly est référencé par l'option du compilateur /link. Le type dynamic permet la liaison tardive, déjà disponible en Visual Basic, et évite le cast explicite requis en Visual C# 2008 et dans les versions antérieures du langage.

Par exemple, excelApp.Columns[1] retourne un Object et AutoFit est une méthode Range Excel. Sans dynamic, vous devez effectuer un cast de l'objet retourné par excelApp.Columns[1] sous la forme d'une 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 » plus loin dans cette rubrique. Pour plus d'informations sur 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 est le nom de la liste des comptes à traiter. Le deuxième argument est une expression lambda multiligne qui définit comment les données doivent être traitées. Les valeurs ID et balance 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 sont 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 s'affiche avec les données des comptes.

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 fonctionnalités nouvelles en C# : la possibilité d'omettre le mot clé ref dans la 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, tous définis en tant que paramètres de référence optionnels. Avant Visual C# 2010, vous deviez définir les variables d'objet à utiliser comme arguments pour les sept paramètres, même si vous n'aviez aucune valeur significative à transmettre. Les arguments nommés et les arguments facultatifs vous permettent de désigner les paramètres auxquels vous souhaitez accéder par leur nom et d'envoyer des arguments à ces seuls paramètres. Dans cet exemple, les arguments sont envoyés pour indiquer qu'un lien vers le classeur dans le Presse-papiers doit être créé (paramètre Link) et que ce lien doit être affiché dans le document Word sous 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 et 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 qui contient les informations des deux comptes de bankAccounts. Puis, un document Word apparaît qui contient un lien vers le tableau Excel.

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 ouvrirez 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. Puis, cliquez successivement sur Microsoft Visual Studio 2013, Visual Studio Tools et Invite de commandes de Visual Studio (2013).
Entrez ildasm dans l'Invite de commandes de Visual Studio (2013), puis appuyez sur ENTRÉE. La fenêtre IL DASM s'affiche.
Dans le menu Fichier de la fenêtre IL DASM, cliquez sur Ouvrir. Double-cliquez sur Visual Studio 2013, puis sur Projets. Ouvrez le dossier de votre projet et, dans le dossier bin/Debug, recherchez nom de votre projet.dll. Double-cliquez sur nom de votre projet.dll. Une nouvelle fenêtre affiche les attributs de votre projet, en plus des références à d'autres modules et assemblys. Remarquez 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 2013, le compilateur importe les types dont vous avez besoin à partir d'un assembly PIA référencé dans votre assembly.

Pour plus d'informations, consultez Comment : afficher le contenu d'un assembly.
Double-cliquez sur l'icône MANIFESTE. Une fenêtre affiche la liste des assemblys contenant 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 dont votre projet a besoin ont été importés dans votre assembly, les références à un assembly PIA ne sont pas requis. Le déploiement s'en trouve facilité. Les assemblys PIA ne doivent pas être présents sur l'ordinateur de l'utilisateur ; comme une application ne nécessite pas le déploiement d'une version spécifique d'un assembly PIA, les applications peuvent être conçues pour fonctionner avec plusieurs versions d'Office, sous réserve que les API nécessaires existent dans toutes les versions.

Le déploiement d'assemblys PIA n'étant plus nécessaire, vous pouvez créer une application dans les scénarios avancés qui fonctionne avec plusieurs versions d'Office, y compris les versions antérieures. Cependant, cela ne fonctionne que si votre code n'utilise pas d'API qui ne sont pas disponibles dans la version d'Office que vous utilisez. Comme il n'est pas toujours évident de savoir si une API particulière était disponible dans une version antérieure, l'utilisation de versions antérieures d'Office n'est pas recommandée.

Notes

Jusqu'à Office 2003, Office ne publiait pas les assemblys PIA.Par conséquent, le seul moyen de générer un assembly d'interopérabilité pour Office 2002 ou 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, choisissez Afficher tous les fichiers. Développez le dossier References 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, modifiez la valeur de la propriété Incorporer les types interop de True en False.
Répétez les étapes 1 et 2 de cette procédure pour Microsoft.Office.Interop.Word.
Dans C#, commentez les deux appels à Autofit à la fin de la méthode DisplayInExcel.
Appuyez sur F5 pour vérifier que le projet continue de s'exécuter 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 sont plus dans la liste des assemblys incorporés.
Double-cliquez sur l'icône MANIFESTE et faites défiler la liste des assemblys référencés. Microsoft.Office.Interop.Word et Microsoft.Office.Interop.Excel figurent tous deux dans la liste. Comme l'application référence les assemblys PIA Excel et Word, et que la propriété Incorporer les types interop 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 achevé.

Voir aussi

Partager via