Gewusst wie: Zugreifen auf Office-Interop-Objekte mithilfe von Visual C#-Funktionen (C#-Programmierhandbuch)How to: Access Office Interop Objects by Using Visual C# Features (C# Programming Guide)

Visual C# verfügt über Funktionen, die den Zugriff auf Office-API-Objekte vereinfachen.Visual C# has features that simplify access to Office API objects. 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.The new features include named and optional arguments, a new type called dynamic, and the ability to pass arguments to reference parameters in COM methods as if they were value parameters.

In diesem Thema verwenden Sie die neuen Funktionen, um Code zu schreiben, mit dem ein Microsoft Office Excel-Arbeitsblatt erstellt und angezeigt wird.In this topic you will use the new features to write code that creates and displays a Microsoft Office Excel worksheet. Dann schreiben Sie Code, um ein Office Word-Dokument hinzuzufügen, das ein Symbol enthält, das mit dem Excel-Arbeitsblatt verknüpft ist.You will then write code to add an Office Word document that contains an icon that is linked to the Excel worksheet.

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.To complete this walkthrough, you must have Microsoft Office Excel 2007 and Microsoft Office Word 2007, or later versions, installed on your computer.

Wenn Sie ein Betriebssystem verwenden, das älter ist als Windows VistaWindows Vista, stellen Sie sicher, dass .NET Framework 2.0.NET Framework 2.0 installiert ist.If you are using an operating system that is older than Windows VistaWindows Vista, make sure that .NET Framework 2.0.NET Framework 2.0 is installed.

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.Your computer might show different names or locations for some of the Visual Studio user interface elements in the following instructions. Diese Elemente sind von der jeweiligen Visual Studio-Version und den verwendeten Einstellungen abhängig.The Visual Studio edition that you have and the settings that you use determine these elements. Weitere Informationen finden Sie unter Personalisieren der IDE.For more information, see Personalizing the IDE.

So erstellen Sie eine KonsolenanwendungTo create a new console application

  1. Starten Sie Visual Studio.Start Visual Studio.

  2. Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.On the File menu, point to New, and then click Project. Das Dialogfeld Neues Projekt wird angezeigt.The New Project dialog box appears.

  3. Erweitern Sie im Bereich Installierte Vorlagen den Eintrag Visual C#, und klicken Sie dann auf Windows.In the Installed Templates pane, expand Visual C#, and then click 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.Look at the top of the New Project dialog box to make sure that .NET Framework 4 (or later version) is selected as a target framework.

  5. Klicken Sie im Bereich Vorlagen auf Konsolenanwendung.In the Templates pane, click Console Application.

  6. Geben Sie einen Namen für das Projekt im Feld Name ein.Type a name for your project in the Name field.

  7. Klicken Sie auf OK.Click OK.

    Das neue Projekt wird im Projektmappen-Explorer angezeigt.The new project appears in Solution Explorer.

So fügen Sie Verweise hinzuTo add references

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, und klicken Sie dann auf Verweis hinzufügen.In Solution Explorer, right-click your project's name and then click Add Reference. Das Dialogfeld Verweis hinzufügen wird angezeigt.The Add Reference dialog box appears.

  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.On the Assemblies page, select Microsoft.Office.Interop.Word in the Component Name list, and then hold down the CTRL key and select Microsoft.Office.Interop.Excel. Wenn keine Assemblys sichtbar sind, müssen Sie unter Umständen sicherstellen, dass sie installiert sind und angezeigt werden (siehe Vorgehensweise: Installieren von primären Interopassemblys für Office).If you do not see the assemblies, you may need to ensure they are installed and displayed (see How to: Install Office Primary Interop Assemblies)

  3. Klicken Sie auf OK.Click OK.

So fügen Sie erforderliche using-Anweisungen hinzuTo add necessary using directives

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Datei Program.cs und dann auf Code anzeigen.In Solution Explorer, right-click the Program.cs file and then click View Code.

  2. Fügen Sie am Anfang der Codedatei die folgenden using-Direktiven hinzu.Add the following using directives to the top of the code file.

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

