Bindung von Office-Automatisierungsservern mit Visual C# .NET

SPRACHE AUSWÄHLEN SPRACHE AUSWÄHLEN
Artikel-ID: 302902 - Produkte anzeigen, auf die sich dieser Artikel bezieht
Dieser Artikel wurde zuvor veröffentlicht unter D302902
Dieser Artikel ist eine Übersetzung des folgenden englischsprachigen Artikels der Microsoft Knowledge Base:
302902 Binding for Office automation servers with Visual C# .NET
Bitte beachten Sie: Bei diesem Artikel handelt es sich um eine Übersetzung aus dem Englischen. Es ist möglich, dass nachträgliche Änderungen bzw. Ergänzungen im englischen Originalartikel in dieser Übersetzung nicht berücksichtigt sind. Die in diesem Artikel enthaltenen Informationen basieren auf der/den englischsprachigen Produktversion(en). Die Richtigkeit dieser Informationen in Zusammenhang mit anderssprachigen Produktversionen wurde im Rahmen dieser Übersetzung nicht getestet. Microsoft stellt diese Informationen ohne Gewähr für Richtigkeit bzw. Funktionalität zur Verfügung und übernimmt auch keine Gewährleistung bezüglich der Vollständigkeit oder Richtigkeit der Übersetzung.
Alles erweitern | Alles schließen

Auf dieser Seite

Zusammenfassung

Wenn Sie eine Anwendung, wie beispielsweise eine Microsoft Office-Anwendung, automatisieren möchten, müssen Sie die Aufrufe für Eigenschaften und Methoden für die Objekte dieser Office-Anwendung auf eine bestimmte Weise an diese Objekte binden. Der Prozess des Verbindens von Eigenschafts- und Methodenaufrufen mit den Objekten, die diese Eigenschaften und Methoden implementieren, wird im Allgemeinen als Bindung bezeichnet. In Visual C# stehen zwei Arten der Bindung zur Verfügung: Frühe Bindung und Späte Bindung. Die Art der von Ihnen gewählten Bindung kann sich auf viele Aspekte Ihres Programms auswirken, zum Beispiel auf die Leistung, die Flexibilität und die Wartungsfreundlichkeit.

Dieser Artikel erklärt und vergleicht die frühe und die späte Bindung für Visual C#-Automatisierungsclients und enthält Codebeispiele, die beide Bindungstypen veranschaulichen.

Frühe Bindung

Bei der frühen Bindung verwendet Visual C# Typinformationen, die zu der jeweiligen Office-Anwendung verfügbar sind, um eine direkte Bindung an die erforderlichen Methoden oder Eigenschaften vorzunehmen. Der Compiler kann Typ- und Syntaxprüfungen durchführen, um sicherzustellen, dass die richtige Anzahl und der richtige Typ von Parametern an die Methode oder die Eigenschaft übergeben werden, und dass der zurückgegebene Wert dem erwarteten Typ entspricht. Da es weniger Aufwand erfordert, einen Eigenschafts- oder Methodenaufruf zur Laufzeit auszuführen, ist die frühe Bindung in manchen Fällen schneller. Die Leistungsunterschiede im Vergleich zur späten Bindung sind jedoch oft nur geringfügig.

Ein gewisser Nachteil der frühen Bindung besteht darin, dass sie zu Problemen in Bezug auf die Versionskompatibilität führen kann. Nehmen Sie beispielsweise an, dass ein Automatisierungsserver wie Microsoft Excel 2002 eine neue Methode oder Eigenschaft einführt, die in Excel 2000 nicht verfügbar war, oder eine Änderung an einer vorhandenen Eigenschaft oder Methode vornimmt. Diese Änderungen können die binäre Anordnung des Objekts verändern und Probleme mit einer Visual C#-Anwendung verursachen, die die Excel 2002-Typinformationen zum Automatisieren von Excel 2000 verwendet. Es wird im Allgemeinen empfohlen, beim Entwickeln und Testen Ihres Automatisierungsclients die Typinformationen für die früheste Version der Office-Anwendung zu verwenden, die Sie unterstützen möchten, um dieses bei der frühen Bindung auftretende Problem zu vermeiden.

In der folgenden Anleitung wird veranschaulicht, wie Sie einen Automatisierungsclient erstellen können, der die frühe Bindung verwendet. Beachten Sie, dass es die frühe Bindung (wie aus der Anleitung ersichtlich) erfordert, einen Verweis auf die Typbibliothek für den Automatisierungsclient anzulegen.

