Comment accéder aux objets Office Interop (Guide de programmation C#)

C# possède des fonctionnalités qui simplifient l’accès aux objets d’API Office. Les nouvelles fonctionnalités incluent les arguments nommés et les arguments facultatifs, un nouveau type appelé dynamic et la possibilité de passer des arguments aux paramètres de référence dans les méthodes COM comme s'il s'agissait de paramètres de valeur.

Dans cette rubrique, vous allez utiliser les nouvelles fonctionnalités pour écrire le code qui crée et affiche une feuille de calcul Microsoft Office Excel. Vous écrirez ensuite le code pour ajouter un document Office Word qui contient une icône liée à la feuille de calcul Excel.

Pour effectuer cette procédure pas à pas, Microsoft Office Excel 2007 et Microsoft Office Word 2007, ou versions ultérieures, doivent être installés sur votre ordinateur.

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, consultez Personnalisation de l’IDE.

Pour créer une application console

  1. Démarrez Visual Studio.

  2. Dans le menu Fichier , pointez sur Nouveau, puis cliquez sur Projet. La boîte de dialogue Nouveau projet apparaît.

  3. Dans le volet Modèles installés, développez Visual C#, puis cliquez sur Windows.

  4. Vérifiez en haut de la boîte de dialogue Nouveau projet que .NET Framework 4 (ou version ultérieure) est sélectionné comme version cible de .NET Framework.

  5. Dans le volet Modèles, cliquez sur Application console.

  6. Attribuez un nom à votre projet dans le champ Nom.

  7. Cliquez sur OK.

    Le nouveau projet s’affiche dans l’Explorateur de solutions.

Pour ajouter des références

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

  2. Dans la page Assemblys, sélectionnez Microsoft.Office.Interop.Word dans la liste Nom du composant, puis maintenez la touche CTRL enfoncée et sélectionnez Microsoft.Office.Interop.Excel. Si vous ne voyez pas les assemblys, vous devrez peut-être vous assurer qu’ils sont installés et affichés. Consultez Comment : installer les assemblys PIA (Primary Interop Assembly) d’Office.

  3. Cliquez sur OK.

Pour ajouter les directives using nécessaires

  1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le fichier Program.cs, puis cliquez sur Afficher le code.

  2. Ajoutez les using directives suivantes en haut du fichier de code :

    using Excel = Microsoft.Office.Interop.Excel;
    using Word = Microsoft.Office.Interop.Word;
    

Pour créer une liste de comptes bancaires

  1. Copiez-collez la définition de classe suivante dans Program.cs, sous la classe Program.

    public class Account
    {
        public int ID { get; set; }
        public double Balance { get; set; }
    }
    
  2. Ajoutez le code suivant à la méthode Main pour créer une liste bankAccounts contenant deux comptes.

    // Create a list of accounts.
    var bankAccounts = new List<Account> {
        new Account {
                      ID = 345678,
                      Balance = 541.27
                    },
        new Account {
                      ID = 1230221,
                      Balance = -127.44
                    }
    };
    

Pour déclarer une méthode qui exporte les informations de compte vers Excel

  1. Ajoutez la méthode suivante à la classe Program pour définir une feuille de calcul Excel.

    La méthode Add a un paramètre facultatif pour spécifier un modèle particulier. Les paramètres optionnels, introduits dans C# 4, 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 le code suivant, 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).

    static void DisplayInExcel(IEnumerable<Account> accounts)
    {
        var excelApp = new Excel.Application();
        // Make the object visible.
        excelApp.Visible = true;
    
        // Create a new, empty workbook and add it to the collection returned
        // by property Workbooks. The new workbook becomes the active workbook.
        // Add has an optional parameter for specifying a praticular template.
        // Because no argument is sent in this example, Add creates a new workbook.
        excelApp.Workbooks.Add();
    
        // This example uses a single workSheet. The explicit type casting is
        // removed in a later procedure.
        Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet;
    }
    
  2. À la fin de DisplayInExcel, ajoutez le code suivant. Le code insère les valeurs dans les deux premières colonnes de la première ligne de la feuille de calcul.

    // Establish column headings in cells A1 and B1.
    workSheet.Cells[1, "A"] = "ID Number";
    workSheet.Cells[1, "B"] = "Current Balance";
    
  3. À la fin de DisplayInExcel, ajoutez le code suivant. La boucle foreach place les informations de la liste des comptes dans les deux premières colonnes des lignes successives de la feuille de calcul.

    
    var row = 1;
    foreach (var acct in accounts)
    {
        row++;
        workSheet.Cells[row, "A"] = acct.ID;
        workSheet.Cells[row, "B"] = acct.Balance;
    }
    
  4. À la fin de DisplayInExcel, ajoutez le code suivant pour ajuster les largeurs de colonne au contenu.

    workSheet.Columns[1].AutoFit();
    workSheet.Columns[2].AutoFit();
    

    Les versions antérieures de C# nécessitent un cast explicite pour ces opérations, car ExcelApp.Columns[1] retourne Object, et AutoFit est une méthode Range d’Excel. Les lignes suivantes illustrent le cast.

    ((Excel.Range)workSheet.Columns[1]).AutoFit();
    ((Excel.Range)workSheet.Columns[2]).AutoFit();
    

    C# 4 et versions ultérieures convertit automatiquement l’retourné Object en dynamic si l’assembly est référencé par l’option du compilateur EmbedInteropTypes ou, de manière équivalente, si la propriété Excel incorporer les types Interop a la valeur true. La valeur par défaut de cette propriété est true.

Pour exécuter le projet

  1. À la fin de Main, ajoutez la ligne suivante.

    // Display the list in an Excel spreadsheet.
    DisplayInExcel(bankAccounts);
    
  2. Appuyez sur CTRL+F5.

    Une feuille de calcul Excel s'affiche avec les données des deux comptes.

Pour ajouter un document Word

  1. Pour illustrer d'autres façons grâce auxquelles C# 4, ainsi que les versions ultérieures, améliore la programmation Office, le code suivant ouvre une application Word et crée une icône liée à la feuille de calcul Excel.

    Collez la méthode CreateIconInWordDoc, fournie ultérieurement dans cette étape, dans la classe Program. CreateIconInWordDoc utilise des arguments nommés et facultatifs pour réduire la complexité des appels de méthode à Add et PasteSpecial. Ces appels incorporent deux autres nouvelles fonctionnalités introduites dans C# 4, qui simplifient les appels aux méthodes COM comportant des paramètres de référence. Premièrement, vous pouvez envoyer des arguments aux paramètres de référence comme s'il s'agissait de paramètres de valeur. Autrement dit, vous pouvez envoyer les valeurs directement, sans créer une variable pour chaque paramètre de référence. Le compilateur génère des variables temporaires pour stocker les valeurs d'argument et les ignore lors du retour de l'appel. Ensuite, vous pouvez omettre le mot clé ref dans la liste d'arguments.

    La méthode Add comporte quatre paramètres de référence, tous facultatifs. Dans C# 4.0 ou versions ultérieures, vous pouvez omettre les arguments de tout ou partie des paramètres si vous voulez utiliser leurs valeurs par défaut. Dans C# 3.0 et versions antérieures, un argument doit être fourni pour chaque paramètre et l'argument doit être une variable, car les paramètres sont des paramètres de référence.

    La méthode PasteSpecial insère le contenu du Presse-papiers. La méthode comporte sept paramètres de référence, tous facultatifs. Le code suivant spécifie des arguments pour deux d'entre eux : Link pour créer un lien vers la source du contenu du Presse-papiers et DisplayAsIcon pour afficher le lien sous forme d'icône. Dans C# 4.0 et versions ultérieures, vous pouvez utiliser des arguments nommés pour ces deux-là et omettre les autres. Bien qu'il s'agisse de paramètres de référence, vous n'avez pas à utiliser le mot clé ref ou à créer des variables à envoyer tant qu'arguments. Vous pouvez envoyer les valeurs directement. Dans C# 3.0 et versions antérieures, vous devez fournir un argument de variable pour chaque paramètre de référence.

    static void CreateIconInWordDoc()
    {
        var wordApp = new Word.Application();
        wordApp.Visible = true;
    
        // The Add method has four reference parameters, all of which are
        // optional. Visual C# allows you to omit arguments for them if
        // the default values are what you want.
        wordApp.Documents.Add();
    
        // PasteSpecial has seven reference parameters, all of which are
        // optional. This example uses named arguments to specify values
        // for two of the parameters. Although these are reference
        // parameters, you do not need to use the ref keyword, or to create
        // variables to send in as arguments. You can send the values directly.
        wordApp.Selection.PasteSpecial( Link: true, DisplayAsIcon: true);
    }
    

    Dans C# 3.0 ou dans les versions antérieures du langage, le code plus complexe suivant est requis.

    static void CreateIconInWordDoc2008()
    {
        var wordApp = new Word.Application();
        wordApp.Visible = true;
    
        // The Add method has four parameters, all of which are optional.
        // In Visual C# 2008 and earlier versions, an argument has to be sent
        // for every parameter. Because the parameters are reference
        // parameters of type object, you have to create an object variable
        // for the arguments that represents 'no value'.
    
        object useDefaultValue = Type.Missing;
    
        wordApp.Documents.Add(ref useDefaultValue, ref useDefaultValue,
            ref useDefaultValue, ref useDefaultValue);
    
        // PasteSpecial has seven reference parameters, all of which are
        // optional. In this example, only two of the parameters require
        // specified values, but in Visual C# 2008 an argument must be sent
        // for each parameter. Because the parameters are reference parameters,
        // you have to contruct variables for the arguments.
        object link = true;
        object displayAsIcon = true;
    
        wordApp.Selection.PasteSpecial( ref useDefaultValue,
                                        ref link,
                                        ref useDefaultValue,
                                        ref displayAsIcon,
                                        ref useDefaultValue,
                                        ref useDefaultValue,
                                        ref useDefaultValue);
    }
    
  2. À la fin de Main, ajoutez l'instruction suivante.

    // Create a Word document that contains an icon that links to
    // the spreadsheet.
    CreateIconInWordDoc();
    
  3. À la fin de DisplayInExcel, ajoutez l'instruction suivante. La méthode Copy ajoute la feuille de calcul au Presse-papiers.

    // Put the spreadsheet contents on the clipboard. The Copy method has one
    // optional parameter for specifying a destination. Because no argument
    // is sent, the destination is the Clipboard.
    workSheet.Range["A1:B3"].Copy();
    
  4. Appuyez sur CTRL+F5.

    Un document Word s'affiche avec une icône. Double-cliquez sur l'icône pour afficher la feuille de calcul au premier plan.

Pour définir la propriété Incorporer les types interop

  1. D'autres améliorations sont possibles lorsque vous appelez un type COM qui ne nécessite pas un assembly PIA (Primary Interop Assembly) au moment de l'exécution. La suppression de la dépendance vis-à-vis des assemblys PIA aboutit à l'indépendance des versions et facilite le déploiement. Pour plus d’informations sur les avantages de la programmation sans assemblys PIA, consultez Procédure pas à pas : incorporation de types provenant d’assemblys managés.

    En outre, la programmation est plus facile, car les types qui sont requis et retournés par les méthodes COM peuvent être représentés par l'utilisation du type dynamic à la place d'Object. Les variables de type dynamic ne sont pas évaluées avant l'exécution, ce qui élimine la nécessité d'un cast explicite. Pour plus d’informations, consultez Utilisation du type dynamic.

    Dans C# 4, l'incorporation des informations de type au lieu de l'utilisation des assemblys PIA est le comportement par défaut. En raison de ce comportement par défaut, plusieurs des exemples précédents sont simplifiés, car un cast explicite n'est pas requis. Par exemple, la déclaration de worksheet dans DisplayInExcel est écrite sous la forme Excel._Worksheet workSheet = excelApp.ActiveSheet plutôt que sous la forme Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet. Les appels à AutoFit dans la même méthode nécessiteraient également un cast explicite sans la valeur par défaut, parce que ExcelApp.Columns[1] retourne un Object et que AutoFit est une méthode Excel. Le code suivant illustre le cast.

    ((Excel.Range)workSheet.Columns[1]).AutoFit();
    ((Excel.Range)workSheet.Columns[2]).AutoFit();
    
  2. Pour modifier la valeur par défaut et utiliser les assemblys PIA au lieu d’incorporer les informations de type, développez le nœud Références dans l’Explorateur de solutions, puis sélectionnez Microsoft.Office.Interop.Excel ou Microsoft.Office.Interop.Word.

  3. Si la fenêtre Propriétés n’apparaît pas, appuyez sur F4.

  4. Recherchez Incorporer les types interop dans la liste des propriétés et attribuez-lui la valeur False. De manière équivalente, vous pouvez compiler à l’aide de l’option de compilateur References au lieu de EmbedInteropTypes à partir d’une invite de commandes.

Pour ajouter une mise en forme supplémentaire au tableau

  1. Remplacez les deux appels à AutoFit de DisplayInExcel avec l'instruction suivante.

    // Call to AutoFormat in Visual C# 2010.
    workSheet.Range["A1", "B3"].AutoFormat(
        Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);
    

    La méthode AutoFormat a sept paramètres de valeur, tous facultatifs. Les arguments nommés et les arguments facultatifs vous permettent de fournir des arguments pour tout ou partie des paramètres, voire pour aucun. Dans l'instruction précédente, un argument est fourni pour un seul des paramètres, Format. Comme Format est le premier paramètre dans la liste des paramètres, vous n'avez pas à fournir le nom du paramètre. Cependant, l'instruction peut être plus facile à comprendre si le nom du paramètre est inclus, comme illustré dans le code suivant.

    // Call to AutoFormat in Visual C# 2010.
    workSheet.Range["A1", "B3"].AutoFormat(Format:
        Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);
    
  2. Appuyez sur CTRL+F5 pour afficher le résultat. D’autres formats sont listés dans l’énumération XlRangeAutoFormat.

  3. Comparez l'instruction de l'étape 1 au code suivant, qui indique les arguments requis dans C# 3.0 et versions antérieures.

    // The AutoFormat method has seven optional value parameters. The
    // following call specifies a value for the first parameter, and uses
    // the default values for the other six.
    
    // Call to AutoFormat in Visual C# 2008. This code is not part of the
    // current solution.
    excelApp.get_Range("A1", "B4").AutoFormat(Excel.XlRangeAutoFormat.xlRangeAutoFormatTable3,
        Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
        Type.Missing);
    

Exemple

L'exemple de code suivant illustre l'exemple complet.

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

namespace OfficeProgramminWalkthruComplete
{
    class Walkthrough
    {
        static void Main(string[] args)
        {
            // Create a list of accounts.
            var bankAccounts = new List<Account>
            {
                new Account {
                              ID = 345678,
                              Balance = 541.27
                            },
                new Account {
                              ID = 1230221,
                              Balance = -127.44
                            }
            };

            // Display the list in an Excel spreadsheet.
            DisplayInExcel(bankAccounts);

            // Create a Word document that contains an icon that links to
            // the spreadsheet.
            CreateIconInWordDoc();
        }

        static void DisplayInExcel(IEnumerable<Account> accounts)
        {
            var excelApp = new Excel.Application();
            // Make the object visible.
            excelApp.Visible = true;

            // Create a new, empty workbook and add it to the collection returned
            // by property Workbooks. The new workbook becomes the active workbook.
            // Add has an optional parameter for specifying a praticular template.
            // Because no argument is sent in this example, Add creates a new workbook.
            excelApp.Workbooks.Add();

            // This example uses a single workSheet.
            Excel._Worksheet workSheet = excelApp.ActiveSheet;

            // Earlier versions of C# require explicit casting.
            //Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet;

            // Establish column headings in cells A1 and B1.
            workSheet.Cells[1, "A"] = "ID Number";
            workSheet.Cells[1, "B"] = "Current Balance";

            var row = 1;
            foreach (var acct in accounts)
            {
                row++;
                workSheet.Cells[row, "A"] = acct.ID;
                workSheet.Cells[row, "B"] = acct.Balance;
            }

            workSheet.Columns[1].AutoFit();
            workSheet.Columns[2].AutoFit();

            // Call to AutoFormat in Visual C#. This statement replaces the
            // two calls to AutoFit.
            workSheet.Range["A1", "B3"].AutoFormat(
                Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);

            // Put the spreadsheet contents on the clipboard. The Copy method has one
            // optional parameter for specifying a destination. Because no argument
            // is sent, the destination is the Clipboard.
            workSheet.Range["A1:B3"].Copy();
        }

        static void CreateIconInWordDoc()
        {
            var wordApp = new Word.Application();
            wordApp.Visible = true;

            // The Add method has four reference parameters, all of which are
            // optional. Visual C# allows you to omit arguments for them if
            // the default values are what you want.
            wordApp.Documents.Add();

            // PasteSpecial has seven reference parameters, all of which are
            // optional. This example uses named arguments to specify values
            // for two of the parameters. Although these are reference
            // parameters, you do not need to use the ref keyword, or to create
            // variables to send in as arguments. You can send the values directly.
            wordApp.Selection.PasteSpecial(Link: true, DisplayAsIcon: true);
        }
    }

    public class Account
    {
        public int ID { get; set; }
        public double Balance { get; set; }
    }
}

Voir aussi