So erstellen Sie eine Liste mit BankkontenTo create a list of bank accounts

  1. Fügen Sie die folgende Klassendefinition in Program.cs unter der Program-Klasse ein.Paste the following class definition into Program.cs, under the Program class.

    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.Add the following code to the Main method to create a bankAccounts list that contains two accounts.

    // 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 werdenTo declare a method that exports account information to Excel

  1. Fügen Sie die folgende Methode der Program-Klasse hinzu, um ein Excel-Arbeitsblatt einzurichten.Add the following method to the Program class to set up an Excel worksheet.

    Die Methode Add hat einen optionalen Parameter zur Angabe einer bestimmten Vorlage.Method Add has an optional parameter for specifying a particular template. Optionale Parameter, die in C# 4 neu sind, ermöglichen es Ihnen, das Argument für diesen Parameter auszulassen, wenn Sie den Standardwert des Parameters verwenden möchten.Optional parameters, new in C# 4, enable you to omit the argument for that parameter if you want to use the parameter's default value. Da im folgenden Beispiel kein Argument gesendet wird, verwendet Add die Standardvorlage und erstellt eine neue Arbeitsmappe.Because no argument is sent in the following code, Add uses the default template and creates a new workbook. Die entsprechende Anweisung in früheren Versionen von C# erfordert ein Platzhalterargument: ExcelApp.Workbooks.Add(Type.Missing).The equivalent statement in earlier versions of C# requires a placeholder argument: 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.Add the following code at the end of DisplayInExcel. Der Code fügt Werte in die ersten beiden Spalten der ersten Zeile des Arbeitsblatts ein.The code inserts values into the first two columns of the first row of the worksheet.

    // 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.Add the following code at the end of DisplayInExcel. Die foreach-Schleife fügt die Informationen aus der Liste der Konten in die ersten beiden Spalten der nachfolgenden Zeilen des Arbeitsblattes ein.The foreach loop puts the information from the list of accounts into the first two columns of successive rows of the worksheet.

    
    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.Add the following code at the end of DisplayInExcel to adjust the column widths to fit the content.

    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 Range-Methode ist.Earlier versions of C# require explicit casting for these operations because ExcelApp.Columns[1] returns an Object, and AutoFit is an Excel Range method. Die folgenden Zeilen verdeutlichen die Umwandlung.The following lines show the casting.

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

    C# 4 und höhere Versionen konvertieren das zurückgegebene Object automatisch in dynamic, wenn die Compileroption /link auf die Assembly verweist oder gleichermaßen wenn die Excel-Eigenschaft Interop-Typen einbetten auf TRUE festgelegt ist., and later versions, converts the returned Object to dynamic automatically if the assembly is referenced by the /link compiler option or, equivalently, if the Excel Embed Interop Types property is set to true. Der Standardwert für diese Eigenschaft ist "True".True is the default value for this property.

So führen Sie das Projekt ausTo run the project

  1. Fügen Sie die folgende Zeile am Ende von Main hinzu.Add the following line at the end of Main.

    // Display the list in an Excel spreadsheet.
    DisplayInExcel(bankAccounts);
    
  2. Drücken Sie STRG+F5.Press CTRL+F5.

    Ein Excel-Arbeitsblatt mit den Daten der beiden Konten wird angezeigt.An Excel worksheet appears that contains the data from the two accounts.

