Freigeben über

Gewusst wie: Zugreifen auf Office-Interop-Objekte mithilfe von Visual C#-Funktionen (C#-Programmierhandbuch)

  • Artikel

Ab Visual C# 2010 gibt es neue Funktionen, die den Zugriff auf Office-API-Objekte vereinfachen. Zu den neuen Funktionen zählen benannte und optionale Argumente, ein neuer Typ namens dynamic und die Möglichkeit, Argumente an Verweisparameter in COM-Methoden zu übergeben, als handele es sich um Werteparameter.

In diesem Thema verwenden Sie die neuen Funktionen, um Code zu schreiben, mit dem ein Microsoft Office Excel-Arbeitsblatt erstellt und angezeigt wird. Dann schreiben Sie Code, um ein Office Word-Dokument hinzuzufügen, das ein Symbol enthält, das mit dem Excel-Arbeitsblatt verknüpft ist.

Um diese exemplarische Vorgehensweise auszuführen, müssen Microsoft Office Excel 2007 und Microsoft Office Word 2007 oder neuere Versionen auf Ihrem Computer installiert sein.

Wenn Sie ein Betriebssystem verwenden, das älter ist als Windows Vista, stellen Sie sicher, dass .NET Framework 2,0 installiert ist.

Hinweis

Auf Ihrem Computer werden möglicherweise andere Namen oder Speicherorte für die Benutzeroberflächenelemente von Visual Studio angezeigt als die in den folgenden Anweisungen aufgeführten. Diese Elemente sind von der jeweiligen Visual Studio-Version und den verwendeten Einstellungen abhängig. Weitere Informationen finden Sie unter Anpassen der Entwicklungseinstellungen in Visual Studio.

So erstellen Sie eine Konsolenanwendung

  1. Starten Sie Visual Studio.

  2. Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt. Das Dialogfeld Neues Projekt wird angezeigt.

  3. Erweitern Sie im Bereich Installierte Vorlagen den Eintrag Visual C#, und klicken Sie dann auf Windows.

  4. Sehen Sie sich den oberen Rand des Dialogfelds Neues Projekt an, um sicherzustellen, dass .NET Framework 4 (oder höher) als Zielframework ausgewählt ist.

  5. Klicken Sie im Bereich Vorlagen auf Konsolenanwendung.

  6. Geben Sie einen Namen für das Projekt im Feld Name ein.

  7. Klicken Sie auf OK.

    Das neue Projekt wird im Projektmappen-Explorer angezeigt.

So fügen Sie Verweise hinzu

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, und klicken Sie dann auf Verweis hinzufügen. Das Dialogfeld Verweis hinzufügen wird angezeigt.

  2. Wählen Sie auf der Seite Assemblys in der Liste Komponentenname den Eintrag Microsoft.Office.Interop.Word aus, und wählen Sie bei gedrückter Strg-Taste Microsoft.Office.Interop.Excel aus. Wenn keine Assemblys sichtbar sind, müssen Sie unter Umständen sicherstellen, dass sie installiert sind und angezeigt werden (siehe Gewusst wie: Installieren von primären Interopassemblys für Office).

  3. Klicken Sie auf OK.

So fügen Sie erforderliche using-Direktiven hinzu

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Datei Program.cs und dann auf Code anzeigen.

  2. Fügen Sie am Anfang der Codedatei die folgenden using-Direktiven hinzu.

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

So erstellen Sie eine Liste mit Bankkonten

  1. Fügen Sie die folgende Klassendefinition in Program.cs unter der Program-Klasse ein.

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

  2. Fügen Sie den folgenden Code der Main-Methode hinzu, um eine bankAccounts-Liste mit zwei Konten zu erstellen.

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

