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

Artikel
08/10/2011

Visual C# 2010 stellt neue Funktionen bereit, die den Zugriff auf Office-API-Objekte vereinfachen. Zu diesen neuen Funktionen zählen benannte und optionale Argumente, ein neuer Typ mit dem Namendynamic sowie die Möglichkeit, Argumente wie Wertparameter an Verweisparameter in COM-Methoden zu übergeben.

In diesem Thema verwenden Sie die neuen Funktionen zum Schreiben von Code, mit dem ein Microsoft Office Excel-Arbeitsblatt erstellt und angezeigt wird. Anschließend schreiben Sie den Code, mit dem ein Office Word-Dokument hinzugefügt wird, das ein mit dem Excel-Arbeitsblatt verknüpftes Symbol enthält.

Zur Durchführung dieser exemplarischen Vorgehensweise müssen Microsoft Office Excel 2007 und Microsoft Office Word 2007 auf Ihrem Computer installiert sein.

Wenn Sie ein älteres Betriebssystem als Windows Vista verwenden, stellen Sie sicher, dass .NET Framework 2.0 installiert ist.

Tipp

Ihr Computer zeigt möglicherweise für einige der Elemente der Visual Studio-Benutzeroberfläche in der folgenden Anleitung andere Namen oder Standorte an. Diese Elemente sind von der jeweiligen Visual Studio-Version und den verwendeten Einstellungen abhängig. Weitere Informationen finden Sie unter Visual Studio-Einstellungen.

So erstellen Sie eine neue Konsolenanwendung

Starten Sie Visual Studio.
Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt. Das Dialogfeld Neues Projekt wird angezeigt.
Erweitern Sie im Bereich Installierte Vorlagen den Eintrag Visual C#, und klicken Sie dann auf Windows.
Vergewissern Sie sich, dass oben im Dialogfeld Neues Projekt die Option .NET Framework 4 als Zielframework ausgewählt ist.
Klicken Sie im Bereich Vorlagen auf Konsolenanwendung.
Geben Sie einen Namen für das Projekt in das Feld Name ein.
Klicken Sie auf OK.

Das neue Projekt wird im Projektmappen-Explorer angezeigt.

So fügen Sie Verweise hinzu

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Namen des Projekts, und klicken Sie auf Verweis hinzufügen. Das Dialogfeld Verweis hinzufügen wird angezeigt.
Wählen Sie auf der Seite .NET in der Liste Komponentenname den Eintrag Microsoft.Office.Interop.Word und dann bei gedrückt gehaltener STRG-Taste den Eintrag Microsoft.Office.Interop.Excel.
Klicken Sie auf OK.

So fügen Sie erforderliche Direktiven hinzu

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

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

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; }
}

Fügen Sie der Main-Methode den folgenden Code 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 zum Export von Kontoinformationen in Excel

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

Die Methode Add verfügt über einen optionalen Parameter zur Angabe einer bestimmten Vorlage. Die in Visual C# 2010 neu eingeführten optionalen Parameter ermöglichen Ihnen, das Argument für einen Parameter wegzulassen, wenn Sie den Standardwert des Parameters verwenden möchten. Da im folgenden Beispiel kein Argument gesendet wird, verwendet die Add-Methode die Standardvorlage und erstellt eine neue Arbeitsmappe. Die entsprechende Anweisung in früheren C#-Versionen 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;
}

Fügen Sie am Ende von DisplayInExcel den folgenden Code hinzu. Mit dem Code werden Werte in die ersten zwei Spalten der ersten Zeile im Arbeitsblatt eingefügt.
```
// Establish column headings in cells A1 and B1.
workSheet.Cells[1, "A"] = "ID Number";
workSheet.Cells[1, "B"] = "Current Balance";
```
Fügen Sie am Ende von DisplayInExcel den folgenden Code hinzu. Die foreach-Schleife fügt die Informationen aus der Kontoliste im Arbeitsblatt in die ersten zwei Spalten in aufeinanderfolgende Zeilen ein.
```
var row = 1;
foreach (var acct in accounts)
{
    row++;
    workSheet.Cells[row, "A"] = acct.ID;
    workSheet.Cells[row, "B"] = acct.Balance;
}
```
Fügen Sie am Ende von DisplayInExcel den folgenden Code hinzu, um die Spaltenbreiten an den Inhalt anzupassen.
```
workSheet.Columns[1].AutoFit();
workSheet.Columns[2].AutoFit();
```
Frühere Versionen von C# erfordern die explizite Umwandlung dieser Vorgänge, da ExcelApp.Columns[1] ein Object zurückgibt und AutoFit eine Excel-Range-Methode ist. Die folgenden Zeilen verdeutlichen die Umwandlung.
```
((Excel.Range)workSheet.Columns[1]).AutoFit();
((Excel.Range)workSheet.Columns[2]).AutoFit();
```
Visual C# 2010 konvertiert das zurückgegebene Object automatisch in den dynamic-Typ, wenn die /link-Compileroption auf die Assembly verweist oder wenn die Excel-Eigenschaft Interoptypen einbetten auf true festgelegt ist. True ist der Standardwert für diese Eigenschaft.

So führen Sie das Projekt aus

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

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

Drücken Sie STRG+F5.

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

So fügen Sie ein Word-Dokument hinzu

Zur Veranschaulichung zusätzlicher Möglichkeiten, die Visual C# 2010 zur Verbesserung der Office-Programmierung bietet, wird mit dem folgenden Code eine Word-Anwendung geöffnet und ein Symbol mit einer Verknüpfung zu dem Excel-Arbeitsblatt erstellt.