So fügen Sie ein Word-Dokument hinzuTo add a Word document

  1. Um zusätzliche Wege zu zeigen, wie C# 4 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.To illustrate additional ways in which C# 4, and later versions, enhances Office programming, the following code opens a Word application and creates an icon that links to the Excel worksheet.

    Fügen Sie die Methode CreateIconInWordDoc, die später in diesem Schritt bereitgestellt wird, in die Program-Klasse ein.Paste method CreateIconInWordDoc, provided later in this step, into the Program class. CreateIconInWordDoc verwendet benannte und optionale Argumente, um die Komplexität der Methodenaufrufe von add und PasteSpecial zu verringern.CreateIconInWordDoc uses named and optional arguments to reduce the complexity of the method calls to Add and PasteSpecial. Diese Aufrufe beinhalten zwei weitere neue Funktionen, die in C# 4 eingeführt wurden und die Aufrufe von COM-Methoden mit Verweisparametern vereinfachen.These calls incorporate two other new features introduced in C# 4 that simplify calls to COM methods that have reference parameters. Erstens können Sie Argumente an die Verweisparameter senden als handele es sich um Werteparameter.First, you can send arguments to the reference parameters as if they were value parameters. Das heißt, Sie können Werte direkt senden, ohne eine Variable für jeden Verweisparameter zu erstellen.That is, you can send values directly, without creating a variable for each reference parameter. Der Compiler generiert temporäre Variablen, die die Argumentwerte enthalten, und verwirft diese Variablen bei Rückkehr vom Aufruf.The compiler generates temporary variables to hold the argument values, and discards the variables when you return from the call. Zweitens können Sie das ref-Schlüsselwort in der Argumentliste auslassen.Second, you can omit the ref keyword in the argument list.

    Die Add-Methode verfügt über vier Verweisparameter, die alle optional sind.The Add method has four reference parameters, all of which are optional. In C# 4 oder höher können Sie Argumente für einen oder alle Parameter weglassen, wenn Sie deren Standardwerte verwenden möchten.In C# 4, or later versions, you can omit arguments for any or all of the parameters if you want to use their default values. In Visual C# 2008Visual 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.In Visual C# 2008Visual C# 2008 and earlier versions, an argument must be provided for each parameter, and the argument must be a variable because the parameters are reference parameters.

    Die PasteSpecial-Methode fügt den Inhalt aus der Zwischenablage ein.The PasteSpecial method inserts the contents of the Clipboard. Die Methode verfügt über sieben Verweisparameter, die alle optional sind.The method has seven reference parameters, all of which are optional. 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.The following code specifies arguments for two of them: Link, to create a link to the source of the Clipboard contents, and DisplayAsIcon, to display the link as an icon. In C# 4 können Sie benannte Argumente für diese zwei verwenden und die anderen weglassen.In C# 4, you can use named arguments for those two and omit the others. Obwohl es sich um Verweisparameter handelt, müssen Sie nicht das ref-Schlüsselwort verwenden oder Variablen erstellen, die als Argumente gesendet werden.Although these are reference parameters, you do not have to use the ref keyword, or to create variables to send in as arguments. Sie können die Werte direkt senden.You can send the values directly. In Visual C# 2008Visual C# 2008 und früheren Versionen müssen Sie für jeden Verweisparameter ein Variablenargument senden.In Visual C# 2008Visual C# 2008 and earlier versions, you must send a variable argument for each reference parameter.

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

    In Visual C# 2008Visual C# 2008 oder früheren Versionen der Sprache ist der folgende komplexere Code erforderlich.In Visual C# 2008Visual C# 2008 or earlier versions of the language, the following more complex code is required.

    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.Add the following statement at the end of Main.

    // 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.Add the following statement at the end of DisplayInExcel. Die Copy-Methode fügt das Arbeitsblatt der Zwischenablage hinzu.The Copy method adds the worksheet to the Clipboard.

    // 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.Press CTRL+F5.

    Ein Word-Dokument mit einem Symbol wird angezeigt.A Word document appears that contains an icon. Doppelklicken Sie auf das Symbol, um das Arbeitsblatt in den Vordergrund zu bringen.Double-click the icon to bring the worksheet to the foreground.

