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

Artikel
02/26/2013

Visual Studio 2010 stellt neue Funktionen in C# und Visual Basic zur Verbesserung der Microsoft Office-Programmierung bereit.Jede Sprache verfügt über hinzugefügte Funktionen, die in der anderen Sprache bereits vorhanden sind.

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

Beide Sprachen ermöglichen das Einbetten von Typinformationen, sodass Assemblys bereitgestellt werden können, die mit COM-Komponenten interagieren, ohne primäre Interopassemblys (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, wobei viele dieser Funktionen auch bei der allgemeinen Programmierung nützlich sind.In dieser exemplarischen Vorgehensweise verwenden Sie zunächst eine Excel-Add-In-Anwendung, um eine Excel-Arbeitsmappe zu erstellen.Anschließend erstellen Sie ein Word-Dokument, das einen Link zu der Arbeitsmappe enthält.Zum Schluss wird gezeigt, wie Sie die PIA-Abhängigkeit aktivieren bzw. deaktivieren können.

Vorbereitungsmaßnahmen

Zur Durchführung dieser exemplarischen Vorgehensweise müssen Microsoft Office Excel 2010 oder 2007 und Microsoft Office Word 2010 oder 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.

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 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 den Eintrag Visual Basic oder Visual C#, erweitern Sie Office, und klicken Sie dann auf 2010 (oder 2007, wenn Sie Office 2007 verwenden).
Klicken Sie im Bereich Vorlagen auf Excel 2010-Add-In (bzw. Excel 2007-Add-in).
Stellen Sie oben im Bereich Vorlagen sicher, dass .NET Framework 4 im Feld Zielframework angezeigt wird.
Wenn Sie möchten, können Sie im Feld Name einen Namen für das Projekt eingeben.
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 Registerkarte .NET in der Liste Komponentenname die Option Microsoft.Office.Interop.Excel 14.0.0.0 (oder Microsoft.Office.Interop.Excel 12.0.0.0 für Excel 2007) und dann bei gedrückt gehaltener STRG-TASTE Microsoft.Office.Interop.Word, Version 14.0.0.0 (bzw. Version 12.0.0.0 für Word 2007), aus.
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 oben in der Codedatei die folgenden Imports-Anweisungen (Visual Basic) oder die folgenden using-Direktiven (C#) hinzu, falls 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 Namen Ihres Projekts, klicken Sie auf Hinzufügen und dann auf Klasse.Nennen 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 folgenden Code:Die Klassendefinitionen verwenden automatisch implementierte Eigenschaften, die in Visual Studio 2010 für Visual Basic neu eingeführt wurden.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; }
}
```

Zum Erstellen einer bankAccounts-Liste mit zwei Konten fügen Sie der ThisAddIn_Startup-Methode in "ThisAddIn.vb" bzw. "ThisAddIn.cs" den folgenden Code hinzu.Die Listendeklarationen verwenden Auflistungsinitialisierer, die in Visual Studio 2010 für Visual Basic neu eingeführt wurden.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 in Excel

Fügen Sie in derselben Datei der ThisAddIn-Klasse die folgende Methode hinzu.Mit dieser Methode wird eine Excel-Arbeitsmappe eingerichtet, 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();
}
```
In dieser Methode werden zwei neue C#-Funktionen verwendet.Beide Funktionen sind in Visual Basic bereits vorhanden.
- 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 vorherigen 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).
  
  Weitere Informationen finden Sie unter Benannte und optionale Argumente (C#-Programmierhandbuch).
- Die Range- und Offset-Eigenschaften des Range-Objekts verwenden die Funktion für indizierte Eigenschaften.Diese Funktion ermöglicht Ihnen, diese Eigenschaften mit der folgenden typischen C#-Syntax für COM-Typen zu nutzen.Indizierte Eigenschaften ermöglichen Ihnen auch die Verwendung der Value-Eigenschaft des Range-Objekts, sodass die Value2-Eigenschaft nicht mehr verwendet werden muss.Die Value-Eigenschaft ist indiziert, der Index ist jedoch optional.Im folgenden Beispiel arbeiten optionale Argumente und indizierte Eigenschaften 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 keine eigenen indizierten Eigenschaften erstellen.Die Funktion unterstützt lediglich die Nutzung vorhandener indizierter Eigenschaften.
  
  Weitere Informationen finden Sie unter Gewusst wie: Indizierte Eigenschaften bei der COM-Interop-Programmierung (C#-Programmierhandbuch).
Fügen Sie am Ende von DisplayInExcel den folgenden Code hinzu, um die Spaltenbreiten 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 der von COM-Hosts wie z. B. Office zurückgegebenen Object-Werte als Werte vom Typ dynamic.Dies geschieht automatisch, wenn Interoptypen einbetten auf den Standardwert True festgelegt ist, oder wenn von der /link-Compileroption auf die Assembly verwiesen wird.Mit dem dynamic-Typ wird die späte Bindung ermöglicht, die in Visual Basic bereits verfügbar ist, und die in Visual C# 2008 und früheren Versionen der Sprache erforderliche explizite Umwandlung wird vermieden.

Beispielsweise gibt excelApp.Columns[1]Object zurück, und AutoFit ist eine Excel-Methode Bereich.Ohne dynamic müssen Sie das von excelApp.Columns[1] als Instanz von Range zurückgegebene Objekt umwandeln, bevor Sie die AutoFit-Methode 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 Interoptypen finden Sie weiter unten in diesem Thema unter "So suchen Sie den PIA-Verweis" und unter "So stellen Sie die PIA-Abhängigkeit wieder her".Weitere Informationen zu dynamic finden Sie unter dynamic (C#-Referenz) und unter Verwenden des Typs dynamic (C#-Programmierhandbuch).

So rufen Sie DisplayInExcel auf

Fügen Sie am Ende der ThisAddIn_StartUp-Methode den folgenden Code hinzu:Der Aufruf von DisplayInExcel enthält zwei Argumente.Das erste Argument ist der Name der Liste mit den Konten, die verarbeitet werden sollen.Das zweite Argument ist ein mehrzeiliger lambda-Ausdruck, mit dem definiert wird, wie die Daten verarbeitet werden sollen.Der ID-Wert und der balance-Wert für jedes Konto wird in angrenzenden Zellen angezeigt. Die Zeile wird rot unterlegt, wenn die Bilanz kleiner als 0 (null) ist.Bei mehrzeiligen lambda-Ausdrücken handelt es sich um 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 mit den Kontendaten wird angezeigt.

So fügen Sie ein Word-Dokument hinzu

Fügen Sie am Ende der ThisAddIn_StartUp-Methode den folgenden Code 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 bei der COM-Programmierung wegzulassen, sowie benannte und optionale Argumente.Diese Funktionen sind in Visual Basic bereits vorhanden.Die PasteSpecial-Methode hat sieben Parameter, die als optionale Verweisparameter definiert werden.In Versionen vor Visual C# 2010 mussten Sie Objektvariablen als Argumente für die sieben Parameter definieren, selbst wenn keine aussagekräftigen Werte zum Senden vorhanden waren.Benannte und optionale Argumente ermöglichen Ihnen, die Parameter, auf die Sie zugreifen möchten, nach Namen festzulegen, und nur an diese Parameter Argumente zu senden.In diesem Beispiel werden Argumente gesendet, um anzugeben, dass ein Link zur Arbeitsmappe in der Zwischenablage erstellt werden soll (Link-Parameter) und dass dieser Link im Word-Dokument als Symbol angezeigt werden soll (DisplayAsIcon-Parameter).Visual C# 2010 ermöglicht Ihnen außerdem, das ref-Schlüsselwort für diese Argumente wegzulassen.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 geöffnet und zeigt eine Tabelle mit den Informationen der beiden Konten in bankAccounts an.Anschließend wird ein Word-Dokument mit einem Link zu der Excel-Tabelle angezeigt.

So bereinigen Sie das abgeschlossene Projekt

Klicken Sie in Visual Studio im Menü Erstellen auf Projektmappe bereinigen.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 auf Microsoft Visual Studio 2010 und dann auf Visual Studio Tools und auf Visual Studio-Eingabeaufforderung (2010).
Geben Sie im Fenster der Visual Studio-Eingabeaufforderung (2010) 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 2010 und dann auf Projekte.Öffnen Sie den Ordner für Ihr Projekt, und suchen Sie im bin/Debug-Ordner nach Ihr Projektname.dll.Doppelklicken Sie auf Ihr Projektname.dll.Die Attribute Ihres Projekts sowie Verweise auf andere Module und Assemblys werden in einem neuen Fenster angezeigt.Beachten Sie, dass die Namespaces Microsoft.Office.Interop.Excel und Microsoft.Office.Interop.Word in der Assembly enthalten sind.In Visual Studio 2010 werden die erforderlichen Typen vom Compiler standardmäßig aus der primären Interopassembly, auf die verwiesen wird, in Ihre Assembly importiert.

Weitere Informationen finden Sie unter Gewusst wie: Ansichtsassemblyinhalt.

Doppelklicken Sie auf das Symbol MANIFEST.Daraufhin wird ein Fenster mit einer Liste von Assemblys angezeigt, die Elemente enthalten, auf die das Projekt verweist.Microsoft.Office.Interop.Excel und Microsoft.Office.Interop.Word sind in der Liste nicht enthalten.Da die für das Projekt erforderlichen Typen in die Assembly importiert wurden, sind Verweise auf eine primäre Interopassembly (PIA) nicht erforderlich.Dadurch wird die Bereitstellung vereinfacht.Die primären Interopassemblys müssen nicht auf dem Computer des Benutzers vorhanden sein, und da eine Anwendung nicht die Bereitstellung einer bestimmten PIA-Version erfordert, können Anwendungen entworfen werden, die mehrere Versionen von Office unterstützen. Voraussetzung ist, dass die erforderlichen APIs in allen Versionen vorhanden sind.

Da die Bereitstellung von primären Interopassemblys nicht mehr notwendig ist, können Sie eine Anwendung in komplexeren Szenarios erstellen, die mit mehreren Versionen von Office kompatibel ist, einschließlich früherer Versionen.Dies funktioniert jedoch nur, wenn alle im Code verwendeten APIs in der Office-Version, mit der Sie arbeiten, vorhanden sind.Da nicht immer klar ist, ob eine bestimmte API in einer früheren Version verfügbar war, wird die Arbeit mit früheren Office-Versionen nicht empfohlen.

Hinweis
Für Office wurden primäre Interopassemblys erst ab Office 2003 veröffentlicht.Wenn Sie eine Interopassembly für Office 2002 oder eine frühere Version erstellen möchten, müssen Sie daher den COM-Verweis importieren.

Schließen Sie das Manifestfenster und das Assemblyfenster.

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.Drücken Sie F4, um das Fenster Eigenschaften anzuzeigen.
Ändern Sie im Fenster Eigenschaften den Wert der Eigenschaft Interoptypen einbetten von True in False.
Wiederholen Sie Schritt 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 zu überprüfen, dass das Projekt immer noch ordnungsgemäß ausgeführt wird.
Wiederholen Sie Schritt 1 bis 3 der vorherigen Prozedur, um das Assemblyfenster zu öffnen.Beachten Sie, dass Microsoft.Office.Interop.Word und Microsoft.Office.Interop.Excel nicht mehr in der Liste der eingebetteten Assemblys enthalten sind.
Doppelklicken Sie auf das Symbol MANIFEST, und führen Sie einen Bildlauf durch die Liste der Assemblys, auf die verwiesen wird, durch.Microsoft.Office.Interop.Word und Microsoft.Office.Interop.Excel sind in der Liste enthalten.Da die Anwendung auf Excel- und Word-PIAs verweist und die Eigenschaft Interoptypen einbetten auf False festgelegt 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