So deklarieren Sie eine Methode, mit der Kontoinformationen in Excel exportiert werden

  1. Fügen Sie die folgende Methode der Program-Klasse hinzu, um ein Excel-Arbeitsblatt einzurichten.

    Die Methode Add hat einen optionalen Parameter zur Angabe einer bestimmten Vorlage. Optionale Parameter, die in Visual C# 2010 neu sind, ermöglichen es Ihnen, das Argument für diesen Parameter auszulassen, wenn Sie den Standardwert des Parameters verwenden möchten. Da im folgenden Beispiel kein Argument gesendet wird, verwendet Add die Standardvorlage und erstellt eine neue Arbeitsmappe. Die entsprechende Anweisung in früheren Versionen von C# erfordert ein Platzhalterargument: 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. Fügen Sie den folgenden Code am Ende von DisplayInExcel hinzu. Der Code fügt Werte in die ersten beiden Spalten der ersten Zeile des Arbeitsblatts ein.

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

  3. Fügen Sie den folgenden Code am Ende von DisplayInExcel hinzu. Die foreach-Schleife fügt die Informationen aus der Liste der Konten in die ersten beiden Spalten der nachfolgenden Zeilen des Arbeitsblattes ein.

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

  4. Fügen Sie den folgenden Code am Ende von DisplayInExcel hinzu, um die Spaltenbreite an den Inhalt anzupassen.

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

    Frühere Versionen von C# erfordern eine explizite Umwandlung für diese Vorgänge, da ExcelApp.Columns[1] ein Object zurückgibt und AutoFit eine Excel Bereich-Methode ist. Die folgenden Zeilen verdeutlichen die Umwandlung.

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

    Visual C# 2010 und höhere Versionen konvertieren das zurückgegebene Object automatisch in dynamic, wenn die /link-Compileroption auf die Assembly verweist oder gleichermaßen wenn die Excel-Eigenschaft Interop-Typen einbetten auf "true" festgelegt ist. Der Standardwert für diese Eigenschaft ist "True".

So führen Sie das Projekt aus

  1. Fügen Sie die folgende Zeile am Ende von Main hinzu.

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

  2. Drücken Sie STRG+F5.

    Ein Excel-Arbeitsblatt mit den Daten der beiden Konten wird angezeigt.

So fügen Sie ein Word-Dokument hinzu

  1. Um zusätzliche Wege zu zeigen, wie Visual C# 2010 und höhere Versionen die Office-Programmierung verbessern, öffnet der folgende Code eine Word-Anwendung und erstellt ein Symbol, das mit dem Excel-Arbeitsblatt verknüpft ist.

    Fügen Sie die Methode CreateIconInWordDoc, die später in diesem Schritt bereitgestellt wird, in die Program-Klasse ein. CreateIconInWordDoc verwendet benannte und optionale Argumente, um die Komplexität der Methodenaufrufe von Add und PasteSpecial zu reduzieren. Diese Aufrufe beinhalten zwei weitere neue Funktionen, die in Visual C# 2010 eingeführt wurden und die Aufrufe von COM-Methoden mit Verweisparametern vereinfachen. Erstens können Sie Argumente an die Verweisparameter senden als handele es sich um Werteparameter. Das heißt, Sie können Werte direkt senden, ohne eine Variable für jeden Verweisparameter zu erstellen. Der Compiler generiert temporäre Variablen, die die Argumentwerte enthalten, und verwirft diese Variablen bei Rückkehr vom Aufruf. Zweitens können Sie das ref-Schlüsselwort in der Argumentliste auslassen.

    Die Add-Methode verfügt über vier Verweisparameter, die alle optional sind. In Visual C# 2010 oder höher können Sie Argumente für einen oder alle Parameter weglassen, wenn Sie deren Standardwerte verwenden möchten. In Visual C# 2008 und früheren Versionen muss ein Argument für jeden Parameter bereitgestellt werden, und das Argument muss eine Variable sein, da es sich bei den Parametern um Verweisparameter handelt.

    Die PasteSpecial-Methode fügt den Inhalt aus der Zwischenablage ein. Die Methode verfügt über sieben Verweisparameter, die alle optional sind. Der folgende Code gibt Argumente für zwei dieser Parameter an: Link, um eine Verknüpfung mit der Quelle des Zwischenablage-Inhalts zu erstellen, und DisplayAsIcon, um die Verknüpfung als Symbol anzuzeigen. In Visual C# 2010 können Sie benannte Argumente für diese zwei verwenden und die anderen weglassen. Obwohl es sich um Verweisparameter handelt, müssen Sie nicht das ref-Schlüsselwort verwenden oder Variablen erstellen, die als Argumente gesendet werden. Sie können die Werte direkt senden. In Visual C# 2008 und früheren Versionen müssen Sie für jeden Verweisparameter ein Variablenargument senden.

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

    In Visual C# 2008 oder früheren Versionen der Sprache ist der folgende komplexere Code erforderlich.

    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. Fügen Sie die folgende Anweisung am Ende von Main hinzu.

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

  3. Fügen Sie die folgende Anweisung am Ende von DisplayInExcel hinzu. Die Copy-Methode fügt das Arbeitsblatt der Zwischenablage hinzu.

    // 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. Drücken Sie STRG+F5.

    Ein Word-Dokument mit einem Symbol wird angezeigt. Doppelklicken Sie auf das Symbol, um das Arbeitsblatt in den Vordergrund zu bringen.

