Exemplarische Vorgehensweise: Office-Programmierung (C# und Visual Basic)

Artikel
06/10/2015

Ab Visual Studio 2010 gibt es neue Funktionen in C# und Visual Basic, die die Microsoft Office-Programmierung verbessern. Jede Sprache verfügt über zusätzliche Funktionen, die bereits in der anderen Sprache existieren.

Zu den neuen Funktionen in C# gehören benannte und optionale Argumente, Rückgabewerte vom Typ dynamic und in der COM-Programmierung die Möglichkeit, das Schlüsselwort ref auszulassen und auf indizierte Eigenschaften zuzugreifen. Die neuen Funktionen in Visual Basic umfassen automatisch implementierte Eigenschaften, Anweisungen in Lambda-Ausdrücken sowie Auflistungsinitialisierer.

Beide Sprachen ermöglichen das Einbetten von Typinformationen, wodurch Assemblys bereitgestellt werden können, die mit COM-Komponenten interagieren, ohne primäre Interop-Assemblys (PIAs) auf dem Computer des Benutzers bereitzustellen. Weitere Informationen finden Sie unter Exemplarische Vorgehensweise: Einbetten von Typen aus verwalteten Assemblys (C# und Visual Basic).

Diese exemplarische Vorgehensweise veranschaulicht die neuen Funktionen im Kontext der Office-Programmierung, aber viele von ihnen sind auch bei der allgemeinen Programmierung nützlich. In der exemplarischen Vorgehensweise verwenden Sie zunächst eine Excel-Add-In-Anwendung, um eine Excel-Arbeitsmappe zu erstellen. Sie werden dann ein Word-Dokument erstellen, das einen Link zur Arbeitsmappe enthält. Abschließend sehen Sie, wie die PIA-Abhängigkeit aktiviert oder deaktiviert werden kann.

Vorbereitungsmaßnahmen

Zum Durchführen dieser exemplarischen Vorgehensweise müssen Microsoft Office Excel 2013 (oder Version 2007 oder höher) und Microsoft Office Word 2013 (oder Version 2007 oder höher) 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 richten Sie eine Excel-Add-In-Anwendung ein

Starten Sie Visual Studio.
Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.
Erweitern Sie im Bereich Installierte Vorlagen die Option Visual Basic oder Visual C#, erweitern Sie dann Office, und klicken Sie auf 2013 (oder 2010 oder 2007).
Klicken Sie im Bereich Vorlagen auf Excel 2013 Add-In (oder Excel 2010 Add-In oder Excel 2007 Add-In).
Sehen Sie am oberen Rand des Bereichs Vorlagen nach, um sicherzustellen, dass .NET Framework 4 oder eine höhere Version im Feld Zielframework angezeigt wird.
Geben Sie, wenn gewünscht, 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 Projektnamen, und klicken Sie dann auf Verweis hinzufügen. Das Dialogfeld Verweis hinzufügen wird angezeigt.
Wählen Sie auf der Registerkarte Assemblys die Option Microsoft.Office.Interop.Excel, Version 15.0.0.0 (oder Version 14.0.0.0 für Excel 2010 oder Version 12.0.0.0 für Excel 2007), in der Liste Komponentenname aus, und halten Sie dann die Strg-Taste gedrückt, während Sie Microsoft.Office.Interop.Word, Version 15.0.0.0 (oder Version 14.0.0.0 für Word 2010 oder 12.0.0.0 für Word 2007), auswählen. 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).
Klicken Sie auf OK.

So fügen Sie erforderliche Imports-Anweisungen oder using-Direktiven hinzu

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

Fügen Sie die folgenden Imports-Anweisungen (Visual Basic) oder using-Direktiven (C#) am Anfang der Codedatei ein, wenn sie noch nicht vorhanden sind.

Imports Microsoft.Office.Interop

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

So erstellen Sie eine Liste mit Bankkonten

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, klicken Sie auf Hinzufügen und dann auf Klasse. Benennen Sie die Klasse "Account.vb", wenn Sie Visual Basic verwenden, oder "Account.cs", wenn Sie C# verwenden. Klicken Sie auf Hinzufügen.
Ersetzen Sie die Definition der Account-Klasse durch den folgenden Code. Die Klassendefinitionen verwenden automatisch implementierte Eigenschaften, die neu in Visual Basic in Visual Studio 2010 sind. Weitere Informationen finden Sie unter Automatisch implementierte Eigenschaften (Visual Basic).
```
Public Class Account
    Property ID As Integer = -1
    Property Balance As Double 
End Class
```
```
class Account
{
    public int ID { get; set; }
    public double Balance { get; set; }
}
```

Fügen Sie den folgenden Code in die ThisAddIn_Startup-Methode in "ThisAddIn.vb" oder "ThisAddIn.cs" ein, um eine bankAccounts-Liste mit zwei Konten zu erstellen. Die Listendeklarationen verwenden Auflistungsinitialisierer, die neu in Visual Basic in Visual Studio 2010 sind. Weitere Informationen finden Sie unter Auflistungsinitialisierer (Visual Basic).

Dim bankAccounts As New List(Of Account) From {
    New Account With {
                          .ID = 345,
                          .Balance = 541.27
                     },
    New Account With {
                          .ID = 123,
                          .Balance = -127.44
                     }
    }

var bankAccounts = new List<Account> 
{
    new Account 
    {
        ID = 345,
        Balance = 541.27
    },
    new Account 
    {
        ID = 123,
        Balance = -127.44
    }
};

So exportieren Sie Daten nach Excel

Fügen Sie in der gleichen Datei die folgende Methode der ThisAddIn-Klasse hinzu. Die Methode richtet eine Excel-Arbeitsmappe ein, in die die Daten exportiert werden.
```
Sub DisplayInExcel(ByVal accounts As IEnumerable(Of Account),
               ByVal DisplayAction As Action(Of Account, Excel.Range))

    With Me.Application
        ' Add a new Excel workbook.
        .Workbooks.Add()
        .Visible = True
        .Range("A1").Value = "ID"
        .Range("B1").Value = "Balance"
        .Range("A2").Select()

        For Each ac In accounts
            DisplayAction(ac, .ActiveCell)
            .ActiveCell.Offset(1, 0).Select()
        Next 

        ' Copy the results to the Clipboard.
        .Range("A1:B3").Copy()
    End With 
End Sub
```
```
void DisplayInExcel(IEnumerable<Account> accounts,
           Action<Account, Excel.Range> DisplayFunc)
{
    var excelApp = this.Application;
    // Add a new Excel workbook.
    excelApp.Workbooks.Add();
    excelApp.Visible = true;
    excelApp.Range["A1"].Value = "ID";
    excelApp.Range["B1"].Value = "Balance";
    excelApp.Range["A2"].Select();

    foreach (var ac in accounts)
    {
        DisplayFunc(ac, excelApp.ActiveCell);
        excelApp.ActiveCell.Offset[1, 0].Select();
    }
    // Copy the results to the Clipboard.
    excelApp.Range["A1:B3"].Copy();
}
```
Bei dieser Methode werden zwei neue C#-Funktionen verwendet. Beide Funktionen existieren bereits in Visual Basic.
- 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 vorherigen Beispiel kein Argument gesendet wurde, 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).
  
  Weitere Informationen finden Sie unter Benannte und optionale Argumente (C#-Programmierhandbuch).
- Die Range- und Offset-Eigenschaften des Bereich-Objekts verwenden die Funktion Indizierte Eigenschaften. Diese Funktion ermöglicht es Ihnen, diese Eigenschaften von COM-Typen zu nutzen, indem Sie die folgende typische C#-Syntax verwenden. Indizierte Eigenschaften ermöglichen es Ihnen außerdem, die Value-Eigenschaft des Range-Objekts zu verwenden, sodass Sie die Value2-Eigenschaft nicht mehr verwenden müssen. Die Value-Eigenschaft ist indiziert, der Index ist jedoch optional. Optionale Argumente und indizierte Eigenschaften arbeiten im folgenden Beispiel zusammen.
```
// Visual C# 2010 provides indexed properties for COM programming.
excelApp.Range["A1"].Value = "ID";
excelApp.ActiveCell.Offset[1, 0].Select();
```
  In früheren Versionen der Sprache ist die folgende spezielle Syntax erforderlich.
```
// In Visual C# 2008, you cannot access the Range, Offset, and Value 
// properties directly.
excelApp.get_Range("A1").Value2 = "ID";
excelApp.ActiveCell.get_Offset(1, 0).Select();
```
  Sie können nicht Ihre eigenen indizierten Eigenschaften erstellen. Die Funktion unterstützt nur die Nutzung vorhandener indizierter Eigenschaften.
  
  Weitere Informationen finden Sie unter Gewusst wie: Indizierte Eigenschaften bei der COM-Interop-Programmierung (C#-Programmierhandbuch).
Fügen Sie den folgenden Code am Ende von DisplayInExcel hinzu, um die Spaltenbreite an den Inhalt anzupassen.
```
' Add the following two lines at the end of the With statement.
.Columns(1).AutoFit()
.Columns(2).AutoFit()
```
```
excelApp.Columns[1].AutoFit();
excelApp.Columns[2].AutoFit();
```
Diese Hinzufügungen veranschaulichen eine weitere neue Funktion in C# 2010: die Behandlung von Object-Werten, die von COM-Hosts wie z. B. Office zurückgegeben wurden, als wären sie vom Typ dynamic. Dies geschieht automatisch, wenn Interop-Typen einbetten auf den Standardwert True festgelegt ist oder gleichermaßen wenn die /link-Compileroption auf die Assembly verweist. Der Typ dynamic ermöglicht eine späte Bindung, bereits in Visual Basic verfügbar, und vermeidet die in Visual C# 2008 und in früheren Sprachversionen erforderliche explizite Umwandlung.

Beispielsweise gibt excelApp.Columns[1] ein Object zurück, und AutoFit ist eine Excel Bereich-Methode. Ohne dynamic müssen Sie das von excelApp.Columns[1] zurückgegebene Objekt als eine Instanz von Range umwandeln, bevor Sie die Methode AutoFit aufrufen.
```
// Casting is required in Visual C# 2008.
((Excel.Range)excelApp.Columns[1]).AutoFit();

// Casting is not required in Visual C# 2010.
excelApp.Columns[1].AutoFit();
```
Weitere Informationen zum Einbetten von Interop-Typen finden Sie in den Verfahren "So suchen Sie den PIA-Verweis" und "So stellen Sie die PIA-Abhängigkeit wieder her" weiter unten in diesem Thema. Weitere Informationen zu dynamic finden Sie unter dynamic (C#-Referenz) oder Verwenden des Typs dynamic (C#-Programmierhandbuch).

So rufen Sie DisplayInExcel auf

Fügen Sie den folgenden Code am Ende der ThisAddIn_StartUp-Methode hinzu. Der Aufruf von DisplayInExcel enthält zwei Argumente. Das erste Argument ist der Name der Liste mit Konten, die verarbeitet werden sollen. Das zweite Argument ist ein mehrzeiliger Lambda-Ausdruck, der definiert, wie die Daten verarbeitet werden. Die ID- und balance-Werte für jedes Konto werden in angrenzenden Zellen angezeigt, und die Zeile wird rot dargestellt, wenn der Saldo kleiner als Null ist. Mehrzeilige Lambda-Ausdrücke sind eine neue Funktion in Visual Basic 2010. Weitere Informationen finden Sie unter Lambda-Ausdrücke (Visual Basic).

DisplayInExcel(bankAccounts,
       Sub(account, cell)
           ' This multiline lambda expression sets custom 
           ' processing rules for the bankAccounts.
           cell.Value = account.ID
           cell.Offset(0, 1).Value = account.Balance

           If account.Balance < 0 Then
               cell.Interior.Color = RGB(255, 0, 0)
               cell.Offset(0, 1).Interior.Color = RGB(255, 0, 0)
           End If 
       End Sub)

DisplayInExcel(bankAccounts, (account, cell) =>
// This multiline lambda expression sets custom processing rules   
// for the bankAccounts.
{
    cell.Value = account.ID;
    cell.Offset[0, 1].Value = account.Balance;
    if (account.Balance < 0)
    {
        cell.Interior.Color = 255;
        cell.Offset[0, 1].Interior.Color = 255;
    }
});

Drücken Sie F5, um das Programm auszuführen. Ein Excel-Arbeitsblatt wird mit den Kontendaten angezeigt.

So fügen Sie ein Word-Dokument hinzu

Fügen Sie den folgenden Code am Ende der ThisAddIn_StartUp-Methode hinzu, um ein Word-Dokument zu erstellen, das einen Link zur Excel-Arbeitsmappe enthält.
```
Dim wordApp As New Word.Application
wordApp.Visible = True
wordApp.Documents.Add()
wordApp.Selection.PasteSpecial(Link:=True, DisplayAsIcon:=True)
```
```
var wordApp = new Word.Application();
wordApp.Visible = true;
wordApp.Documents.Add();
wordApp.Selection.PasteSpecial(Link: true, DisplayAsIcon: true);
```
Dieser Code veranschaulicht mehrere der neuen Funktionen in C#: die Möglichkeit, das ref-Schlüsselwort in der COM-Programmierung auszulassen, benannte Argumente sowie optionale Argumente. Diese Funktionen sind bereits in Visual Basic vorhanden. Die PasteSpecial-Methode verfügt über sieben Parameter, die als optionale Verweisparameter definiert sind. Vor Visual C# 2010 mussten Sie Objektvariablen definieren, die als Argumente für die sieben Parameter verwendet wurden, auch wenn Sie keine aussagekräftigen Werte zum Übertragen hatten. Benannte und optionale Argumente ermöglichen es Ihnen, die Parameter festzulegen, auf die Sie namentlich zugreifen möchten, und Argumente nur an diese Parameter zu senden. In diesem Beispiel werden Argumente gesendet, um anzugeben, dass ein Link zur Arbeitsmappe in der Zwischenablage erstellt werden soll (Parameter Link) und dass der Link im Word-Dokument als Symbol angezeigt werden soll (Parameter DisplayAsIcon). Visual C# 2010 ermöglicht auch das Weglassen des ref-Schlüsselworts für diese Argumente. Vergleichen Sie das folgende Codesegment von Visual C# 2008 mit der einzelnen, in Visual C# 2010 erforderlichen Zeile:
```
// Call to PasteSpecial in Visual C# 2008. 
object iconIndex = Type.Missing;
object link = true;
object placement = Type.Missing;
object displayAsIcon = true;
object dataType = Type.Missing;
object iconFileName = Type.Missing;
object iconLabel = Type.Missing;
wordApp.Selection.PasteSpecial(ref iconIndex,
                               ref link,
                               ref placement,
                               ref displayAsIcon,
                               ref dataType,
                               ref iconFileName,
                               ref iconLabel);

// Call to PasteSpecial in Visual C# 2010.
wordApp.Selection.PasteSpecial(Link: true, DisplayAsIcon: true);
```

So führen Sie die Anwendung aus

Drücken Sie F5, um die Anwendung auszuführen. Excel wird gestartet und zeigt eine Tabelle mit den Informationen der beiden Konten in bankAccounts an. Anschließend wird ein Word-Dokument angezeigt, das einen Link zur Excel-Tabelle enthält.

So bereinigen Sie das abgeschlossene Projekt

Klicken Sie in Visual Studio auf Projektmappe bereinigen im Menü Erstellen. Andernfalls wird das Add-In jedes Mal ausgeführt, wenn Sie Excel auf Ihrem Computer öffnen.

So suchen Sie den PIA-Verweis

Führen Sie die Anwendung erneut aus, klicken Sie jedoch nicht auf Projektmappe bereinigen.
Klicken Sie im Menü Start auf Alle Programme. Klicken Sie anschließend auf Microsoft Visual Studio 2013, dann Visual Studio-Tools und dann auf Visual Studio-Eingabeaufforderung (2013).
Geben Sie im Fenster "Visual Studio-Eingabeaufforderung (2013)" Ildasm ein, und drücken Sie dann die EINGABETASTE. Das IL DASM-Fenster wird angezeigt.
Klicken Sie im IL DASM-Fenster im Menü Datei auf Öffnen. Doppelklicken Sie auf Visual Studio 2013 und dann noch einmal auf Projekte. Öffnen Sie den Ordner für das Projekt, und suchen Sie im Ordner "bin/Debug" nach der Datei "Projektname.dll". Doppelklicken Sie auf "Projektname.dll". In einem neuen Fenster werden die Attribute Ihres Projekts sowie Verweise auf andere Module und Assemblys angezeigt. Beachten Sie, dass die Namespaces Microsoft.Office.Interop.Excel und Microsoft.Office.Interop.Word in der Assembly enthalten sind. Standardmäßig importiert der Compiler in Visual Studio 2013 die benötigten Typen aus einer referenzierten PIA in Ihre Assembly.

Weitere Informationen finden Sie unter Gewusst wie: Ansichtsassemblyinhalt.
Doppelklicken Sie auf das Symbol MANIFEST. Es wird ein Fenster angezeigt, das eine Liste von Assemblys enthält, die vom Projekt referenzierte Elemente enthalten. Microsoft.Office.Interop.Excel und Microsoft.Office.Interop.Word sind nicht in der Liste enthalten. Da die Typen, die das Projekt benötigt, in die Assembly importiert wurden, sind keine Verweise auf eine PIA erforderlich. Dadurch wird die Bereitstellung vereinfacht. Die PIAs müssen nicht auf dem Computer des Benutzers vorhanden sein, und da für eine Anwendung keine bestimmte PIA-Version bereitgestellt werden muss, können die Anwendungen so konzipiert sein, dass sie mit mehreren Versionen von Office funktionieren, sofern die erforderlichen APIs in allen Versionen vorhanden sind.

Da die Bereitstellung von primären Interop-Assemblys nicht mehr benötigt wird, können Sie eine Anwendung in erweiterten Szenarien erstellen, bei denen mehrere Versionen von Office, einschließlich früherer Versionen, verwendet werden. Dies funktioniert jedoch nur, wenn Ihr Code keine APIs verwendet, die nicht in der Version von Office verfügbar sind, mit der Sie arbeiten. Es ist nicht immer klar, ob eine bestimmte API in einer früheren Version verfügbar war; daher wird die Arbeit mit früheren Office-Versionen nicht empfohlen.

Hinweis

Office hat vor Office 2003 keine PIAs veröffentlicht.Aus diesem Grund besteht die einzige Möglichkeit zum Generieren einer Interop-Assembly für Office 2002 oder früheren Versionen darin, den COM-Verweis zu importieren.
Schließen Sie das Manifest-Fenster und das Assembly-Fenster.

So stellen Sie die PIA-Abhängigkeit wieder her

Klicken Sie im Projektmappen-Explorer auf die Schaltfläche Alle Dateien anzeigen. Erweitern Sie den Ordner Verweise, und wählen Sie Microsoft.Office.Interop.Excel aus. Drücken Sie F4, um das Fenster Eigenschaften anzuzeigen.
Ändern Sie im Fenster Eigenschaften die Eigenschaft Interop-Typen einbetten von True in False.
Wiederholen Sie die Schritte 1 und 2 in dieser Prozedur für Microsoft.Office.Interop.Word.
Kommentieren Sie in C# die beiden Aufrufe von Autofit am Ende der DisplayInExcel-Methode aus.
Drücken Sie F5, um sicherzustellen, dass das Projekt immer noch ordnungsgemäß ausgeführt wird.
Wiederholen Sie die Schritte 1 bis 3 der vorherigen Prozedur, um das Assembly-Fenster zu öffnen. Beachten Sie, dass Microsoft.Office.Interop.Word und Microsoft.Office.Interop.Excel nicht mehr in der Liste der eingebetteten Assemblys sind.
Doppelklicken Sie auf das Symbol MANIFEST, und führen Sie einen Bildlauf durch die Liste der referenzierten Assemblys durch. Microsoft.Office.Interop.Word und Microsoft.Office.Interop.Excel befinden sich in der Liste. Da die Anwendung auf die Excel- und Word-PIAs verweist und die Eigenschaft Interop-Typen einbetten auf False gesetzt ist, müssen beide Assemblys auf dem Computer des Endbenutzers vorhanden sein.
Klicken Sie in Visual Studio im Menü Erstellen auf Projektmappe bereinigen, um das abgeschlossene Projekt zu bereinigen.

Siehe auch

Freigeben über