Erstellen eines Automatisierungsclients mit früher Bindung

  1. Starten Sie Microsoft Visual Studio .NET. Klicken Sie im Menü Datei auf Neu, und klicken Sie anschließend auf Projekt. Wählen Sie aus der Liste der Visual C#-Projekttypen die Option Windows-Anwendung. Form1 wird standardmäßig erstellt.
  2. Fügen Sie der Microsoft Excel Object Library einen Verweis hinzu. Gehen Sie hierzu folgendermaßen vor:
    1. Klicken Sie im Menü Projekt auf Verweis hinzufügen.
    2. Suchen Sie die Microsoft Excel Object Library auf der Registerkarte COM, und klicken Sie anschließend auf Auswählen.

      Hinweis Office 2003 beinhaltet Primäre Interop-Assemblys (Primary Interop Assemblies = PIAs). In Office XP sind zwar keine PIAs enthalten, Sie können diese jedoch bei Bedarf downloaden. Weitere Informationen zu Office XP-PIAs finden Sie im folgenden Artikel der Microsoft Knowledge Base:
      328912 Primäre Microsoft Office XP-Interop-Assembly (Pia) sind zu Download verfügbar
    3. Klicken Sie im Dialogfeld Verweise hinzufügen auf OK, um Ihre Auswahl zu übernehmen. Klicken Sie auf Ja, wenn Sie gefragt werden, ob für die von Ihnen gewählten Bibliotheken Wrapper erstellt werden sollen.
  3. Wählen Sie im Menü Ansicht die Option Toolbox, um die Toolbox anzuzeigen, und fügen Sie Form1 eine Schaltfläche hinzu.
  4. Doppelklicken Sie auf Button1 (Schaltfläche 1). Das Codefenster für die Form wird angezeigt.
  5. Ersetzen Sie im Codefenster folgenden Code
    private void button1_Click(object sender, System.EventArgs e)
    {
    }
    					
    durch:
    private void button1_Click(object sender, System.EventArgs e)
    {
    	Excel.Application objApp;
    	Excel._Workbook objBook;
    	Excel.Workbooks objBooks;
    	Excel.Sheets objSheets;
    	Excel._Worksheet objSheet;
    	Excel.Range range;
    	try
    	{
    		// Instantiate Excel and start a new workbook.
    		objApp = new Excel.Application();
    		objBooks = objApp.Workbooks;
    		objBook = objBooks.Add( Missing.Value );
    		objSheets = objBook.Worksheets;
    		objSheet = (Excel._Worksheet)objSheets.get_Item(1);
    		range = objSheet.get_Range("A1", Missing.Value);
    		range.set_Value(Missing.Value, "Hello, World!" );
    		//Return control of Excel to the user.
    		objApp.Visible = true;
    		objApp.UserControl = true;
    	}
    	catch( Exception theException ) 
    	{
    		String errorMessage;
    		errorMessage = "Error: ";
    		errorMessage = String.Concat( errorMessage, theException.Message );
    		errorMessage = String.Concat( errorMessage, " Line: " );
    		errorMessage = String.Concat( errorMessage, theException.Source );
    		MessageBox.Show( errorMessage, "Error" );
    	}
    }  
    					
  6. Gehen Sie im Codefenster per Bildlauf ganz nach oben. Fügen Sie am Ende der Liste der using-Direktiven die folgende Zeile hinzu:
    using System.Reflection;
    using Excel = Microsoft.Office.Interop.Excel;
    					

Späte Bindung

Im Gegensatz zur frühen Bindung wird bei der späten Bindung bis zur Laufzeit abgewartet, um die Eigenschafts- und Methodenaufrufe an ihre jeweiligen Objekte zu binden. Hierzu muss das Zielobjekt eine spezielle COM-Schnittstelle implementieren: IDispatch. Die Methode IDispatch::GetIDsOfNames erlaubt es Visual C#, ein Objekt auf die unterstützten Eigenschaften und Methoden hin abzufragen. Mithilfe der Methode IDispatch::Invoke kann Visual C# diese Methoden und Eigenschaften anschließend aufrufen. Die späte Bindung auf diese Weise hat den Vorteil, dass einige der Versionsabhängigkeiten vermieden werden, die für die frühe Bindung typisch sind. Die Nachteile dieses Verfahrens bestehen jedoch darin, dass Prüfungen der Integrität des Automatisierungscodes bei der Kompilierung entfallen, und dass keine Intellisense-Funktionen verfügbar sind, die Hinweise auf die korrekten Aufrufe für Methoden und Eigenschaften geben könnten.

Verwenden Sie die Methode System.Type.InvokeMember, um die späte Bindung in Visual C# zu verwenden. Diese Methode ruft IDispatch::GetIDsOfNames und IDispatch::Invoke auf, um eine Bindung an die Methoden und Eigenschaften des Automatisierungsservers vorzunehmen.