Fügen Sie die in diesem Schritt zu einem späteren Zeitpunkt bereitgestellte CreateIconInWordDoc-Methode in die Program-Klasse ein. CreateIconInWordDoc verwendet benannte und optionale Argumente zur Vereinfachung des Aufrufs der Add-Methode und der PasteSpecial-Methode. Diese Aufrufe beinhalten zwei weitere neue Funktionen von Visual C# 2010, die den Aufruf von COM-Methoden mit Verweisparametern vereinfachen. Erstens können Sie Argumente wie Wertparameter an die Verweisparameter senden. Das heißt, Sie können Werte direkt senden, ohne eine Variable für jeden Verweisparameter erstellen zu müssen. Der Compiler generiert temporäre Variablen, die die Argumentwerte enthalten, und verwirft diese Variablen bei Rückgabe aus dem Aufruf. Zweitens können Sie das ref-Schlüsselwort in der Argumentliste weglassen.

Die Add-Methode verfügt über vier Verweisparameter, die alle optional sind. In Visual C# 2010 können Sie Argumente für die Parameter weglassen, für die Sie die 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.

Mit der PasteSpecial-Methode wird der Inhalt der Zwischenablage eingefügt. Die Methode verfügt über sieben Verweisparameter, die alle optional sind. Mit dem folgenden Code werden Argumente für zwei dieser Parameter angegeben: Link zur Erstellung einer Verknüpfung mit der Quelle des Zwischenablageninhalts und DisplayAsIcon zur Anzeige der Verknüpfung als Symbol. In Visual C# 2010 können Sie benannte Argumente für diese zwei Parameter verwenden und die anderen weglassen. Obwohl es sich um Verweisparameter handelt, müssen Sie weder das ref-Schlüsselwort verwenden noch Variablen als Argumente erstellen. Sie können die Werte direkt senden. In Visual C# 2008 und früheren Versionen müssen Sie für jeden Verweisparameter eine Variable als Argument 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 und 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);
}
```

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

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

Fügen Sie am Ende von DisplayInExcel die folgende Anweisung hinzu. Mit der Copy-Methode wird das Arbeitsblatt in die Zwischenablage eingefügt.

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

Drücken Sie STRG+F5.

Ein Word-Dokument mit einem Symbol wird angezeigt. Doppelklicken Sie auf das Symbol, um das Arbeitsblatt aufzurufen.

So legen Sie die Eigenschaft Interoptypen einbetten fest

Weitere Verbesserungen sind beim Aufruf eines COM-Typs, der zur Laufzeit keine primäre Interopassembly (PIA) erfordert, möglich. Die Vermeidung der Abhängigkeit von PIAs ermöglicht Versionsunabhängigkeit und eine einfachere 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 wird die Programmierung vereinfacht, da die für COM-Methoden erforderlichen und von COM-Methoden zurückgegebenen Typen mit dem Typ dynamic statt mit dem Typ 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 die Einbettung von Typinformationen anstelle der Verwendung 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 statt Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet. Außerdem erfordern ohne das Standardverhalten die Aufrufe von AutoFit in derselben Methode eine explizite Umwandlung, da ExcelApp.Columns[1] ein Object zurückgibt und AutoFit eine Excel-Methode ist. Im folgenden Codebeispiel wird die Umwandlung veranschaulicht.
```
((Excel.Range)workSheet.Columns[1]).AutoFit();
((Excel.Range)workSheet.Columns[2]).AutoFit();
```
Wenn Sie das Standardverhalten ändern möchten, um PIAs zu verwenden statt Typinformationen einzubetten, erweitern Sie den Knoten Verweise im Projektmappen-Explorer, und wählen Sie dann Microsoft.Office.Interop.Excel oder Microsoft.Office.Interop.Word.
Wenn das Eigenschaftenfenster nicht angezeigt wird, drücken Sie F4.
Suchen Sie Interoptypen einbetten in der Liste der Eigenschaften, und ändern Sie den Wert in False. Sie können auch zur Kompilierung die /reference-Compileroption anstelle der /link-Compileroption an einer Eingabeaufforderung verwenden.

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

Ersetzen Sie die zwei Aufrufe von AutoFit in DisplayInExcel durch die folgende Anweisung.
```
// Call to AutoFormat in Visual C# 2010.
workSheet.Range["A1", "B3"].AutoFormat(
    Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);
```
Die AutoFormat-Methode verfügt über sieben Wertparameter, die alle optional sind. Mithilfe von benannten und optionalen Argumenten können Sie Argumente für beliebig viele oder keinen dieser Parameter bereitstellen. In der vorherigen Anweisung wird für nur einen der Parameter (Format) ein Argument angegeben. Da Format der erste Parameter in der Parameterliste ist, müssen Sie den Parameternamen nicht angeben. Die Anweisung ist jedoch einfacher zu verstehen, wenn der Parametername eingeschlossen ist, wie im folgenden Code gezeigt.
```
// Call to AutoFormat in Visual C# 2010.
workSheet.Range["A1", "B3"].AutoFormat(Format:
    Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);
```
Drücken Sie STRG+F5, um das Ergebnis anzuzeigen. Weitere Formate sind in der XlRangeAutoFormat-Enumeration aufgelistet.

Vergleichen Sie die Anweisung in Schritt 1 mit dem folgenden Code, der die Argumente enthält, 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