Dariusz Parys Developer Group Microsoft GmbH Email: [email protected] Interoperabilität Microsoft.NET und COM+

Dariusz ParysDeveloper GroupMicrosoft GmbH

Email: [email protected]

InteroperabilitätInteroperabilität

Microsoft .NET und COM+

Microsoft .NET und COM+ 2

Agenda

Warum Interoperabilität? Integration mit COM Nutzung von COM+ Diensten API Aufrufe in native Win32 DLL’s


Warum Interoperabilität?

Sicherung der Investitionen

• Entwicklungskosten

• Stabilität der Software

Bestehende Funktionalität nutzen und diese Erweitern

• Zeitgewinn

• Mehrwert durch neue Möglichkeiten

Langsames Ersetzen der Software

• Migration: Schritt für Schritt

Manchmal hat man keine andere Wahl


Unterschiede .NET - COM

.NET Framework Typen Standard Metadaten Interface basierend New operator Cast operator Exceptions Managed Object

Lifetime Strong Names

COM / DLL Modell Binärer Standard Typbibliotheken Objekt basierend CoCreateInstance QueryInterface HResults Referenzzähler

GUIDS


Interop Möglichkeiten

COM Interop

• COM Objekte aus der .NET Welt nutzen

• .NET Objekte aus der COM Welt nutzen

• COM+ Dienste in .NET nutzen

Platform Invoke Service (PInvoke)

• Native Win32 API Aufrufe aus .NET heraus


COM Objekte aus .NET nutzenCOM Objekte aus .NET nutzen


Drei Schritte zu COM

Referenzieren eines Interop Assemblies Instanzieren des Typen mit „new“ Nutzung der Funktionalität


Was ist ein Interop Assembly?

Enthält keinerlei ausführbaren Code Nur Typendefinitionen die im COM

Objekt implementiert sind Grundlage für den RCW zur Laufzeit um

die Typen zu binden Grundlage für das Marshaling der Daten

zwischen beiden Welten


Woher bekomme ich ein Interop Assembly?

Vorzugsweise vom „Hersteller“

• PIA (Primary Interop Assembly)

In VS .NET durch „Add References...“ Mit Hilfe des Tools

• TLBIMP.EXE


Interop Assemblies

Interop Assemblies müssen zur Laufzeit verfügbar sein

• Der Assembly Loader muß diese finden

Installation ins Applikationsverzeichnis

• Einfaches XCOPY

Oder Installation in den Global Assembly Cache

• Strong Name für Assembly (SN)

• Installation mit GACUTIL


COM Objekt aus .NET

Managed Unmanaged

Client COM Objekt

IUnknown

IFoo?RuntimeCallableWrapper

TracedReference

ReferenceCounted


Runtime Callable Wrapper

Proxy Objekt der Runtime Pro COM Objekt Instanz ein RCW Handhabt das Marshaling der Daten Verbirgt COM spezifische Aufrufe

• Bestimmte Interfaces wie IUnknown, IDispatch, etc…

Stellt jedoch Interfaces des Objektes .NET zur Verfügung


RCW bietet Transparenz

Kein Referenzzähler Keine GUID Keine HRESULT, Fehler werden als

Exception geworfen Kein QueryInterface, einfach ein cast

auf das entsprechende Interface

• InvalidCastException <-> E_NOINTERFACE


Demo

COM Objekt in .NET nutzen

COM Objekt in .NET nutzen


Denkanstöße

Ziel von COM Interop ist es existierende Funktionalität zu nutzen

Kein Ersatz für richtige “managed” Objekte

• Keine Konstruktoren

• Keine Vererbung

• Kein Überladen von Funmktionen

• Keine statischen Funktionen

Überlegung RCW’s zu wrappen


.NET Objekte aus COM nutzen.NET Objekte aus COM nutzen


Drei Schritte zu .NET

Erstellen einer Typenbibliothek Instanzieren des Objektes

• CoCreateInstance

• Oder “new” in VB6

Nutzung der Funktionalität


Wie erstelle ich die Typenbibliothek?

Mit Visual Studio .NET

• Einstellung in den Projektproperties• “Register for COM Interoperability”

Manuell

• Mit TLBEXP.EXE und REGASM.EXE


COM Objekt aus .NET

Unmanaged Managed

Client .NET ObjektIUnknown

IFoo ?COM

CallableWrapper

TracedReference

ReferenceCounted


COM Callable Wrapper

Proxy für COM Clients um auf Managed Code zuzugreifen

Pro .NET Objekt Instanz ein CCW Handhabt das Marshaling der Daten Simuliert COM Interfaces wie IUnknown,

IDispatch, etc… Verwendung von Klasseninterface per

Attribute


Design für Interoperabilität

Einschränkungen• Nur öffentlich Typen sind Sichtbar

• Nur öffentliche Funktionen/Props sind sichtbar

• Shared/Static Member sind nicht erreichbar

• Überladene Funktionen haben andere Namen

• Benötigen einen public default Konstruktor

Tips• Funktionalität durch Interfaces verfügbar machen

• Custom Attributes um Marshaling zu beeinflußen


Nützliche Informationen (1/2)

Klasseninterface kann automatisch erzeugt werden

• In VB: Benutzung des ComClass Attributes

• In C#: Benutzung des ClassInterfaceType Attributes

GUID’s werden beim Export automatisch erstellt

• Basierend auf Assembly und Typenbezeichnung

• Basierend auf kompletter Interfacebeschreibung


Nützliche Informationen (2/2)

Assembly muß zur Laufzeit aufgelöst werden können

• Wird nicht über InProcServer32 aufgelöst

• Assemblies liegen im Applikationsverzeichnis

• Oder sind im Global Assembly Cache installiert