So legen Sie die Eigenschaft "Interop-Typen einbetten" festTo set the Embed Interop Types property

  1. Weitere Verbesserungen sind möglich, wenn Sie einen COM-Typ aufrufen, der keine primäre Interop-Assembly (PIA) zur Laufzeit benötigt.Additional enhancements are possible when you call a COM type that does not require a primary interop assembly (PIA) at run time. Das Entfernen der Abhängigkeit von PIAs führt zu einer Versionsunabhängigkeit und einfacheren Bereitstellung.Removing the dependency on PIAs results in version independence and easier deployment. Weitere Informationen zu den Vorteilen der Programmierung ohne PIAs finden Sie unter Exemplarische Vorgehensweise: Einbetten von Typen aus verwalteten Assemblys.For more information about the advantages of programming without PIAs, see Walkthrough: Embedding Types from Managed Assemblies.

    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.In addition, programming is easier because the types that are required and returned by COM methods can be represented by using the type dynamic instead of Object. Variablen vom Typ dynamic werden erst zur Laufzeit ausgewertet, wodurch die Notwendigkeit der expliziten Umwandlung entfällt.Variables that have type dynamic are not evaluated until run time, which eliminates the need for explicit casting. Weitere Informationen finden Sie unter Verwenden von dynamischen Typen.For more information, see Using Type dynamic.

    In C# 4 ist das Einbetten von Typinformationen anstelle eines Einsatzes von PIAs das Standardverhalten.In C# 4, embedding type information instead of using PIAs is default behavior. Aufgrund dieses Standardverhaltens werden mehrere der vorherigen Beispiele vereinfacht, da keine explizite Umwandlung erforderlich ist.Because of that default, several of the previous examples are simplified because explicit casting is not required. Beispiel: Die Deklaration von worksheet in DisplayInExcel lautet Excel._Worksheet workSheet = excelApp.ActiveSheet und nicht Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet.For example, the declaration of worksheet in DisplayInExcel is written as Excel._Worksheet workSheet = excelApp.ActiveSheet rather than 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.The calls to AutoFit in the same method also would require explicit casting without the default, because ExcelApp.Columns[1] returns an Object, and AutoFit is an Excel method. Im folgenden Code sind alle Umwandlungen dargestellt.The following code shows the casting.

    ((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.To change the default and use PIAs instead of embedding type information, expand the References node in Solution Explorer and then select Microsoft.Office.Interop.Excel or Microsoft.Office.Interop.Word.

  3. Wenn Sie das Fenster Eigenschaften nicht sehen, drücken Sie F4.If you cannot see the Properties window, press F4.

  4. Suchen Sie in der Liste der Eigenschaften nach Interop-Typen einbetten, und ändern Sie dessen Wert in FALSE.Find Embed Interop Types in the list of properties, and change its value to False. Gleichermaßen können Sie die Kompilierung durchführen, wenn Sie an einer Eingabeaufforderung die /reference-Compileroption anstelle von /link verwenden.Equivalently, you can compile by using the /reference compiler option instead of /link at a command prompt.

So fügen Sie der Tabelle zusätzliche Formatierungen hinzuTo add additional formatting to the table

  1. Ersetzen Sie die beiden Aufrufe von AutoFit in DisplayInExcel mit der folgenden Anweisung.Replace the two calls to AutoFit in DisplayInExcel with the following statement.

    // 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.The AutoFormat method has seven value parameters, all of which are optional. Benannte und optionale Argumente ermöglichen es Ihnen, Argumente für keine, einige oder alle von ihnen bereitzustellen.Named and optional arguments enable you to provide arguments for none, some, or all of them. In der vorherigen Anweisung wurde ein Argument für nur einen der Parameter angegeben, nämlich für Format.In the previous statement, an argument is supplied for only one of the parameters, Format. Da Format der erste Parameter in der Parameterliste ist, müssen Sie nicht den Parameternamen angeben.Because Format is the first parameter in the parameter list, you do not have to provide the parameter name. Die Anweisung ist jedoch möglicherweise leichter zu verstehen, wenn der Parametername eingeschlossen wird, wie im folgenden Code gezeigt.However, the statement might be easier to understand if the parameter name is included, as is shown in the following code.

    // 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.Press CTRL+F5 to see the result. Weitere Formate sind in der XlRangeAutoFormat-Enumeration aufgelistet.Other formats are listed in the XlRangeAutoFormat enumeration.

  3. Vergleichen Sie die Anweisung in Schritt 1 mit dem folgenden Code, der die Argumente zeigt, die in Visual C# 2008Visual C# 2008 oder früheren Versionen erforderlich sind.Compare the statement in step 1 with the following code, which shows the arguments that are required in Visual C# 2008Visual C# 2008 or earlier versions.

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

BeispielExample

Der folgende Code veranschaulicht das vollständige Beispiel.The following code shows the complete example.

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

Siehe auchSee Also

Type.Missing
dynamicdynamic
Verwenden von dynamischen TypenUsing Type dynamic
Benannte und optionale ArgumenteNamed and Optional Arguments
Gewusst wie: Verwenden von benannten und optionalen Argumenten in der Office-ProgrammierungHow to: Use Named and Optional Arguments in Office Programming