Zur Hauptseite ... Zum Onlinearchiv ... Zum Abonnement ... Zum Newsletter ... Zu den Tools ... Zum Impressum ... Zum Login ...

Achtung: Dies ist nicht der vollständige Artikel, sondern nur ein paar Seiten davon. Wenn Sie hier nicht erfahren, was Sie wissen möchten, finden Sie am Ende Informationen darüber, wie Sie den ganzen Artikel lesen können.

Kompletten Artikel lesen?

Einfach für den Newsletter anmelden, dann lesen Sie schon in einer Minute den kompletten Artikel und erhalten die Beispieldatenbanken.

E-Mail:

Gedrucktes Heft

Diesen Beitrag finden Sie in Ausgabe 4/2004.

Unser Angebot für Sie!

Lesen Sie diesen Beitrag und 500 andere sofort im Onlinearchiv, und erhalten Sie alle zwei Monate brandheißes Access-Know-how auf 72 gedruckten Seiten! Plus attraktive Präsente, zum Beispiel das bald erscheinende Buch 'Access 2010 - Das Grundlagenbuch für Entwickler'!

Diesen Beitrag twittern

.NET-Klassen in Access verwenden

Manfred Hoffbauer, Düsseldorf

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.

Was Sie benötigen

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.

Hinweis

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. (

Vom Quellcode zum COM-Server

Das Component Object Model ist als weitgehend standardisierte Beschreibung für die Kommunikation zwischen Anwendungen unter Windows recht weit verbreitet.

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.

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.

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.

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.

Abb. 1: Mit diesem Dialog legen Sie eine neue Klassenbibliothek an.

Programm eingeben

Zur Eingabe des ersten Testprogramms starten Sie den kostenlosen Programmeditor SharpDevelop. Gehen Sie dann wie folgt vor (s. Abb. 1):

  • Klicken Sie auf den Button Neues Combine.
  • Markieren Sie im Dialog Neues Projekt die Kategorie VBNET.
  • Markieren Sie die Schablone Klassenbibliothek.
  • Geben Sie DotNetServerApp als Namen ein.
  • Wählen Sie einen einprägsamen und kurzen Pfad wie zum Beispiel C:\Daten\DotNetServerApp für das Verzeichnis.
  • Klicken Sie auf die Erstellen. (
  • 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:

    Public Class DotNetTestClass

       Public Sub New()

            MyBase.New()

        End Sub

        Public Function EineZeichenkette() _
            As String

            EineZeichenkette = _
                "http://www.trinidat.de"

        End Function

    End Class

    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.

    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 (s. Abb. 2). Die nächsten Abschnitte dieses Beitrags beschreiben die Schritte, mit denen Sie aus der DLL-Datei einen COM-Server machen.

    Von der DLL zum COM-Server

    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.

    <Comclass(VonDotNet.ClassId, VonDotNet.InterfaceId, VonDotNet.EventsId)> _

    Public Class DotNetTestClass

    Quellcode 1

    <Microsoft.Visualbasic.Comclass(DotNetTestClass.ClassId, DotNetTestClass.InterfaceId, DotNetTestClass.EventsId)> _

    Public Class DotNetTestClass

    Quellcode 2

    #Region "COM GUIDs"

        Public Const ClassId As String =   "ce8c8909-1126-4694-bfdd-602528cae505"

        Public Const InterfaceId As String = "b937860c-6670-4f1e-8028-31e5adacb18d"

        Public Const EventsId As String = "ccd5da17-c538-4903-913e-3b7bcf6f7f71"

    #End Region

    Quellcode 3

    Abb. 2: Diese Fehlermeldung erhalten Sie beim Versuch, die DLL als Com-Server einzubinden.

    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.

    Alternativ können Sie es auch eine Zeile darüber positionieren und die beiden Zeilen mit dem Unterstrich verbinden (s. Quellcode 1).

    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).

    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.

    Woher kommen die Guids?

    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.

    SharpDevelop fügt Ihrer Combine automatisch das Formular MainForm.vb hinzu. Klicken Sie auf das Register Design, damit SharpDevelop die Entwurfsansicht des Formulars anzeigt
    (s. Abb. 3). Gehen Sie dann wie folgt vor:

  • Blenden Sie mit Ansicht/Tools die Toolbox ein.
  • Abb. 3: In der Entwurfsansicht des Formulars können Sie Steuerelemente hinzufügen und deren Eigenschaften bearbeiten.

  • Klicken Sie auf die Gruppe Windows Forms.
  • Ziehen Sie ein Textbox-Steuerelement und ein Button-Steuerelement in die Entwurfsansicht des Formulars.
  • Klicken Sie das Textbox-Steuerelement mit der rechten Maustaste an und wählen Sie Eigenschaften aus dem Kontextmenü.
  • Ändern Sie die Eigenschaft Name auf txtGuid.
  • Klicken Sie das Button-Steuerelement an.
  • Ändern Sie die Eigenschaft Name auf btnCreateGuid und die Eigenschaft Text auf &Create Guid. (
  • 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.

    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:

    me.txtGuid.text = 

        System.Guid.NewGuid.ToString

    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 (s. Abb. 4).

    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.

    Abb. 4: Mit diesem Formular erhalten Sie neue Guids.

    DLL als COM-Server kompilieren

    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.

    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.

    Einen starken Namen zuweisen

    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.

    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.

    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.

    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.

    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:

    "C:\Programme\Microsoft Visual Studio .NET 2003\SDK\v1.1\Bin\sn.exe" -k DotNetServerApp.snk

    Pause

    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.

    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 (s. Abb. 5). Es bietet sich an, die Datei in das gleiche Verzeichnis zu kopieren, in dem sich der Quellcode der Anwendung befindet.

    Im Beispiel ist dies der folgende Ordner:

    Abb. 5: Der Aufruf des .NET Framework Strong Name Utilities erfolgt über den Windows-Befehlszeileninterpreter.

    Abb. 6: Mit diesen Schritten erzeugen Sie eine Typenbibliothek sowie installieren und registrieren die Assembly.

    C:\Daten\DotNetServerApp\DotNetServerApp

    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.

    Ändern Sie die standardmäßig eingefügte Zeile für das AssemblyKeyFile-Attribut wie folgt:

    <assembly: 

    AssemblyKeyFile("DotNetServerApp.snk")>

    Abschließend sollten Sie die Combine durch Betätigen der F8-Taste neu erstellen lassen.

    Abb. 7: Der Inhalt des Global Assembly Cache mit mehreren Versionen von DotNetServerApp

    COM-Server im Global Assembly Cache registrieren

    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 (s. Abb. 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.

    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 Abb. 7 an.

    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.

    Den Com-Server verwenden

    So, das war’s. Der Com-Server ist fertig programmiert, registriert und Sie können ihn verwenden. Gehen Sie dazu wie folgt vor:

  • Starten Sie Microsoft Access mit einer leeren Datenbank.
  • Fügen Sie ein neues, leeres Modul hinzu.
  • Wählen Sie den Befehl Extras/Verweise.
  • Option Compare Database

    Option Explicit

    Public Sub MeinTest()

        Dim x As New DotNetServerApp.DotNetTestClass

        Debug.Print x.EineZeichenkette

    End Sub

    Quellcode 4

  • Klicken Sie auf die Schaltfläche Durchsuchen.
  • Fügen Sie den Verweis auf die Datei DotNetServerApp.tlb hinzu (s. Abb. 8). (
  • Abb. 8: Mit diesem Dialog fügen Sie einen Verweis auf den COM-Server hinzu.

    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.

    Ö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.

    Zeichenketten verschlüsseln

    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:

  • Klicken Sie in SharpDevelop das Projekt DotNetServerApp mit der rechten Maustaste an.
  • Wählen Sie Hinzufügen ( Neue Datei aus dem Kontextmenü.
  • Markieren Sie die Kategorie VB und die Schablone Klasse.
  • Geben Sie DotNetCryptoClass.vb als Dateinamen ein.
  • Klicken Sie auf Erstellen. (
  • 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.

    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.

    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.

    Imports System

    Imports System.Security.Cryptography

    Imports System.Text

    Namespace DotNetServerApp

    <Microsoft.VisualBasic.ComClass(DotNetCryptoClass.ClassId, DotNetCryptoClass.InterfaceId, DotNetCryptoClass.EventsId)> _

    Public Class DotNetCryptoClass

    #Region "COM GUIDs"

        ' These  GUIDs provide the COM identity for this class 

        ' and its COM interfaces. If you change them, existing 

        ' clients will no longer be able to access the class.

        Public Const ClassId As String = "fb0b3833-2e08-4e33-b3b3-706520acb848"

        Public Const InterfaceId As String = "7dd9a403-710a-4d50-a58b-bcc12ae2608b"

        Public Const EventsId As String = "cd5e09d8-e7e5-4c27-8e4e-cda949bc6e5a"

    #End Region

        Private m_Key As String = ""

        Private Des As New TripleDESCryptoServiceProvider

        Private HashMD5 As New MD5CryptoServiceProvider

        Public Sub New()

     MyBase.new()

        End Sub

        Public Property CryptKey() As String

            Get

                Return m_Key

            End Get

            Set(ByVal Value As String)

                m_Key = Value

            End Set

        End Property

        Public Function DeCrypt(ByVal SourceText As String) As String

            Des.Key = HashMD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(m_Key))

            Des.Mode = CipherMode.ECB

            Dim desdencrypt As ICryptoTransform = Des.CreateDecryptor()

            Dim buff() As Byte = Convert.FromBase64String(SourceText)

            Return ASCIIEncoding.ASCII.GetString _

            (desdencrypt.TransformFinalBlock(buff, 0, buff.Length))

        End Function

        Public Function Crypt(ByVal SourceText As String) As String

            Des.Key = HashMD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(m_Key))

            Des.Mode = CipherMode.ECB

            Dim desdencrypt As ICryptoTransform = Des.CreateEncryptor()

            Dim MyASCIIEncoding As New ASCIIEncoding

            Dim buff() As Byte = ASCIIEncoding.ASCII.GetBytes(SourceText)

            Return Convert.ToBase64String _

            (desdencrypt.TransformFinalBlock(buff, 0, buff.Length))

        End Function

    Quellcode 5 (Start)

    Testen der DotNetCryptoClass-Klasse

    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:

        Public Shared Function GenerateHash(ByVal SourceText As String) As String

            Dim Ue As New UnicodeEncoding

            Dim ByteSourceText() As Byte = Ue.GetBytes(SourceText)

            Dim Md5 As New MD5CryptoServiceProvider

            Dim ByteHash() As Byte = Md5.ComputeHash(ByteSourceText)

            Return Convert.ToBase64String(ByteHash)

        End Function

    End Class

    End Namespace

    Quellcode 5 (Fortsetzung)

    Option Compare Database

    Option Explicit

    Public Sub ComTest()

        Dim x As New DotNetServerApp.DotNetTestClass

        Debug.Print x.EineZeichenkette

        Dim y As New DotNetServerApp.DotNetCryptoClass

        y.CryptKey = "www.trinidat.de"

        Dim strCrypt, strStart As String

        strStart = "DotNet als COM-Server."

        strCrypt = y.Crypt(strStart)

        Debug.Print "1.) Durchlauf mit gleichen Key"

        Debug.Print "Verwendeter Key:", y.CryptKey

        Debug.Print "Ursprüngliche Zeichenkette:", strStart

        Debug.Print "Verschlüsselte Zeichenkette:", strCrypt

        Debug.Print "Entschlüsselte Zeichenkette:", y.DeCrypt(strCrypt)

        Debug.Print "2.) Entschlüsseln mit anderem Key"

        y.CryptKey = "www.trinidat.de"

        Debug.Print "Änderung Key auf:", y.CryptKey

        Debug.Print "Entschlüsselte Zeichenkette:", y.DeCrypt(strCrypt)

    End Sub

    Quellcode 6

    C:\Daten\DotNetServerApp\DotNetServerApp\bin\Debug

    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.

    Starten Sie danach die Batchdatei libgen.bat.

    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.

    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.

    Wenn Sie das Programm durch die Eingabe von ComTest in den Direktbereich starten, erhalten Sie folgende Ausgabe:

    http://www.trinidat.de

    Verwendeter Key:            www.trinidat.de

    Ursprüngliche Zeichenkette:              DotNet als COM-Server.

    Verschlüsselte Zeichenkette:              /Kgtv0/ebWjxZyhEkyLbB1OVMzNho7kl

    Entschlüsselte Zeichenkette:              DotNet als COM-Server.

    Es ist wichtig, dass Sie beim Ver- und Entschlüsseln den gleichen Key verwenden. Andernfalls erhalten Sie eine Fehlermeldung.

    Zusammenfassung und Ausblick

    Durch den Einsatz von .NET als COM-Server erhalten Sie Zugriff auf mehr als 4.000 im .NET-Framework enthaltene Klassen.

    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.

    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.

    .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.

    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.

    Literaturhinweise

    Wenn Sie die in diesem Beitrag beschriebenen Themen vertiefen wollen, dann sollten Sie sich folgende Internetseiten ansehen:

    Sie haben das Ende des frei verfügbaren Teils des Artikels erreicht. Lesen Sie weiter, um zu erfahren, wie Sie den vollständigen Artikel lesen und auf viele hundert weitere Artikel zugreifen können.

    Sind Sie Abonnent?Jetzt einloggen ...
     

    Kompletten Artikel lesen?

    Einfach für den Newsletter anmelden, dann lesen Sie schon in einer Minute den kompletten Artikel und erhalten die Beispieldatenbanken.

    E-Mail:

    Verwandte Beiträge:

    Visual Basic 2008 Express Edition

    Ereignisprozeduren implantieren

    .NET-Klassen und Formulare in Access nutzen

    © 2003-2015 André Minhorst Alle Rechte vorbehalten.