Interop Attribute

Using System.Runtime.InteropServices

[Guid(…), InterfaceType(ComInterfaceType.IsIUnknown)]

Interface IFooBar {

[DispId(64)] int Format( [MarshalAs(LPStr)] String s)

}

Mit Interop Attributen* kann man beim Export Mit Interop Attributen* kann man beim Export die Umsetzung auf COM Typen Definitionen die Umsetzung auf COM Typen Definitionen beeinflußen. Dies gilt für Typen, Methoden, beeinflußen. Dies gilt für Typen, Methoden, Eigenschaften, Felder oder Parameter.Eigenschaften, Felder oder Parameter.

* Attribute werden nicht nur für Interop genutzt* Attribute werden nicht nur für Interop genutzt


Parameter Umsetzung

COM Method Signature

HRESULT FormatDate(BSTR s, DATE d, [out, retval] int *retval);

int FormatDate(String s, DateTime d);

.NET Method Signature


Datentypen Umwandlung

DATE System.DateTimeBSTR System.StringSafearray( int ) Int[]OLECOLOR System.Drawing.ColorCURRENCY System.DecimalVariant System.ObjectInterface Foo Interface FooCoclass Foo Class Foo


Mehr Marshaling…

Blittable Datentypen werden direkt übergeben

• z.B. Byte, Short, Integer, Long, Single, Double

Einige Typen brauchen besondere Handhabung

• z.B. BOOLEAN: 2 oder 4 byte value, Wert True 1 oder -1


Blittable Typen

System.Byte, System.SByte System.Int16, System.UInt16 System.Int32, System.UInt32 System.Int64 System.IntPtr, System.UIntPtr


Nicht Blittable Typen

System.Array C-Style Array oder SafeArray

System.Boolean 1, 2 oder 4 Byte mit 1 oder -1

System.Char Unicode oder AnsiSystem.Class KlasseninterfaceSystem.Object Variant oder

KlasseninterfaceSystem.String Nullterminierter String

oder BSTRSystem.ValueType Struktur


Demo

Nutzung von .NET Objekten aus COM

Nutzung von .NET Objekten aus COM


COM+ Dienste in .NETCOM+ Dienste in .NET


Was ist zu tun?

Namespace: System.EnterpriseServices Beinhaltet eine Vielzahl Attribute und

Objekte Eigene Klasse ableiten von

ServicedComponent

• Eventuell überschreiben der COM+ spezifischen Methoden

Mit Attributen die entsprechenden Services definieren


Beispiel 1: ObjectPooling

Namespace Beispiel1{ [ ObjectPooling( 5, 20 ) ] public class PooledKlasse : ServicedComponent { public PooledKlasse() {} // Überschreiben von CanBePooled protected override bool CanBePooled() { return true; // Notwendig damit Reused wird! } }}


Beispiel 2: Transaktionen

Using System.EnterpriseServices;[ assembly: ApplicationName( “MeineApplikation” ) ][ assembly: ApplicationActivation( ActivationOption.Library ) ]

Namespace Beispiel2{ [ Transaction( TransactionOption.Required ) ] public class TransaktionsKlasse : ServicedComponent { public TransaktionsKlasse() {} }}


Demo

Object Pooling mit .NETObject Pooling mit .NET


In Win32 DLL’s reinrufenIn Win32 DLL’s reinrufen


Platform Invoke (P/Invoke)

Zugriff auf statische Einstiegspunkte von nativen DLL’s

Ähnlich:

• Declare statement aus VB 6

• Load library / GetProcAddress

Methoden Definitionen müssen mit Custom Attributes zur Verfügung gestellt werden

Benutzt ebenfalls den COM Interop Marshaling Service


Platform Invoke Beispiel #1

public class Win32API

{

[DllImport(“User32.dll”,EntryPoint=“MessageBox”)]

public static extern Boolean MsgBox(…);

}


Platform Invoke Beispiel #2

[StructLayout(LayoutKind.Sequential)]

Public struct OSInfo (

uint MajorVersion;

uint MinorVersion;

String VersionString;

}

public class Win32API {

[DllImport(“User32.dll”)]

public static extern Boolean GetVersionEx(OSInfo osi);

}


String vs. Stringbuilder

System.String

• Strings sind nicht veränderbar

System.Text.StringBuilder

• Aufruf von API’s die einen Buffer erwarten, die StringBuilder Klasse einsetzen

[C#]

uint sz = 256;StringBuilder sb = new StringBuilder( ( int ) sz );GetUserName( sb, ref sz );


Demo

Aufrufe mit P/InvokeAufrufe mit P/Invoke


Wie sieht es mit Performance aus?

Umwandlungen haben Overhead• Ca. 30 Instruktionen pro Aufruf

Daten Marshaling verursacht ebenfalls Overhead• Abhängig von Typ und Größe

• Blittable Typen direkt Gezielt nutzen

• Nur aufrufen wenn es sein muß Alternativen in Betracht ziehen

• Kann man den Code vielleicht doch migrieren?


Zusammenfassung

Interop Services ermöglichen Nutzung bestehender und zukünftiger Funktionalität in beiden Welten

Interop kann bei der Migration behilflich sein

Nutzung der COM+ basierten Dienste für .NET Objekte


Links und Ressourcen

So bringen Sie COM und .NET in Einklang

• http://www.microsoft.com/germany/ms/msdnbiblio/show_all.asp?siteid=500418

Microsoft .NET / COM Migration and Interoperability• http://msdn.microsoft.com/library/en-us/dn

bda/html/cominterop.asp


Fragen!?

Uff...Uff...

Documents

Dariusz Parys Developer Group Microsoft GmbH Email: [email protected] Interoperabilität Microsoft.NET und COM+