<\/p>\n
Manfred Hoffbauer, Düsseldorf<\/b><\/p>\n
Das Microsoft.NET Framework hält mit über 4.000 wesentlich mehr Klassen bereit als Microsoft Access. Darunter befinden sich auch zahlreiche Klassen, bei denen dem Access-Entwickler das Wasser im Munde zusammenläuft. Der folgende Beitrag beschreibt ein paar Tricks, mit denen Sie eine .NET-Klasse als COM-Komponente kompilieren und mit Access benutzen können.<\/b><\/p>\n
Ein mit Microsoft .NET erstelltes Programm kann prinzipiell nur innerhalb des .NET-Frameworks ausgeführt werden. Demzufolge können Sie auch die mit .NET programmierten COM-Komponenten auf PCs ausführen, auf denen das .NET-Framwork installiert ist. Außerdem benötigen Sie einige Hilfsprogramme, die im Microsoft Visual Studio.NET und im Microsoft NET-Framework SDK enthalten sind. Als Programmeditor setzen wir SharpDevelop ein. Alle benötigten Komponenten können Sie kostenlos aus dem Internet laden und installieren.<\/p>\n
Eine Anleitung zur Installation und zur Anwendung der .NET-Entwicklungsumgebung SharpDevelop finden Sie im Beitrag .NET-Programmierung mit SharpDevelop in der vorliegenden Ausgabe von Access im Unternehmen. <\/p>\n
Das Component Object Model ist als weitgehend standardisierte Beschreibung für die Kommunikation zwischen Anwendungen unter Windows recht weit verbreitet.<\/p>\n
Viele Windows-Programme können COM-Komponenten unabhängig davon benutzen, mit welcher Programmiersprache sie erstellt wurden. Beispiele sind Microsoft Access, Microsoft C++, Microsoft Excel und Microsoft Visual Basic. Wenn eine Anwendung eine COM-Komponente benutzt, fungiert die Anwendung als COM-Client und die Komponente als COM-Server.<\/p>\n
Bei der Verwendung eines .NET-Programms mit Microsoft Access ist die .NET-Komponente der COM-Server und die Microsoft Access-Anwendung der COM-Client. Dieser Weg ist für Sie als Access-Programmierer zunächst der nahe liegende. Dank der COM-Schnittstelle können Sie Ihre Hauptanwendung weiterhin mit Microsoft Access entwickeln und .NET-Programmcode nur sporadisch per COM einfließen lassen.<\/p>\n
Wenn Sie später hauptsächlich mit .NET entwickeln sollten, dann wird Sie vielleicht schon jetzt beruhigen, dass der umgekehrte Weg ebenfalls möglich ist: Ein .NET-Programm kann bestehende COM-Komponenten als so genannten unsicheren Code verwenden. Diese Verfahrensweise benötigen Sie, um mit .NET auf Microsoft Excel und Microsoft Word zuzugreifen.<\/p>\n
Ein erstes Testprogramm soll zunächst die verschiedenen Schritte vom Quellcode zum COM-Server aufzeigen. Um wirklich nur die erforderlichen Schritte zu zeigen und etwaige Programmierfehler weitgehend auszuschließen, soll das Programm selbst möglichst einfach gehalten werden. Später erhält die Komponente weitere Klassen aus dem .NET-Framework. Dabei erhalten Sie unter anderem eine Klasse, mit der sich Zeichenketten ver- und entschlüsseln lassen.<\/p>\n
![](\"..\/fileadmin\/_temp_\/{C5818781-172B-472A-864C-C965CB39CB4C}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Bild 1: Mit diesem Dialog legen Sie eine neue Klassenbibliothek an.<\/span><\/b><\/p>\n Zur Eingabe des ersten Testprogramms starten Sie den kostenlosen Programmeditor SharpDevelop. Gehen Sie dann wie folgt vor (siehe Bild 1):<\/p>\n SharpDevelop legt eine neue Klassenbibliothek an und fügt die leere Klasse NewClass hinzu. Aus Gründen der übersichtlichkeit sollten Sie der Klasse einen sprechenden Namen geben. Klicken Sie den Eintrag NewClass.vb im Projekt-Explorer mit der rechten Maustaste an und wählen Sie Umbenennen aus dem Kontextmenü. ändern Sie den Namen in DotNetTestClass.vb. Korrespondierend können Sie den Klassennamen im Quelltext ebenfalls anpassen. Fügen Sie außerdem den folgenden Programmcode ein:<\/p>\n Damit verfügen Sie über eine Funktion namens EineZeichenkette(), die eine Zeichenkette als Parameter zurückgibt. Mit der F8-Taste können Sie das Combine erstellen und erhalten im Verzeichnis C:\\Daten\\DotNetServerApp\\DotNetServerApp\\bin\\Debug die Datei DotNetServerApp.dll. Diese Datei gilt es nun für eine Access-Anwendung verfügbar zu machen.<\/p>\n Nun könnte man auf die Idee kommen, die DLL über den Befehl Extras\/Verweise und Durchsuchen in Access hinzuzufügen. Dies führt jedoch leider zu der Fehlermeldung, dass ein Verweis auf die angegebene Datei nicht hinzugefügt werden kann (siehe Bild 2). Die nächsten Abschnitte dieses Beitrags beschreiben die Schritte, mit denen Sie aus der DLL-Datei einen COM-Server machen.<\/p>\n Eine wichtige Voraussetzung für einen COM-Server ist das Vorhandensein eines Konstruktors, der ohne Argumente auskommt. Durch die Eingabe der New()-Prozedur ist diese Voraussetzung bereits erfüllt. Die Angabe von MyBase.New() ruft den Konstruktor der Basisklasse auf, was für unser Beispiel völlig ausreichend ist.<\/p>\n Quellcode 1<\/b><\/p>\n Quellcode 2<\/b><\/p>\n Quellcode 3<\/b><\/p>\n <\/b><\/p>\n Bild 2: Diese Fehlermeldung erhalten Sie beim Versuch, die DLL als Com-Server einzubinden.<\/span><\/b><\/p>\n Mit dem ComClass-Attribut kennzeichnen Sie die neue Klasse als COM-Server. Dies veranlasst den Compiler zu verschiedenen Aktionen, die für die Verwendung eines .NET-Programms als COM-Server erforderlich sind. Sie müssen das Attribut in spitzen Klammern vor Public Class DotNetTestClass setzen.<\/p>\n Alternativ können Sie es auch eine Zeile darüber positionieren und die beiden Zeilen mit dem Unterstrich verbinden (s. Quellcode 1).<\/p>\n Wenn Sie das Combine nun mit F8 erstellen, dann meldet .NET den Fehler, dass ComClass unbekannt sei. Der Grund hierfür besteht darin, dass ComClass im Namespace Microsoft.VisualBasic definiert ist. Aus diesem Grund müssen Sie den Namespace entweder importieren oder vor ComClass mit angeben (s. Quellcode 2).<\/p>\n Jede unter Windows registrierte COM-Komponente muss eindeutig über eine Guid identifizierbar sein. Aus diesem Grund müssen Sie mindestens die Guid für die ClassId im Quellcode angeben. Falls Ihr COM-Server Interfaces und Ereignisse verwendet, müssen Sie auch diese Guids angeben. Die Definition der Guids geschieht durch die Programmzeilen aus Quellcode 3.<\/p>\n Es stellt sich natürlich die Frage, woher Sie gültige Guids bekommen können. Eine einfache Möglichkeit besteht darin, dass Sie mit SharpDevelop ein kleines Tool für diesen Zweck programmieren. Legen Sie dazu eine neue Combine mit dem Namen CreateGuid an. Wählen Sie VBNET als Kategorie und verwenden Sie die Schablone Windows-Anwendung.<\/p>\n SharpDevelop fügt Ihrer Combine automatisch das Formular MainForm.vb hinzu. Klicken Sie auf das Register Design, damit SharpDevelop die Entwurfsansicht des Formulars anzeigt(siehe Bild 3). Gehen Sie dann wie folgt vor:<\/p>\n <\/b><\/p>\n Bild 3: In der Entwurfsansicht des Formulars können Sie Steuerelemente hinzufügen und deren Eigenschaften bearbeiten.<\/span><\/b><\/p>\n Mit einem Doppelklick auf den Button veranlassen Sie SharpDevelop, eine Ereignisprozedur für das Click-Ereignis des Buttons anzulegen und diese über AddHandler mit dem Click-Ereignis des Buttons zu verknüpfen. Falls Sie sich den vom Formulardesigner generierten Programmcode ansehen wollen, dann brauchen Sie nur einen Doppelklick auf die Region Windows Forms Designer generated code auszuführen.<\/p>\n Die Ereignisprozedur BtnCreateGuidClick ist ein echter Einzeiler. Mit der folgenden Anweisung veranlassen Sie .NET zur Anlage einer Guid. Diese Guid wird dem Steuerelement als Text zugewiesen:<\/p>\n <\/p>\n Durch das Betätigen der F5-Taste veranlassen Sie das Kompilieren und den Start des Programms. .Net zeigt ein Formular mit einer Schaltfläche an. Bei jedem Klick auf die Schaltfläche wird eine neue Guid generiert (siehe Bild 4).<\/p>\n Falls Sie das Programm häufiger benötigen, brauchen Sie jeweils nur die Datei CreateGuid.exe per Doppelklick zu starten. Bei Bedarf können Sie auch eine Verknüpfung zu dieser EXE-Datei auf dem Desktop ablegen.<\/p>\n <\/b><\/p>\n Bild 4: Mit diesem Formular erhalten Sie neue Guids.<\/span><\/b><\/p>\n Das Programm ist nun so vollständig, dass Sie es mit F8 kompilieren können. Falls beim Kompilieren Fehler auftreten, zeigt SharpDevelop die Anzahl der Fehler an. Im unteren Teil des Fensters können Sie auf das Register Aufgaben klicken, um eine Liste der Fehler zu erhalten. Ein Doppelklick auf einen dieser Fehler markiert die entsprechende Stelle im Quellcode.<\/p>\n Wenn das Kompilieren fehlerfrei funktioniert, erhalten Sie erwartungsgemäß die Datei DotNetServerApp.dll. Leider lässt sich auch diese Datei mit Access nicht als Verweis hinzufügen. Bevor Sie den COM-Server wirklich benutzen können, müssen Sie ihn zuerst noch in Windows registrieren.<\/p>\n Eine DLL ist nur dann als COM-Server zu gebrauchen, wenn die Assembly einen starken Namen hat. In .NET ist eine Assembly eine abstrakte Zusammenfassung von Klassen und Projekten zu einer Einheit.<\/p>\n Es handelt sich dabei um die kleinste als eigenständiges Programm ausführbare Einheit. Ein einfaches Beispiel für eine minimale Assembly ist das weiter oben beschriebene Programm CreateGuid.exe.<\/p>\n Eine besondere Stärke von .NET ist das so genannte XCopy-Deployment. Das bedeutet sinngemäß, dass Sie, um sie von dort aus zu starten, die Bestandteile einer Anwendung (DLL-, EXE- und Ressourcen-Dateien) einfach nur in ein Verzeichnis zu kopieren brauchen. Wenn Sie das Programm CreateGuid.exe in ein anderes Verzeichnis kopieren, dann können Sie es von dort aus starten. Ein zusätzliches Installationsprogramm ist nicht erforderlich.<\/p>\n Dieses Verfahren ist in den meisten Fällen einfach zu handhaben und sinnvoll. Nicht geeignet ist das Verfahren für Programmbestandteile, die von vielen Anwendungen gleichzeitig benutzt werden sollen. Diese verwaltet .NET im so genannten Global Assembly Cache (kurz: GAC). Ein .NET-Programm, das als COM-Server fungieren soll, muss ebenfalls im GAC registriert werden. Dies ist nun aber leider nur mit solchen Programmen möglich, die über einen starken Namen (englisch: strong name) verfügen. Es gibt mehrere Verfahren zur Vergabe starker Namen. Das Beispiel verwendet das AssemblyKeyFile-Attribut. Mit ihm können Sie den Namen einer Datei angeben, die ein Schlüsselpaar für die Registrierung der Assembly im GAC enthält.<\/p>\n Die Anlage dieser Datei erfolgt mit dem Programm SN.EXE, das sowohl im Lieferumfang von Microsoft Visual Studio .NET als auch im Lieferumfang des Microsoft .NET Framework SDK enthalten ist. Wenn Sie nicht wissen, an welcher Stelle Sie das Programm finden können, sollten Sie einfach mit dem Windows-Explorer im Unterverzeichnis Programme danach suchen. Auf einem PC mit installiertem Visual Studio.NET lautet der Aufruf zur Anlage des Schlüsselpaares wie folgt:<\/p>\n Sie finden die Batchdatei unter dem Namen SN.BAT in den Beispieldateien zu diesem Beitrag. Wenn Sie die Befehle direkt eingeben wollen, dann wählen Sie den Befehl Ausführen aus dem Start-Menü von Windows und geben Sie Command als Befehl ein.<\/p>\n Ja richtig, im Zeitalter von WLans und objektorientierter Programmierung geht“s wieder zurück zu den Wurzeln, also zum DOS-Prompt – Verzeihung: zum Windows-Befehlszeileninterpreter. Der beschriebene Aufruf von SN.EXE generiert die Datei DotNetServerApp.snk, die Sie als Schlüsseldatei in Ihre Combine einfügen sollten (siehe Bild 5). Es bietet sich an, die Datei in das gleiche Verzeichnis zu kopieren, in dem sich der Quellcode der Anwendung befindet.<\/p>\n Im Beispiel ist dies der folgende Ordner:<\/p>\n <\/b><\/p>\n Bild 5: Der Aufruf des .NET Framework Strong Name Utilities erfolgt über den Windows-Befehlszeileninterpreter.<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 6: Mit diesen Schritten erzeugen Sie eine Typenbibliothek sowie installieren und registrieren die Assembly.<\/span><\/b><\/p>\n C:\\Daten\\DotNetServerApp\\DotNetServerApp<\/p>\n Anschließend sollten Sie im Projekt-Explorer von SharpDevelop das Projekt DotNetServerApp mit der rechten Maustaste anklicken und den Befehl Hinzufügen\/Dateien hinzufügen aus dem Kontextmenü auswählen. Fügen Sie die Datei DotNetServerApp.snk Ihrem Projekt hinzu. Damit die Datei auch verwendet wird, müssen Sie im Projekt-Explorer doppelt auf AssemblyInfo.vb klicken.<\/p>\n ändern Sie die standardmäßig eingefügte Zeile für das AssemblyKeyFile-Attribut wie folgt:<\/p>\n Abschließend sollten Sie die Combine durch Betätigen der F8-Taste neu erstellen lassen.<\/p>\n <\/b><\/p>\n Bild 7: Der Inhalt des Global Assembly Cache mit mehreren Versionen von DotNetServerApp<\/span><\/b><\/p>\n Die nächsten drei Schritte erfolgen komplett außerhalb des Editors. Sie müssen eine Typenbibliothek anlegen, die Assembly im GAC installieren und sie unter Windows registrieren. Das Erzeugen der Typenbibliothek erfolgt mit dem Tool tlbexp, das Installieren der Assembly im GAC erfolgt mit gacutil und die Anmeldung unter Windows übernimmt regasm (siehe Bild 6). Die Beispieldateien zu diesem Beitrag enthalten die Batchdatei libgen.bat, die diese Aufgaben für Sie durchführt. Falls bei der Ausführung der Batchdatei ein Fehler auftritt, sollten Sie die Pfade den Gegebenheiten Ihres PCs anpassen.<\/p>\n Das Tool gacutil registriert die DLL bei jedem Aufruf mit einer neuen Versionsnummer im globalen Assemblycache. Das bedeutet, wenn Sie das Programm ändern und gacutil neu starten, haben Sie anschließend zwei Programmversionen im globalen Assemblycache. Einen überblick über alle Programmversionen erhalten Sie mit dem Windows Explorer. öffnen Sie einfach den Ordner C:\\WINDOWS\\assembly. Windows zeigt den Inhalt dieses Ordners wie in Bild 7 an.<\/p>\n Bei Bedarf können Sie alte Programmversionen einfach mit der Entf-Taste löschen. Aber Vorsicht: Sie sollten sich vorerst auf die verschiedenen Versionen von DotNetServerApp beschränken. Wenn Sie andere Assemblies löschen, kann Ihr PC stark durcheinander geraten.<\/p>\n So, das war“s. Der Com-Server ist fertig programmiert, registriert und Sie können ihn verwenden. Gehen Sie dazu wie folgt vor:<\/p>\n Quellcode 4<\/b><\/p>\n <\/b><\/p>\n Bild 8: Mit diesem Dialog fügen Sie einen Verweis auf den COM-Server hinzu.<\/span><\/b><\/p>\n Wenn alles geklappt hat, dann können Sie die Datei ohne weitere Fehlermeldung öffnen und den Verweisen hinzufügen. Im Verweis-Fenster sehen Sie anschließend die Datei DotNetServerApp. Um den COM-Server zu testen, können Sie in das Modulfenster VBA-Code aus Quellcode 4 eingeben.<\/p>\n öffnen Sie mit Strg + G das Direktfenster und geben Sie die Anweisung MeinTest ein. Unmittelbar nach dem Betätigen der Eingabetaste übergibt Access den Aufruf an den frisch gebackenen COM-Server und dieser liefert den Text www.trinidat.de zurück. Das Ergebnis sollte sofort im Direktfenster angezeigt werden.<\/p>\n War das nicht auf den ersten Blick ziemlich viel Aufwand für eine einfache Print-Anweisung Bei der Beurteilung des Aufwands sollten Sie berücksichtigen, dass Sie mit dem beschriebenen Verfahren alle Objektklassen von .NET benutzen können. Wie einfach das ist, zeigt ein zweites Beispiel. Keine Angst, diesmal können Sie die bestehenden Batch-Dateien wieder verwenden und der Aufwand ist viel geringer. Gehen Sie wie folgt vor:<\/p>\n SharpDevelop zeigt den standardmäßig generierten Rumpf der neuen Klasse an. Um diese Klasse innerhalb eines Com-Servers zu verwenden, müssen Sie das ComClass-Attribut mit drei neuen Guids hinzufügen. Die Guids können Sie mit dem selbst programmierten Tool CreateGuid generieren. Um den nachfolgend aufgeführten Programmcode verwenden zu können, müssen Sie zusätzlich zu dem Namespace System die Namespaces System.Security.Cryptography und System.Text importieren. In Quellcode 5 finden Sie das vollständige Listing der gesamten Klasse.<\/p>\n Die DotNetCryptoClass-Klasse verwendet verschiedene in .NET integrierte Klassen zum ver- und entschlüsseln von Zeichenketten. Die verwendeten Klassen sind im Namespace mit der Bezeichnung System.Security.Cryptography enthalten.<\/p>\n Beim Ver- und Entschlüsseln einer Zeichenkette müssen Sie jeweils den gleichen Key angeben. Den Key können Sie vom COM-Client über die Eigenschaft CryptKey definieren lassen.<\/p>\n Quellcode 5 (Start)<\/b><\/p>\n Um die DotNetCryptoClass-Klasse zu testen, müssen Sie die Combine neu erstellen lassen. Betätigen Sie dazu die F8-Taste. Falls Kompilierfehler auftreten, sollten Sie zuerst die erforderlichen änderungen durchführen. Als Ergebnis erhalten Sie wie bisher eine einzelne Datei namens DotNetServerApp.dll in folgendem Verzeichnis:<\/p>\n Quellcode 5 (Fortsetzung)<\/b><\/p>\n Quellcode 6<\/b><\/p>\n C:\\Daten\\DotNetServerApp\\DotNetServerApp\\bin\\Debug<\/p>\n Bevor Sie die Datei registrieren und installieren können, müssen Sie zuerst eine eventuell gestartete Instanz von Microsoft Access beenden. Anderenfalls kann es vorkommen, dass der COM-Server gesperrt ist und nicht neu hinzugefügt werden kann.<\/p>\n Starten Sie danach die Batchdatei libgen.bat.<\/p>\n Nach einem erneuten Start von Microsoft Access sollten Sie ins Modulfenster wechseln und den Menübefehl Extras\/Verweise auswählen. Leeren Sie das Ankreuzkästchen des Verweises DotNetServerApp und klicken Sie auf die Schaltfläche Durchsuchen. <\/p>\n Fügen Sie die Datei DotNetServerApp.tlb neu hinzu. Stellen Sie durch den Vergleich von Dateidatum und -uhrzeit sicher, dass Sie die neueste Version der Datei hinzufügen. Den eigentlichen Test des erweiterten COM-Servers können Sie mit dem VBA-Code aus Quellcode 6 durchführen.<\/p>\n Wenn Sie das Programm durch die Eingabe von ComTest in den Direktbereich starten, erhalten Sie folgende Ausgabe:<\/p>\n Es ist wichtig, dass Sie beim Ver- und Entschlüsseln den gleichen Key verwenden. Andernfalls erhalten Sie eine Fehlermeldung.<\/p>\n Durch den Einsatz von .NET als COM-Server erhalten Sie Zugriff auf mehr als 4.000 im .NET-Framework enthaltene Klassen.<\/p>\n Selbst wenn Sie berücksichtigen, dass ein paar dieser Klassen in diesem Beitrag bereits vorgestellt wurden und weitere Klassen in gleicher oder ähnlicher Form auch in VBA enthalten sind, bleibt immer noch ein reicher Fundus für die unterschiedlichsten Aufgaben.<\/p>\n Es ist also nahe liegend, sich eine Klasse nach der anderen im Hinblick auf die Eignung für Microsoft Access anzusehen. Viele Klassen sind nämlich hervorragend dazu geeignet, die Schwachstellen von Access auszugleichen.<\/p>\n .NET verfügt über betriebssystemnahe Klassen wie FileSystemWatcher. Sie kann ein Programm über änderungen an Dateien unterrichten. Eine völlig neue Denkweise für Access-Programmierer ist die Programmierung von Threads, die als solche innerhalb des Multithreading von Windows ablaufen. Ein Thread kann beispielsweise zu jeder vollständigen Stunde den Lagerbestand berechnen und Bestellungen per E-Mail versenden – eine Aufgabe, die mit Access nur auf Umwegen zu bewältigen ist.<\/p>\n Ein kleines Manko besteht vielleicht darin, dass COM-Server keine visuelle Darstellung bieten. Hierfür benötigen Sie ActiveX-Steuerelemente. Tatsächlich gibt es sogar einen Trick, mit dem sich in .NET programmierte Klassen als ActiveX-Steuerelement in Access einbetten lassen. Aber das ist das Thema eines anderen Beitrags.<\/p>\n Wenn Sie die in diesem Beitrag beschriebenen Themen vertiefen wollen, dann sollten Sie sich folgende Internetseiten ansehen:<\/p>\n http:\/\/msdn.microsoft.com\/library\/default.aspurl=\/library\/en-us\/vbcn7\/html\/vawlkWalkthroughCreatingCOMObjectsWithVisualBasicNET.asp<\/p>\n http:\/\/samples.gotdotnet.com\/quickstart\/howto\/doc\/Interop\/Building_Samples_COM2NET.aspx<\/p>\n http:\/\/msdn.microsoft.com\/library\/en-us\/dndotnet\/html\/interopdotnet.aspframe=true<\/p>\n http:\/\/msdn.microsoft.com\/library\/default.aspurl=\/library\/en-us\/cpguide\/html\/cpconexposingnetframeworkcomponentstocom.asp<\/p>\n","protected":false},"excerpt":{"rendered":" Das Microsoft.NET Framework hält mit über 4.000 wesentlich mehr Klassen bereit als Microsoft Access. Darunter befinden sich auch zahlreiche Klassen, bei denen dem Access-Entwickler das Wasser im Munde zusammenläuft. Der folgende Beitrag beschreibt ein paar Tricks, mit denen Sie eine .NET-Klasse als COM-Komponente kompilieren und mit Access benutzen können.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[44000017,662004,66042004],"tags":[],"class_list":["post-55000225","post","type-post","status-publish","format-standard","hentry","category-NET","category-662004","category-66042004"],"yoast_head":"\nProgramm eingeben<\/h2>\n
Public Class DotNetTestClass\r\n Public Sub New()\r\n MyBase.New()\r\n End Sub\r\n Public Function EineZeichenkette() _ As String\r\n EineZeichenkette = _ \"http:\/\/www.trinidat.de\"\r\n End Function\r\nEnd Class<\/pre>\n
Von der DLL zum COM-Server<\/h2>\n
<Comclass(VonDotNet.ClassId, VonDotNet.InterfaceId, VonDotNet.EventsId)> _\r\nPublic Class DotNetTestClass<\/pre>\n
<Microsoft.Visualbasic.Comclass(DotNetTestClass.ClassId, DotNetTestClass.InterfaceId, DotNetTestClass.EventsId)> _\r\nPublic Class DotNetTestClass<\/pre>\n
#Region \"COM GUIDs\"\r\n Public Const ClassId As String = \"ce8c8909-1126-4694-bfdd-602528cae505\"\r\n Public Const InterfaceId As String = \"b937860c-6670-4f1e-8028-31e5adacb18d\"\r\n Public Const EventsId As String = \"ccd5da17-c538-4903-913e-3b7bcf6f7f71\"\r\n#End Region<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{C5818781-172B-472A-864C-C965CB39CB4C}\/pic002.png\")
<\/p>\nWoher kommen die Guids<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{C5818781-172B-472A-864C-C965CB39CB4C}\/pic003.png\")
<\/p>\nme.txtGuid.text = \r\n System.Guid.NewGuid.ToString<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{C5818781-172B-472A-864C-C965CB39CB4C}\/pic004.png\")
<\/p>\nEinen starken Namen zuweisen<\/h2>\n
\"C:\\Programme\\Microsoft Visual Studio .NET 2003\\SDK\\v1.1\\Bin\\sn.exe\" -k DotNetServerApp.snk\r\nPause<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{C5818781-172B-472A-864C-C965CB39CB4C}\/pic005.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{C5818781-172B-472A-864C-C965CB39CB4C}\/pic006.png\")
<\/p>\n<assembly: \r\nAssemblyKeyFile(\"DotNetServerApp.snk\")><\/pre>\n
![](\"..\/fileadmin\/_temp_\/{C5818781-172B-472A-864C-C965CB39CB4C}\/pic007.png\")
<\/p>\nCOM-Server im Global Assembly Cache registrieren<\/h2>\n
Option Compare Database\r\nOption Explicit\r\nPublic Sub MeinTest()\r\n Dim x As New DotNetServerApp.DotNetTestClass\r\n Debug.Print x.EineZeichenkette\r\nEnd Sub<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{C5818781-172B-472A-864C-C965CB39CB4C}\/pic008.png\")
<\/p>\nZeichenketten verschlüsseln<\/h2>\n
Imports System\r\nImports System.Security.Cryptography\r\nImports System.Text\r\nNamespace DotNetServerApp\r\n<Microsoft.VisualBasic.ComClass(DotNetCryptoClass.ClassId, DotNetCryptoClass.InterfaceId, DotNetCryptoClass.EventsId)> _\r\nPublic Class DotNetCryptoClass\r\n#Region \"COM GUIDs\"\r\n '' These GUIDs provide the COM identity for this class \r\n '' and its COM interfaces. If you change them, existing \r\n '' clients will no longer be able to access the class.\r\n Public Const ClassId As String = \"fb0b3833-2e08-4e33-b3b3-706520acb848\"\r\n Public Const InterfaceId As String = \"7dd9a403-710a-4d50-a58b-bcc12ae2608b\"\r\n Public Const EventsId As String = \"cd5e09d8-e7e5-4c27-8e4e-cda949bc6e5a\"\r\n#End Region\r\n Private m_Key As String = \"\"\r\n Private Des As New TripleDESCryptoServiceProvider\r\n Private HashMD5 As New MD5CryptoServiceProvider\r\n Public Sub New()\r\n MyBase.new()\r\n End Sub\r\n Public Property CryptKey() As String\r\n Get\r\n Return m_Key\r\n End Get\r\n Set(ByVal Value As String)\r\n m_Key = Value\r\n End Set\r\n End Property\r\n Public Function DeCrypt(ByVal SourceText As String) As String\r\n Des.Key = HashMD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(m_Key))\r\n Des.Mode = CipherMode.ECB\r\n Dim desdencrypt As ICryptoTransform = Des.CreateDecryptor()\r\n Dim buff() As Byte = Convert.FromBase64String(SourceText)\r\n Return ASCIIEncoding.ASCII.GetString _\r\n (desdencrypt.TransformFinalBlock(buff, 0, buff.Length))\r\n End Function\r\n Public Function Crypt(ByVal SourceText As String) As String\r\n Des.Key = HashMD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(m_Key))\r\n Des.Mode = CipherMode.ECB\r\n Dim desdencrypt As ICryptoTransform = Des.CreateEncryptor()\r\n Dim MyASCIIEncoding As New ASCIIEncoding\r\n Dim buff() As Byte = ASCIIEncoding.ASCII.GetBytes(SourceText)\r\n Return Convert.ToBase64String _\r\n (desdencrypt.TransformFinalBlock(buff, 0, buff.Length))\r\n End Function<\/pre>\n
Testen der DotNetCryptoClass-Klasse<\/h2>\n
Public Shared Function GenerateHash(ByVal SourceText As String) As String\r\n Dim Ue As New UnicodeEncoding\r\n Dim ByteSourceText() As Byte = Ue.GetBytes(SourceText)\r\n Dim Md5 As New MD5CryptoServiceProvider\r\n Dim ByteHash() As Byte = Md5.ComputeHash(ByteSourceText)\r\n Return Convert.ToBase64String(ByteHash)\r\n End Function\r\nEnd Class\r\nEnd Namespace<\/pre>\n
Option Compare Database\r\nOption Explicit\r\nPublic Sub ComTest()\r\n Dim x As New DotNetServerApp.DotNetTestClass\r\n Debug.Print x.EineZeichenkette\r\n Dim y As New DotNetServerApp.DotNetCryptoClass\r\n y.CryptKey = \"www.trinidat.de\"\r\n Dim strCrypt, strStart As String\r\n strStart = \"DotNet als COM-Server.\"\r\n strCrypt = y.Crypt(strStart)\r\n Debug.Print \"1.) Durchlauf mit gleichen Key\"\r\n Debug.Print \"Verwendeter Key:\", y.CryptKey\r\n Debug.Print \"Ursprüngliche Zeichenkette:\", strStart\r\n Debug.Print \"Verschlüsselte Zeichenkette:\", strCrypt\r\n Debug.Print \"Entschlüsselte Zeichenkette:\", y.DeCrypt(strCrypt)\r\n Debug.Print \"2.) Entschlüsseln mit anderem Key\"\r\n y.CryptKey = \"www.trinidat.de\"\r\n Debug.Print \"änderung Key auf:\", y.CryptKey\r\n Debug.Print \"Entschlüsselte Zeichenkette:\", y.DeCrypt(strCrypt)\r\nEnd Sub<\/pre>\n
http:\/\/www.trinidat.de\r\nVerwendeter Key: www.trinidat.de\r\nUrsprüngliche Zeichenkette: DotNet als COM-Server.\r\nVerschlüsselte Zeichenkette: \/Kgtv0\/ebWjxZyhEkyLbB1OVMzNho7kl\r\nEntschlüsselte Zeichenkette: DotNet als COM-Server.<\/pre>\n
Walkthrough: Creating COM Objects with Visual Basic .NET<\/h3>\n
How Do I…Build a .NET Server Callable from COM clients<\/h3>\n
Handling Language Interoperability with the Microsoft .NET Framework<\/h3>\n
Packaging an Assembly for COM<\/h3>\n