Erstellen eines Automatisierungsclients mit später Bindung

  1. Starten Sie Microsoft Visual Studio .NET. Klicken Sie im Menü Datei auf Neu, und klicken Sie anschließend auf Projekt. Wählen Sie aus der Liste der Visual C#-Projekttypen die Option Windows-Anwendung. Form1 wird standardmäßig erstellt.
  2. Wählen Sie im Menü Ansicht die Option Toolbox, um die Toolbox anzuzeigen, und fügen Sie Form1 eine Schaltfläche hinzu.
  3. Doppelklicken Sie auf Button1 (Schaltfläche 1). Das Codefenster für die Form wird angezeigt.
  4. Ersetzen Sie im Codefenster den folgenden Code
    private void button1_Click(object sender, System.EventArgs e)
    {
    }
    						
    durch den Code:
    private void button1_Click(object sender, System.EventArgs e)
    {
    	object objApp_Late;
    	object objBook_Late;
    	object objBooks_Late;
    	object objSheets_Late;
    	object objSheet_Late;
    	object objRange_Late;
    	object[] Parameters;
    
    	try
    	{
    		// Get the class type and instantiate Excel.
    		Type objClassType; 
    		objClassType = Type.GetTypeFromProgID("Excel.Application"); 
    		objApp_Late = Activator.CreateInstance(objClassType);
    
    		//Get the workbooks collection.
    		objBooks_Late = objApp_Late.GetType().InvokeMember( "Workbooks", 
    		BindingFlags.GetProperty, null, objApp_Late, null );
    
    		//Add a new workbook.
    		objBook_Late = objBooks_Late.GetType().InvokeMember( "Add", 
    			BindingFlags.InvokeMethod, null, objBooks_Late, null );
    
    		//Get the worksheets collection.
    		objSheets_Late = objBook_Late.GetType().InvokeMember( "Worksheets",
    			BindingFlags.GetProperty, null, objBook_Late, null );
    
    		//Get the first worksheet.
    		Parameters = new Object[1];
    		Parameters[0] = 1;
    		objSheet_Late = objSheets_Late.GetType().InvokeMember( "Item", 
    			BindingFlags.GetProperty, null, objSheets_Late, Parameters );
    
    		//Get a range object that contains cell A1.
    		Parameters = new Object[2];
    		Parameters[0] = "A1";
    		Parameters[1] = Missing.Value;
    		objRange_Late = objSheet_Late.GetType().InvokeMember( "Range",
    			BindingFlags.GetProperty, null, objSheet_Late, Parameters );
    
    		//Write "Hello, World!" in cell A1.
    		Parameters = new Object[1];
    		Parameters[0] = "Hello, World!";
    		objRange_Late.GetType().InvokeMember( "Value", BindingFlags.SetProperty, 
    			null, objRange_Late, Parameters );
    
    		//Return control of Excel to the user.
    		Parameters = new Object[1];
    		Parameters[0] = true;
    		objApp_Late.GetType().InvokeMember( "Visible", BindingFlags.SetProperty,
    			null, objApp_Late, Parameters );
    		objApp_Late.GetType().InvokeMember( "UserControl", BindingFlags.SetProperty,
    			null, objApp_Late, Parameters );
    	}
    	catch( Exception theException ) 
    	{
    		String errorMessage;
    		errorMessage = "Error: ";
    		errorMessage = String.Concat( errorMessage, theException.Message );
    		errorMessage = String.Concat( errorMessage, " Line: " );
    		errorMessage = String.Concat( errorMessage, theException.Source );
    
    		MessageBox.Show( errorMessage, "Error" );
    	}
    }
    					
  5. Gehen Sie im Codefenster per Bildlauf ganz nach oben. Fügen Sie am Ende der Liste der using-Direktiven die folgende Zeile hinzu:
     using System.Reflection;  					

Informationsquellen

Weitere Informationen finden Sie auf folgender MSDN-Website:
Microsoft Office Development with Visual Studio (Microsoft Office-Entwicklung mit Visual Studio)
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnoxpta/html/vsofficedev.asp
Weitere Informationen zur Bindung finden Sie in den folgenden Artikeln der Microsoft Knowledge Base:
245115 Verwenden der frühen Bindung und spät von Binden in Automatisierung
244167 Erstellen von Automatisierungsclients für verschiedene Office-Versionen
247579 Verwenden Sie DISPID, Sie Automatisierung von Office-Anwendungen nach Möglichkeit binden

Eigenschaften

Artikel-ID: 302902 - Geändert am: Dienstag, 2. Mai 2006 - Version: 7.2
Die Informationen in diesem Artikel beziehen sich auf:
  • Microsoft Visual C# .NET 2003 Standard Edition
  • Microsoft Visual C# .NET 2002 Standard Edition
  • Microsoft Office Access 2003
  • Microsoft Access 2002 Standard Edition
  • Microsoft Office Excel 2003
  • Microsoft Excel 2002 Standard Edition
  • Microsoft Office PowerPoint 2003
  • Microsoft PowerPoint 2002 Standard Edition
  • Microsoft Office Word 2003
  • Microsoft Word 2002 Standard Edition
Keywords: 
kbpia kbautomation kbhowtomaster KB302902
Microsoft stellt Ihnen die in der Knowledge Base angebotenen Artikel und Informationen als Service-Leistung zur Verfügung. Microsoft übernimmt keinerlei Gewährleistung dafür, dass die angebotenen Artikel und Informationen auch in Ihrer Einsatzumgebung die erwünschten Ergebnisse erzielen. Die Entscheidung darüber, ob und in welcher Form Sie die angebotenen Artikel und Informationen nutzen, liegt daher allein bei Ihnen. Mit Ausnahme der gesetzlichen Haftung für Vorsatz ist jede Haftung von Microsoft im Zusammenhang mit Ihrer Nutzung dieser Artikel oder Informationen ausgeschlossen.

Ihr Feedback an uns

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com