COM+ Komponenten mit .NET Beta 2

COM+ Komponenten sind das Thema, wenn es um "high-end" n-Tier Anwendungen geht. Ob im Intranet oder Internet erreichen Anwendungen damit eine sehr gute Performance und sind skalierbar. In diesem Artikel beschreibe ich wie man mit Visual
Basic.NET eine kleine COM+ Komponente erzeugt. Ich setze voraus dass sich der Leser bereits mit COM+, dem MTS oder den Component Services unter Windows 2000 beschäftigt hat. Im .NET Framework der Beta2 gibt es einen neuen Namespace System.EnterpriseServices in dem sich alle Klassen befinden die Sie benötigen um eine COM+ Komponente zu erzeugen. Im wesentlichen ist das Erzeugen einer solchen Komponente sehr einfach, Sie müssen nur wissen wie Attribute in Visual Basic.NET verwendet wie Key Files für Assemblies erzeugt werden und wozu diese dienen.
Zum Code:
Die Klasse die Sie unter den Fitichen des Component Services laufen lassen wollen muss diese von der Basis Klasse ServicedComponent abgeleitet werden. Damit haben sie vollen Zugriff auf die Component Services.
Ich erzeuge in Visual Studio.NET ein "Empty Project" und füge im Solution Explorer Referenzen auf die System.dll und System.EnterpriseServices.dll hinzu. In den Eigenschaften des Projektes wähle ich bei Output Type Class Library aus. Danach füge ich an das Projekt eine neue Klasse namens Test1 hinzu.
Der Quell - Code:

Imports System
Imports System.EnterpriseServices
<Assembly: ApplicationName("GreetingsSC")>
<Assembly: ApplicationActivation(ActivationOption.Library)>
<Assembly: Description("COM+ Test Komponente")>

<Transaction(TransactionOption.Required), ObjectPooling(True, 5, 20), JustInTimeActivation(True)> _
Public Class Test1 : Inherits ServicedComponent
    <AutoComplete()> _
    Public Function SayHello(ByVal psName As String) As String
        Return "Hello there, " & psName
    End Function

End Class

Die Attribute <Assembly...> stellen die Eigenschaften für die COM+ Anwendung dar wie diese später durch die Component Services ausgeführt wird.
Wichtig sind dann die Attribute der Klasse Test1:
<Transaction(TransactionOption.Required)...> heisst dass dieses Objekt eine Transaktion benötigt. Läuft bereits eine Transaktion und das Objekt wird hieraus aufgerufen bleibt das Objekt innerhalb dieser Transaktion. Ist keine Transaktion vorhanden wird eine neue Transaktion gestartet.

ObjectPooling(True, 5, 20) stellt das Objekt Pooling für die Komponente an.
JustInTimeActiviation(True) stellt die JIT Aktivierung an oder aus.
Diese Attribute funktionieren momentan nur unter Windows 2000!!!!
<AutoComplete()> vor der Function SayHallo weisst den Component Services Dienst an, die Transaktion automatisiert abzuschliessen, d.h. tritt ein Fehler in der Komponente auf, wird die Transaktion gecancelt (SetAbort()), im anderen Fall natürlich SetComplete().
Das war der Quellcode.

Zum Schluss muss die Komponente noch registriert werden. Dazu gibt es zwei Möglichkeiten: Dynamisch oder manuell. Ich beschränke mich in diesem Artikel auf die dynamische Weise. Dazu muss noch ein sogenannter "Strong Name" für das Assembly erzeugt werden. So einen "Strong Name" kann man auf zwei Arten erzeugen, entweder über die sn.exe (Strong Name Tool) oder durch einfügen der entsprechenden Attribute in den Quellcode des Assemblys (Komponente). Bei der Methode mit dem Strong Name Tool wird ein Key File erzeugt mit dem man das Assembly eindeutig auszeichnen kann. Der Strong Name eines Assemblies besteht aus seinem Namen (GreetingsSC), der VersionsNummer, fals mitgelierfert der Kultur Informationen und einem Public Key. Dadurch soll eine Verwechslung zweier Assemblies ausgeschlossen sein und das soll uns ja bekanntlich aus der DLL Hell führen.
Ich mache das ganze über die IDE von Visual Studio.NET. Klicken Sie im Solution Explorer auf das Projekt (rechte Maustaste) und wählen Sie die Eigenschaften für das Projekt aus. Danach wählen Sie im Menu Punkt Strong Name: Generate Strong Name using aus und sagen Sie Generate Key File, das war?s und Sie können zu kompilieren anfangen.
Wollen Sie die Komponente nicht dynamisch registrieren, sondern manuell dann müssen Sie die mit dem Global Assembly Chache Utility (GacUtil.exe) bewerkstelligen. Achtung: Hierfür benötigen Sie einen StrongName für das Assembly!
Jetzt müssen Sie nur noch einen Client für die Komponente erzeugen. Ich habe einen Visual Basic.NET Windows Forms Client gebaut, der nur aus einem Formular, einer TextBox und einem Button besteht. Sie müssen in dem Projekt eine Referenz auf die von Ihnen zuvor erzeugte Komponente setzten.