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

Artikel
02/26/2013

Benannte Argumente und optionale Argumente, die mit Visual C# 2010 eingeführt wurden, erhöhen Benutzerfreundlichkeit, Flexibilität und Lesbarkeit bei der C#-Programmierung. Darüber hinaus wird durch diese Funktionen der Zugriff auf COM-Schnittstellen, z. B. die Microsoft Office-Automatisierungs-APIs, erheblich erleichtert.

Die ConvertToTable-Methode im folgenden Beispiel verfügt über 16 Parameter, die Eigenschaften einer Tabelle darstellen, wie z. B. Spalten- und Zeilenanzahl, Formatierung, Rahmen, Schriftarten und Farben.Alle 16 Parameter sind optional, da Sie in der Regel keine bestimmten Werte für diese Parameter angeben möchten, die von den Standardwerten abweichen.Ohne benannte und optionale Argumente müssen Sie jedoch für jeden dieser Parameter einen Wert bzw. einen Platzhalterwert bereitstellen.Mit benannten und optionalen Argumenten müssen Sie nur für die Parameter Werte angeben, die für Ihr Projekt erforderlich sind.

Zur Durchführung dieser Prozeduren muss Microsoft Office Word auf Ihrem Computer installiert sein.

Hinweis
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.
Erweitern Sie im Bereich Vorlagenkategorien den Eintrag Visual C#, und klicken Sie dann auf Windows.
Stellen Sie oben im Bereich Vorlagen sicher, dass im Feld Zielframework der Eintrag .NET Framework 4 angezeigt wird.
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 einen Verweis 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 den Eintrag Microsoft.Office.Interop.Word aus der Liste Komponentenname aus.
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 Word = Microsoft.Office.Interop.Word;
```

So zeigen Sie Text in einem Word-Dokument an

Fügen Sie in der Program-Klasse in Program.cs die folgende Methode hinzu, um eine Word-Anwendung und ein Word-Dokument zu erstellen.Die Add-Methode verfügt über vier optionale Parameter.In diesem Beispiel werden die Standardwerte dieser Parameter verwendet.Somit sind keine Argumente in der aufrufenden Anweisung erforderlich.

static void DisplayInWord()
{
    var wordApp = new Word.Application();
    wordApp.Visible = true;
    // docs is a collection of all the Document objects currently 
    // open in Word.
    Word.Documents docs = wordApp.Documents;

    // Add a document to the collection and name it doc. 
    Word.Document doc = docs.Add();
}

Fügen Sie am Ende der Methode den folgenden Code hinzu, um zu definieren, an welcher Position im Dokument welcher Text angezeigt werden soll.

// Define a range, a contiguous area in the document, by specifying
// a starting and ending character position. Currently, the document
// is empty.
Word.Range range = doc.Range(0, 0);

// Use the InsertAfter method to insert a string at the end of the
// current range.
range.InsertAfter("Testing, testing, testing. . .");

So führen Sie die Anwendung aus

Fügen Sie Main die folgende Anweisung hinzu.
```
DisplayInWord();
```
Drücken Sie STRG+F5, um das Projekt auszuführen.Ein Word-Dokument mit dem angegebenen Text wird angezeigt.

So konvertieren Sie den Text in eine Tabelle

Verwenden Sie die ConvertToTable-Methode, um den Text in eine Tabelle einzubinden.Die Methode verfügt über sechzehn optionale Parameter.IntelliSense schließt optionale Parameter in Klammern ein, wie in der folgenden Abbildung dargestellt.

ConvertToTable-Parameter

Benannte und optionale Argumente ermöglichen Ihnen die Angabe von Werten ausschließlich für Parameter, die geändert werden sollen.Fügen Sie am Ende der DisplayInWord-Methode den folgenden Code hinzu, um eine einfache Tabelle zu erstellen.Das Argument gibt an, dass die Kommas in der Textzeichenfolge in range die Zellen der Tabelle trennen.
```
// Convert to a simple table. The table will have a single row with
// three columns.
range.ConvertToTable(Separator: ",");
```
In früheren Versionen von C# erfordert der Aufruf von ConvertToTable ein Verweisargument für jeden Parameter, wie im folgenden Code gezeigt.
```
// Call to ConvertToTable in Visual C# 2008 or earlier. This code
// is not part of the solution.
var missing = Type.Missing;
object separator = ",";
range.ConvertToTable(ref separator, ref missing, ref missing,
    ref missing, ref missing, ref missing, ref missing,
    ref missing, ref missing, ref missing, ref missing,
    ref missing, ref missing, ref missing, ref missing,
    ref missing);
```
Drücken Sie STRG+F5, um das Projekt auszuführen.

So experimentieren Sie mit anderen Parametern

Um die Tabelle so zu ändern, dass sie eine Spalte und drei Zeilen enthält, ersetzen Sie die letzte Zeile in DisplayInWord durch die folgende Anweisung, und drücken Sie dann STRG+F5.
```
range.ConvertToTable(Separator: ",", AutoFit: true, NumColumns: 1);
```
Um ein vordefiniertes Format für die Tabelle anzugeben, ersetzen Sie die letzte Zeile in DisplayInWord durch die folgende Anweisung, und drücken Sie dann STRG+F5.Das Format kann eine beliebige WdTableFormat-Konstante sein.
```
range.ConvertToTable(Separator: ",", AutoFit: true, NumColumns: 1,
    Format: Word.WdTableFormat.wdTableFormatElegant);
```

Beispiel

Der folgende Code umfasst das vollständige Beispiel.

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


namespace OfficeHowTo
{
    class WordProgram
    {
        static void Main(string[] args)
        {
            DisplayInWord();
        }

        static void DisplayInWord()
        {
            var wordApp = new Word.Application();
            wordApp.Visible = true;
            // docs is a collection of all the Document objects currently 
            // open in Word.
            Word.Documents docs = wordApp.Documents;

            // Add a document to the collection and name it doc. 
            Word.Document doc = docs.Add();

            // Define a range, a contiguous area in the document, by specifying
            // a starting and ending character position. Currently, the document
            // is empty.
            Word.Range range = doc.Range(0, 0);

            // Use the InsertAfter method to insert a string at the end of the
            // current range.
            range.InsertAfter("Testing, testing, testing. . .");

            // You can comment out any or all of the following statements to
            // see the effect of each one in the Word document.

            // Next, use the ConvertToTable method to put the text into a table. 
            // The method has 16 optional parameters. You only have to specify
            // values for those you want to change.

            // Convert to a simple table. The table will have a single row with
            // three columns.
            range.ConvertToTable(Separator: ",");

            // Change to a single column with three rows..
            range.ConvertToTable(Separator: ",", AutoFit: true, NumColumns: 1);

            // Format the table.
            range.ConvertToTable(Separator: ",", AutoFit: true, NumColumns: 1,
                Format: Word.WdTableFormat.wdTableFormatElegant);
        }
    }
}

Siehe auch

Konzepte

Benannte und optionale Argumente (C#-Programmierhandbuch)

Freigeben über