{"id":55000582,"date":"2008-04-01T00:00:00","date_gmt":"2020-12-03T16:40:13","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=582"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"NETKlassen_und_Formulare_in_Access_nutzen","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/NETKlassen_und_Formulare_in_Access_nutzen\/","title":{"rendered":".NET-Klassen und Formulare in Access nutzen"},"content":{"rendered":"

\"\"<\/p>\n

Das .NET-Framework liefert eine Menge interessanter Klassen, die Sie unter Access gut gebrauchen können. Doch nicht nur das: In Form einer COM-DLL können Sie nicht nur Visual Basic 2008-Klassen, sondern auch damit erstellte Elemente der Benutzeroberfläche in Access-Anwendungen integrieren. Und das Beste ist: Das funktioniert auch mit der kostenlosen Express Edition von Visual Basic 2008.<\/b><\/p>\n

Wenn Sie unter VBA schon einmal einen Verweis auf eine externe Bibliothek gesetzt und deren Methoden und Eigenschaften genutzt haben, kennen Sie zumindest schon einmal die andere Seite von dem, was Sie in den folgenden Abschnitten lernen. Dort erstellen Sie nämlich genau eine solche Bibliothek, die Sie von Access aus referenzieren und deren Funktionen Sie dort unter VBA nutzen können. Ãœblicherweise dürften Sie bisher – wenn überhaupt – auf die Klassenbibliotheken von Anwendungen wie Word, Excel oder Outlook zugegriffen haben, um diese Anwendungen zu automatisieren; vielleicht haben Sie auch schon mal eine Klasse eines Drittanbieters benutzt, um den Funktionsumfang einer Ihrer Datenbanken zu erweitern. Ein gutes Beispiel ist etwa eine Komponente, die eine Anwendung um Funktionen zum Versenden von E-Mails erweitert.<\/p>\n

Warum nun sollten Sie selbst solche Klassen herstellen und von Access aus einsetzen Nun: Das .NET Framework 3.5 liefert eine unüberschaubare Menge an Klassen, die Sie auf diese Weise in Ihre Access-Anwendungen integrieren können.<\/p>\n

Projekt erstellen<\/b><\/p>\n

Der erste Schritt beim Bau einer DLL, die in Access als Verweis eingebunden werden kann, ist das Anlegen eines passenden Visual Basic-Projekts. Dies erledigen Sie in Visual Studio über den Menüeintrag Datei|Neues Projekt<\/b>. Im folgenden Dialog namens Neues Projekt <\/b>wählen Sie den Eintrag Klassenbibliothek aus und geben den Namen Ihrer Wahl an – beispielsweise AccessDLL<\/b>. Um den Speicherpfad brauchen Sie sich noch nicht zu kümmern, den legen Sie später fest, wenn Sie sich entschlossen haben, dass dieses Projekt auch speichernswert ist.<\/p>\n

Visual Studio empfängt Sie im Anschluss mit der leeren Klasse Class1<\/b>, die es nun zu füllen gilt (siehe Bild 1). Zunächst aber geben Sie der Klasse einen sinnvolleren Namen wie etwa Beispielklasse<\/b>. Dies erledigen Sie wahlweise im Projektmappen-Explorer oder im Eigenschaftsfenster – der Name im Codefenster ändert sich automatisch.<\/p>\n

\"missing<\/p>\n

Bild 1: Visual Studio mit einer leeren VB-Klasse<\/span><\/b><\/p>\n

Für einen ersten Funktionstest fügen Sie der Klasse einfach eine kleine Funktion hinzu, die nichts anderes erledigt, als beim Aufruf eine Zeichenkette zurückzuliefern. Die komplette Klasse sieht dann so aus:<\/p>\n

Public Class Beispielklasse\r\nPublic Function Beispielfunktion() As String\r\n    Beispielfunktion = "Funktioniert!"\r\nEnd Function\r\nEnd Class<\/pre>\n
Sie könnten die DLL nun durch den Menüeintrag Erstellen|AccessDLL <\/b>erstellen erzeugen, aber das würde nichts nUtzen: Sie liefert keinerlei Informationen nach außen, die auf die enthaltenen Elemente – hier die Funktion Testfunktion <\/b>– hinweisen. Dazu brauchte man eine .tlb<\/b>-Datei, die sogenannte Type Library, die alle in der DLL enthaltenen Klassen und ihre Elemente auflistet und für das VBA-Projekt, in das sie eingebunden werden soll, bereitstellt. Bevor Sie dies erledigen, speichern Sie das Projekt mit Datei|Projekt schließen <\/b>(siehe Bild 2).<\/p>\n
\"missing<\/p>\n
Bild 2: Speichern des Projekts unter dem gewünschten Projektnamen<\/span><\/b><\/p>\n
Anschließend sind drei zusätzliche Handgriffe nötig, von denen Sie zwei in der Entwicklungsumgebung und einen manuell durchführen müssen: Zunächst müssen Sie erreichen, dass Visual Studio neben den drei Dateien AccessDLL.dll<\/b>, AccessDLL.pdb <\/b>und AccessDLL.xml<\/b>, die Sie nach dem Erstellen mit Erstellen|AccessDLL erstellen <\/b>im Verzeichnis AccessDLL\\bin\\Release <\/b>finden, noch eine zusätzliche Datei namens AccessDLL.tlb <\/b>hinzufügt. Dabei hilft das Tool regasm.exe<\/b>, das auch beim Registrieren der DLL auf anderen Rechnern nützliche Dienste leistet. Rufen Sie es auf, indem Sie folgende Anweisung beispielsweise im Ausführen…<\/b>-Dialog oder in der Eingabeaufforderung von Windows eingeben:<\/p>\n
<Pfad>\\regasm.exe <Pfad>\\<DLLName>.dll\r\n\/tlb<\/pre>\n
<\/p>\n
Die Datei regasm.exe <\/b>finden Sie im jeweiligen Framework-Verzeichnis, das sich in der Regel unter c:\\Windows\\Microsoft.NET\\Framework\\vx.x <\/b>befindet. Ã-ffnen Sie dann das Projekt wieder und klicken Sie im Projektmappen-Explorer auf den Eintrag Beispielklasse.vb<\/b>. Stellen Sie in den Eigenschaften des Projekts den Eintrag COM-sichtbar <\/b>auf True <\/b>ein; dies macht sich im Code der Klasse durch das automatische Voranstellen von <Microsoft.VisualBasic.ComClass()> <\/b>bemerkbar.<\/p>\n
Schließlich müssen Sie noch eine weitere Eigenschaft einstellen – und zwar in den Projekteigenschaften. Diese öffnen Sie über den Menüeintrag Projekt|AccessDLL-Eigenschaften… <\/b>Wechseln Sie dort auf die Registerseite Anwendung<\/b> und klicken Sie auf die Schaltfläche Assemblyinformationen… <\/b>(siehe Bild 3). Im nun erscheinenden Fenster aktivieren Sie die Option Assembly COM-sichtbar machen <\/b>(siehe Bild 4).<\/p>\n
\"missing<\/p>\n
Bild 3: Mit einem Klick auf die Schaltfläche Assemblyinformationen …<\/span><\/b><\/p>\n
\"missing<\/p>\n
Bild 4: … öffnen Sie diesen Dialog und aktivieren die Option Assembly COM-sichtbar machen.<\/span><\/b><\/p>\n
Nun können Sie das Projekt kompilieren und testen. Dazu öffnen Sie den VBA-Editor einer Access-Datenbank und legen im Verweise<\/b>-Dialog einen Verweis auf die nun dort erscheinende Bibliothek AccessDLL <\/b>an (siehe Bild 5). Es fehlt nun nur noch der Zugriff auf die neu erstellte DLL. Dieser erfolgt auf herkömmliche Weise – nach dem Deklarieren und Instanzieren der Klasse können Sie seine einzige Funktion ganz einfach aufrufen.<\/p>\n
\"missing<\/p>\n
Bild 5: Hinzufügen eines Verweises auf die neue Bibliothek<\/span><\/b><\/p>\n
Dim obj As AccessDLL.Beispielklasse\r\nSet obj = New AccessDLL.Beispielklasse\r\nWith obj\r\nDebug.Print .Beispielfunktion\r\nEnd With<\/pre>\n
WinForms in Access-Anwendungen<\/b><\/p>\n
Da liegt der Verdacht nahe, dass sich nicht nur die Klassen des .NET-Frameworks, sondern auch noch die passende Benutzeroberfläche von Access aus aufrufen lässt. Das wäre interessant – immerhin gibt es dort viele Steuerelemente, die Sie in Access vergeblich suchen werden. Probieren wir es aus! Dazu fügen Sie dem VB-Projekt zunächst ein neues Formular hinzu. Das geht am schnellsten über den Menüeintrag Projekt|Neues Element hinzufügen…<\/b> Das neue Formular benennen Sie zunächst von Form1 <\/b>in frmBeispiel <\/b>um. Zu Beispielzwecken wollen wir lediglich eine Schaltfläche auf dem Formular unterbringen, was Sie per Drag and Drop von der Liste der Steuerelemente (Toolbox) aus erledigen. Anschließend geben Sie auch der Schaltfläche einen neuen Namen, und zwar cmdOK<\/b> (siehe Bild 6).<\/p>\n
\"missing<\/p>\n
Bild 6: Das neue Formular mit Schaltfläche<\/span><\/b><\/p>\n
Der Klasse Beispielklasse.vb <\/b>fügen Sie nun noch eine Methode hinzu, die das Formular öffnet:<\/p>\n
Public Sub WinformOeffnen()\r\nDim objForm As frmBeispiel\r\nobjForm = New frmBeispiel\r\nWith objForm\r\n.ShowDialog()\r\nEnd With\r\nEnd Sub<\/pre>\n
Dies läuft ein wenig anders als unter Access: Ein Formular ist hier eine Klasse wie alle anderen und muss deklariert und instanziert werden, bevor man sie mit der ShowDialog<\/b>-Methode öffnet. ShowDialog <\/b>öffnet das Formular als modalen Dialog und entspricht somit DoCmd.OpenForm "Formularname", WindowMode:=acDialog<\/b>, die Alternative wäre die Show<\/b>-Methode.<\/p>\n
Damit Sie das Formular auch wieder schließen können, fügen Sie der Schaltfläche ebenfalls noch eine Zeile Code hinzu – dies geht am schnellsten, indem Sie einfach doppelt auf die Schaltfläche klicken. Die automatisch erstellte Ereignisprozedur ergänzen Sie wie folgt:<\/p>\n
Private Sub cmdOK_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles cmdOK.Click\r\nMe.Close()\r\nEnd Sub<\/pre>\n
Nun brauchen Sie nur noch die folgende Zeile zum Code der Beispieldatenbank hinzuzufügen und aufzurufen – schon erscheint das .NET-Formular in der Access-Anwendung:<\/p>\n
Dim obj As AccessDLL.Beispielklasse\r\nSet obj = New AccessDLL.Beispielklasse\r\nWith obj\r\n.WinformOeffnen\r\nEnd With<\/pre>\n
Weitergabe von COM-DLLs<\/b><\/p>\n
Für die Weitergabe gibt es zwei einfache Varianten:<\/p>\n