Vorgehensweise: Zugreifen auf Office-Interop-Objekte

C# verfügt über 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. Sie schreiben 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.

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 die Option C#, und wählen Sie dann Windows aus.
4. Sehen Sie sich den oberen Rand des Dialogfelds Neues Projekt an, um sicherzustellen, dass Sie .NET Framework 4 (oder höher) als Zielframework auswählen.
5. Wählen Sie im Bereich Vorlagen die Option Konsolenanwendung aus.
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 wählen Sie dann 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 die Assemblys nicht angezeigt werden, müssen Sie sie möglicherweise installieren. Weitere Informationen finden Sie unter How to: Installieren von primären Interopassemblys für Office.
3. Klicken Sie auf OK.

So fügen Sie erforderliche using-Anweisungen hinzu

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Datei Program.cs, und wählen Sie dann Code anzeigen. Fügen Sie am Anfang der Codedatei die folgenden using-Anweisungen 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 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 ermöglichen es Ihnen, das Argument für diesen Parameter auszulassen, wenn Sie den Standardwert des Parameters verwenden möchten. Da Sie kein Argument angegeben haben, 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 particular 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 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";

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

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 Range-Methode von Excel ist. Die folgenden Zeilen verdeutlichen die Umwandlung.

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

C# konvertiert das zurückgegebene Object automatisch in dynamic, wenn die Compileroption EmbedInteropTypes auf die Assembly verweist, oder 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

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

Der folgende Code öffnet 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 verringern. Diese Aufrufe beinhalten zwei weitere Features, 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. Sie können Argumente für einen oder alle Parameter weglassen, wenn Sie deren Standardwerte verwenden möchten.

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. Sie können benannte Argumente für diese beiden Argumente verwenden und die anderen weglassen. Obwohl es sich bei diesen Argumenten 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.

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

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

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

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

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.

Darüber hinaus ist die Programmierung einfacher, da der Typ dynamic die erforderlichen und zurückgegebenen Typen darstellt, die in COM-Methoden deklariert wurden. Variablen vom Typ dynamic werden erst zur Laufzeit ausgewertet, wodurch die Notwendigkeit der expliziten Umwandlung entfällt. Weitere Informationen finden Sie unter Verwenden von dynamischen Typen.

Das Einbetten von Typinformationen anstelle der Verwendung von PIAs ist das Standardverhalten. Aufgrund dieses Standardverhaltens werden mehrere der vorherigen Beispiele vereinfacht. Sie benötigen keine explizite Umwandlung. 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 Standardwert 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();

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. Wenn Sie das Fenster Eigenschaften nicht sehen, drücken Sie F4. Suchen Sie in der Liste der Eigenschaften nach Interop-Typen einbetten, und ändern Sie dessen Wert in FALSE. Äquivalent dazu können Sie kompilieren, indem Sie die Compileroption References anstelle von EmbedInteropTypes an einer Eingabeaufforderung verwenden.

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

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 Methode AutoFormat verfügt über sieben Wertparameter, 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 haben Sie 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 Sie den Parameternamen einschließen, 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 finden Sie in der Enumeration-Liste XlRangeAutoFormat.

Beispiel

Der folgende Code veranschaulicht das vollständige Beispiel.

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

namespace OfficeProgrammingWalkthruComplete
{
    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 particular 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; }
    }
}

Siehe auch

• Type.Missing
• dynamic
• Benannte und optionale Argumente
• Vorgehensweise: Verwenden von benannten und optionalen Argumenten in der Office-Programmierung