So legen Sie die Eigenschaft "Interop-Typen einbetten" fest

  1. Weitere Verbesserungen sind möglich, wenn Sie einen COM-Typ aufrufen, der keine primäre Interop-Assembly (PIA) zur Laufzeit benötigt. Das Entfernen der Abhängigkeit von PIAs führt zu einer Versionsunabhängigkeit und einfacheren Bereitstellung. Weitere Informationen zu den Vorteilen der Programmierung ohne PIAs finden Sie unter Exemplarische Vorgehensweise: Einbetten von Typen aus verwalteten Assemblys (C# und Visual Basic).

    Darüber hinaus ist die Programmierung einfacher, da die Typen, die erforderlich sind und von COM-Methoden zurückgegeben werden, mithilfe des Typs dynamic anstelle von Object dargestellt werden können. Variablen vom Typ dynamic werden erst zur Laufzeit ausgewertet, wodurch die Notwendigkeit der expliziten Umwandlung entfällt. Weitere Informationen finden Sie unter Verwenden des Typs dynamic (C#-Programmierhandbuch).

    In Visual C# 2010 ist das Einbetten von Typinformationen anstelle eines Einsatzes von PIAs das Standardverhalten. Aufgrund dieses Standardverhaltens werden mehrere der vorherigen Beispiele vereinfacht, da keine explizite Umwandlung erforderlich ist. Beispiel: Die Deklaration von worksheet in DisplayInExcel lautet Excel._Worksheet workSheet = excelApp.ActiveSheet und nicht Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet. Die Aufrufe von AutoFit in derselben Methode würden ebenfalls eine explizite Umwandlung ohne den Standard erfordern, da ExcelApp.Columns[1] ein Object zurückgibt und AutoFit eine Excel-Methode ist. Im folgenden Code sind alle Umwandlungen dargestellt.

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

  2. Wenn Sie den Standard ändern und PIAS verwenden möchten, anstatt die Typinformationen einzubetten, erweitern Sie im Projektmappen-Explorer den Knoten Verweise, und wählen Sie dann Microsoft.Office.Interop.Excel oder Microsoft.Office.Interop.Word aus.

  3. Wenn Sie das Fenster Eigenschaften nicht sehen, drücken Sie F4.

  4. Suchen Sie in der Liste der Eigenschaften Interop-Typen einbetten, und ändern Sie dessen Wert in False. Gleichermaßen können Sie die Kompilierung durchführen, wenn Sie an einer Eingabeaufforderung die /reference-Compileroption anstelle von /link verwenden.

So fügen Sie der Tabelle zusätzliche Formatierungen hinzu

  1. Ersetzen Sie die beiden Aufrufe von AutoFit in DisplayInExcel mit der folgenden Anweisung.

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

    Die AutoFormat-Methode verfügt über sieben Werteparameter, die alle optional sind. Benannte und optionale Argumente ermöglichen es Ihnen, Argumente für keine, einige oder alle von ihnen bereitzustellen. In der vorherigen Anweisung wurde ein Argument für nur einen der Parameter angegeben, nämlich für Format. Da Format der erste Parameter in der Parameterliste ist, müssen Sie nicht den Parameternamen angeben. Die Anweisung ist jedoch möglicherweise leichter zu verstehen, wenn der Parametername eingeschlossen wird, wie im folgenden Code gezeigt.

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

  2. Drücken Sie STRG + F5, um das Ergebnis anzuzeigen. Andere Formate finden Sie in der XlRangeAutoFormat-Enumeration.

  3. Vergleichen Sie die Anweisung in Schritt 1 mit dem folgenden Code, der die Argumente zeigt, die in Visual C# 2008 oder früheren Versionen erforderlich sind.

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

Beispiel

Der folgende Code veranschaulicht das vollständige Beispiel.

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# 2010. 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# 2010 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; }
    }
}

Siehe auch

Aufgaben

Gewusst wie: Verwenden von benannten und optionalen Argumenten in der Office-Programmierung (C#-Programmierhandbuch)

Referenz

dynamic (C#-Referenz)

Type.Missing

Konzepte

Benannte und optionale Argumente (C#-Programmierhandbuch)

Weitere Ressourcen

Verwenden des Typs dynamic (C#-Programmierhandbuch)