Schließlich benötigen wir noch eine Datenbank, welche die damit zu erstellenden Bilddateien mit QR-Codes nutzt und in Rechnungsberichte einbettet, sodass diese vom Rechnungsempfänger per Smartphone-Kamera erfasst und für das schnelle Eintragen der Rechnungsdaten in das Überweisungsformular genutzt werden kann. Diese beschreiben wir in einem weiteren Beitrag namens Rechnungsbericht mit EPC-QR-Code <\/b>(www.access-im-unternehmen.de\/****<\/b>).<\/p>\nWie sieht der Inhalt des EPC-QR-Codes aus?<\/h2>\n
Als Erstes schauen wir uns an, welchen Aufbau der Text hat, der als Grundlage für das Erstellen des EPC-QR-Codes genutzt wird. EPC steht übrigens für European Payment Code.<\/p>\n
Ein Beispiel für den Inhalt finden wir auf Wikipedia, die praktischerweise direkt die Bezahldaten für eine Spende an Wikipedia selbst im Beispielcode untergebracht haben. Der Inhalt sieht wie folgt aus:<\/p>\n
BCD\r\n001\r\n1\r\nSCT\r\nBFSWDE33BER\r\nWikimedia Foerdergesellschaft\r\nDE33100205000001194700\r\nEUR123.45\r\nSpende fuer Wikipedia<\/pre>\nIn diesem Beispiel sehen Sie einige Leerzeilen, und auch die letzte Zeile könnte noch mit Inhalt gefüllt sein. Daher hier die Zeilen mit der Beschreibung der Inhalte:<\/p>\n
- \n
- Zeile 1 (Beispiel: BCD<\/b>): Service Tag (fester Wert)<\/li>\n
- Zeile 2 (Beispielwert: 002<\/b>): Version (001 <\/b>oder 002<\/b>)<\/li>\n
- Zeile 3 (Beispielwert: 2<\/b>): Zeichencodierung (1=UTF-8, 2=ISO 8859-1, 3=ISO 8859-2, 4=ISO 8859-4, 5=ISO 8859-5, 6=ISO 8859-7, 7=ISO 8859-10, 8=ISO 8859-15)<\/li>\n
- Zeile 4 (Beispielwert: SCT<\/b>): Identifikation, dreistelliger Code – derzeit nur SCT<\/b> (SEPA Credit Transfer<\/b>)<\/li>\n
- Zeile 5 (Beispielwert: BFSWDE33BER<\/b>): BIC der Empfängerbank (in Version 001 <\/b>erforderlich; in Version 002 <\/b>innerhalb des EWR optional)<\/li>\n
- Zeile 6 (Beispielwert: Wikimedia Foerdergesellschaft<\/b>): Name des Zahlungsempfängers (maximal 70 Zeichen Text)<\/li>\n
- Zeile 7 (Beispielwert: DE33100205000001194700<\/b>): Internationale Bankkontonummer (IBAN) des Zahlungsempfängers<\/li>\n
- Zeile 8 (Beispielwert: EUR123.45<\/b>): Zahlungsbetrag (Format EUR#.##<\/b>, zwischen 0.01 und 999999999.99, optional)<\/li>\n
- Zeile 9 (Beispielwert: CHAR<\/b>): Zweck (max. vierstelliger Code analog dem Textschlüssel nach DTA-Verfahren, optional)<\/li>\n
- Zeile 10 (Beispielwert RF18 5390 0754 7034<\/b>): Referenz (strukturierter 35-Zeichen-Code gem. ISO 116 RF Creditor Reference, optional)<\/li>\n
- Zeile 11 (Beispielwert: Spende fuer Wikipedia<\/b>): Verwendungszweck (unstrukturierter maximal 140 Zeichen langer Text, optional)<\/li>\n
- Zeile 12 (Beispielwert: .\/.): Hinweis an den Nutzer (maximal 70 Zeichen, optional)<\/li>\n<\/ul>\n
Wir wollen in diesem Beispielprojekt lediglich die wichtigsten Daten unterbringen. Wie Sie oben gesehen haben, legt man in der zweiten Zeile die Version des EPC-QR-Codes fest, der eigentlich nur einen Unterschied bewirkt: Die erste Version verlangt nach einem BIC, die zweite tut das nicht. Um das Beispiel einfach zu halten, nutzen wir hier die Version 2 und geben den BIC nicht an. Die ersten vier Zeilen enthalten Standardwerte, einige Zeilen bleiben leer, so müssen wir nur die folgenden Daten mit der zu erstellenden COM-DLL entgegennehmen:<\/p>\n
- \n
- Zahlungsempfänger<\/li>\n
- IBAN<\/li>\n
- Zahlungsbetrag<\/li>\n
- Zweck<\/li>\n<\/ul>\n
.NET-Projekt für die COM-DLL erstellen<\/h2>\n
Damit können wir direkt mit der Erstellung der COM-DLL in Visual Studio beginnen. Visual Studio ist in der Community-Edition schon seit einer ganzen Weile kostenlos. Scheuen Sie sich also nicht, es auszuprobieren – es macht Spaß, mal mit einer alternativen Entwicklungsumgebung zu arbeiten!<\/p>\n
Nachdem Visual Studio gestartet ist, hier in der Version 2019, legen Sie ein neues Projekt an. Dazu verwenden wir die Vorlage Klassenbibliothek (.NET-Framework)<\/b>, die Sie wie in Bild 1 auswählen und mit einem Klick auf die Weiter<\/b>-Schaltfläche bestätigen.<\/p>\n
![\"Auswahl](\"..\/fileadmin\/_temp_\/2022_05\/pic_1378_001.png\")
<\/p>\nBild 1: Auswahl des geeigneten Projekttyps<\/span><\/b><\/p>\n
Mit dem folgenden Dialog ist das Erstellen des Projekts bereits abgeschlossen: Hier geben sie noch den Namen für das Projekt ein und legen den Zielordner fest. Sie müssen keinen neuen Ordner anlegen, Visual Studio legt einen Ordner mit dem zuvor festgelegten Namen des Projekts an (siehe Bild 2).<\/p>\n
![\"Eingabe](\"..\/fileadmin\/_temp_\/2022_05\/pic_1378_002.png\")
<\/p>\nBild 2: Eingabe von Zielordner und Projektname<\/span><\/b><\/p>\n
Klassennamen ändern<\/h2>\n
Wenn Sie den Projektmappen-Explorer einsehen, finden Sie hier eine einzige Klasse namens Class1.vb<\/b>. Den Namen dieser Klasse ändern wir auf EPCQRCodeGenerator.vb<\/b> (siehe Bild 3).<\/p>\n
![\"Ändern](\"..\/fileadmin\/_temp_\/2022_05\/pic_1378_003.png\")
<\/p>\nBild 3: Ändern des Namens der einzigen Klasse<\/span><\/b><\/p>\n
Die anschließende Meldung, ob auch alle Verweise darauf geändert werden sollen, akzeptieren wir mit Ja<\/b>. Damit ändert sich auch gleich der Name der Klassenbezeichnung im Modul selbst auf EPCQRCodeGenerator<\/b>.<\/p>\n
NuGet-Paket mit QR-Code-Bibliothek importieren<\/h2>\n
Bevor wir uns an das Programmieren begeben, fügen wir die für das eigentliche Erstellen des QR-Codes notwendige Bibliothek zum Projekt hinzu. Dazu rufen Sie mit dem Menübefehl Projekt|NuGet-Pakete verwalten … <\/b>den NuGet-Manager auf. Hier klicken Sie auf den Bereich Durchsuchen <\/b>und geben im Suchen-Feld den Text QRCode <\/b>ein.<\/p>\n
Daraufhin erscheint das Paket QrCode.Net<\/b>, das wir anklicken und mit einem Klick auf die nun erscheinende Schaltfläche Installieren <\/b>zum Projekt hinzufügen (siehe Bild 4). Dies legt ein paar Elemente im Projekt an, um die wir uns aber nicht weiter kümmern müssen.<\/p>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2022_05\/pic_1378_004.png\")
<\/p>\nBild 4: Hinzufügen des NuGet-Pakets QrCode.Net<\/span><\/b><\/p>\n
Namespaces importieren<\/h2>\n
Um in der Datei EPCQRCodeGenerator.vb <\/b>auf die Elemente des hinzugefügten NuGet-Pakets und auf einige andere Elemente zugreifen zu können, machen wir diese mit einigen Imports<\/b>-Anweisungen verfügbar.<\/p>\n
Diese landen direkt ganz oben in der Datei, also noch über der Public Class<\/b>-Anweisung, und sehen wir folgt aus:<\/p>\n
Imports System.Runtime.InteropServices\r\nImports Gma.QrCodeNet.Encoding\r\nImports Gma.QrCodeNet.Encoding.Windows.Render\r\nImports System.Drawing<\/pre>\n
Für den Import des Namespaces System.Drawing <\/b>müssen wir überdies noch einen entsprechenden Verweis auf die gleichnamige Bibliothek hinzufügen. Dazu öffnen Sie mit dem Menübefehl Projekt|Verweis hinzufügen… <\/b>den Dialog Verweis-Manager <\/b>und suchen dort unter Assemblys nach dem Suchbegriff System.Drawing<\/b>. Den gefundenen Eintrag fügen Sie durch Setzen eines Hakens zum Projekt hinzu (siehe Bild 5).<\/p>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2022_05\/pic_1378_005.png\")
<\/p>\nBild 5: Hinzufügen von Verweisen zum Projekt<\/span><\/b><\/p>\n
Klasse zum Aufnehmen der Überweisungseigenschaften<\/h2>\n
Normalerweise würden wir nun einfach eine Klasse erstellen, welche einige öffentlich deklarierte Eigenschaften enthält, über die Sie vom VBA-Editor aus die für die Überweisung notwendigen Informationen an die DLL übergeben können. Diese Klasse würde jedoch auch einige Standardmember von .NET-Klassen bereitstellen wie GetType <\/b>oder ToString<\/b>.<\/p>\n
Diese benötigen wir aber unter VBA nicht, also gehen wir einen kleinen Umweg. Dazu definieren wir eine öffentliche Schnittstelle, die wir dann implementieren.<\/p>\n
Die Schnittstelle wird als solche mit dem Schlüsselwort Public Interface <\/b>definiert, erhält eine spezielle Auszeichnung, damit sie über die COM-Schnittstelle für den Zugriff von außen bereitgestellt wird und sieht wie folgt aus:<\/p>\n
<InterfaceType(ComInterfaceType.InterfaceIsDual)>\r\nPublic <\/span>Interface IEPCQRCode\r\n Property Verwendungszweck As String<\/span>\r\n Property IBAN As String<\/span>\r\n Property Betrag As <\/span><Runtime.InteropServices. MarshalAs(Runtime.InteropServices. UnmanagedType.Currency)> Decimal\r\n Property Empfaenger As String<\/span>\r\n Function Generate(strPfad As String<\/span>, ByRef strErgebnis As String<\/span>) As Boolean<\/span>\r\nEnd Interface<\/pre>\n<\/p>\n
Wir stellen also genau die gefragten Eigenschaften bereit plus eine Funktion namens Generate<\/b>, mit der wir den QR-Code generieren und unter dem angegebenen Pfad speichern können.<\/p>\n
Implementierung der Schnittstelle<\/h2>\n
Die Schnittstelle implementieren wir unter VB.NET genauso, wie Sie es auch von VBA kennen. Sie erstellen eine Klasse und zeigen hier mit dem Schlüsselwort Implements <\/b>und Angabe der Schnittstellenbezeichnung an, dass diese Klasse die Schnittstelle implementiert. Sollte dieses Thema noch neu für Sie sein: Die Implementierung einer Schnittstelle muss alle in der Schnittstellendefinition vorgegebenen Member umsetzen, also beispielsweise wie hier die Property<\/b>-Eigenschaften und die Funktion Generate<\/b>.<\/p>\n
Den ersten Teil dieser Schnittstelle finden Sie in Listing 1. Wenn Sie schon einmal Property<\/b>-Eigenschaften in Klassenmodulen mit VBA abgebildet haben, vermissen Sie möglicherweise die einzelnen Property Get…<\/b>– und Property Set\/Let…<\/b>-Prozeduren. <\/p>\n
<ClassInterface(ClassInterfaceType.None)>\r\nPublic Class<\/span> EPCQRCodeGenerator\r\n Implements IEPCQRCode\r\n Public <\/span>Property Verwendungszweck As String<\/span> Implements IEPCQRCode.Verwendungszweck\r\n Public <\/span>Property BIC As String<\/span> Implements IEPCQRCode.BIC\r\n Public <\/span>Property IBAN As String<\/span> Implements IEPCQRCode.IBAN\r\n Public <\/span>Property Betrag As Decimal<\/span> Implements IEPCQRCode.Betrag\r\n Public <\/span>Property Empfaenger As String<\/span> Implements IEPCQRCode.Empfaenger\r\n ...<\/pre>\nListing 1: Erster Teil der Schnittstellen-Implementation<\/span><\/b><\/p>\n
Unter VB.NET könnte man eine solche Eigenschaft auch wie folgt definieren:<\/p>\n
Dim <\/span>_Verwendungszweck As String<\/span>\r\nPublic Property <\/span>Verwendungszweck As String<\/span> _\r\n Implements IEPCQRCode.Verwendungszweck\r\n Get\r\n Return _Verwendungszweck\r\n End Get\r\n Set(value As String<\/span>)\r\n _Verwendungszweck = value\r\n End Set<\/span>\r\nEnd Property<\/span><\/pre>\nSie würden also auch hier eine privat deklarierte Member-Variable wie _Verwendungszweck <\/b>deklarieren und dazu eine einzige Property<\/b>-Prozedur, die dann die Get<\/b>– und die Set<\/b>-Prozedur untergeordnet darstellt und _Verwendungzweck <\/b>zurückgibt oder setzt.<\/p>\n
Wenn diese Property <\/b>aber keinen weiteren Code enthält wie beispielsweise eine Validierung, dann können Sie auch wie hier die folgende verkürzte Schreibweise nutzen:<\/p>\n
Public Property <\/span>Verwendungszweck As String<\/span> _\r\n Implements IEPCQRCode.Verwendungszweck<\/pre>\nObwohl diese nicht explizit deklariert ist, steht aber dennoch eine Variable namens _Verwendungszweck <\/b>zur Verfügung, um in anderen Methoden der Klasse auf den dafür übergebenen Wert zuzugreifen.<\/p>\n
Die Funktion Generate<\/h2>\n
Damit kommen wir zum Kernstück der Klasse, der Funktion Generate<\/b> (siehe Listing 2). Diese hat zwei Parameter:<\/p>\n
Public <\/span>Function Generate(strPfad As String<\/span>, ByRef strErgebnis As String<\/span>) As Boolean<\/span> Implements IEPCQRCode.Generate\r\n Dim <\/span>objQREncoder As <\/span>QrEncoder\r\n Dim <\/span>objQRCode As <\/span>QrCode\r\n Dim <\/span>objFixedModuleSize As <\/span>FixedModuleSize\r\n Dim <\/span>objGraphics As <\/span>Graphics\r\n Dim <\/span>strText As String<\/span>\r\n Dim <\/span>objGraphicsRenderer As <\/span>GraphicsRenderer\r\n Dim <\/span>objBMP As <\/span>Bitmap\r\n If <\/span>_BIC.Length > 11 Then<\/span>\r\n strErgebnis = \"BIC fehlt oder ist zu lang.\"\r\n Return False<\/span>\r\n Else<\/span>If _IBAN Is Nothing OrElse _IBAN.Length > 34 Then\r\n strErgebnis = \"IBAN fehlt oder ist zu lang.\"\r\n Return False<\/span>\r\n Else<\/span>If _Betrag = 0 Then\r\n strErgebnis = \"Betrag fehlt.\"\r\n Return False<\/span>\r\n Else<\/span>If _Verwendungszweck.Length > 140 Then\r\n strErgebnis = \"Verwendungszweck ist zu lang.\"\r\n Return False<\/span>\r\n Else<\/span>If _Empfaenger Is Nothing OrElse _Empfaenger.Length > 70 Then\r\n strErgebnis = \"Empfänger fehlt\"\r\n Return False<\/span>\r\n End If<\/span>\r\n strText = \"BCD\" & vbCrLf<\/span>\r\n strText += \"001\" & vbCrLf<\/span>\r\n strText += \"1\" & vbCrLf<\/span>\r\n strText += \"SCT\" & vbCrLf<\/span>\r\n strText += vbCrLf<\/span>\r\n strText += _Empfaenger & vbCrLf<\/span>\r\n strText += _IBAN & vbCrLf<\/span>\r\n strText += \"EUR\" & String.Format(\"{0:0.00}\", CDec(_Betrag)).Replace<\/span>(\",\", \".\") & vbCrLf<\/span>\r\n strText += \"\" & vbCrLf<\/span>\r\n strText += \"\" & vbCrLf<\/span>\r\n strText += _Verwendungszweck & vbCrLf<\/span>\r\n objFixedModuleSize = New<\/span> FixedModuleSize(2, QuietZoneModules.Two)\r\n objGraphicsRenderer = New<\/span> GraphicsRenderer(objFixedModuleSize, Brushes.Black, Brushes.White)\r\n objQREncoder = New<\/span> QrEncoder(ErrorCorrectionLevel.M)\r\n objQRCode = objQREncoder.Encode(strText)\r\n objBMP = New<\/span> Bitmap(objQRCode.Matrix.Width * 2 + 8, objQRCode.Matrix.Height * 2 + 8)\r\n objGraphics = Graphics.FromImage(objBMP)\r\n objGraphicsRenderer.Draw(objGraphics, objQRCode.Matrix)\r\n objBMP.Save(strPfad)\r\n Return True<\/span>\r\n End Function\r\nEnd Class<\/span><\/pre>\nListing 2: Zweiter Teil der Schnittstellen-Implementation<\/span><\/b><\/p>\n
- \n
- strPfad<\/b>: Erwartet den Pfad der zu erstellenden Bilddatei mit dem QR-Code.<\/li>\n
- strErgebnis<\/b>: Rückgabeparameter, der gegebenenfalls eine Fehlermeldung zurückgibt.<\/li>\n<\/ul>\n
Die Funktion deklariert zunächst einige Elemente, die für das Erstellen des QR-Codes verwendet werden. Andere dienen der Erstellung der Grafik auf Basis des QR-Codes.<\/p>\n
Im ersten Teil erfolgen einige Prüfungen, ob die übergebenen Daten vorhanden und nicht zu lang sind beziehungsweise ob der Betrag nicht 0 <\/b>ist. Hier finden Sie als VBA-Entwickler wieder ein unbekanntes Element, nämlich die OrElse<\/b>-Verknüpfung. Diese arbeitet grundsätzlich wie die Or<\/b>-Verknüpfung, aber mit einem Unterschied: Wenn der erste der beiden verknüpften Ausdrücke bereits wahr ist, wird der folgende gar nicht mehr ausgewertet, weil der gesamte Ausdruck somit ohnehin wahr ist.<\/p>\n
Beim BIC <\/b>prüfen wir, ob dieser länger als 11 Zeichen ist. Wenn er leer ist, ist das kein Problem, denn wir haben, wie weiter oben beschrieben, die Version 002 <\/b>des EPC-QR-Codes gewählt, wo BIC nur ein optionaler Parameter ist.<\/p>\n
Die IBAN muss vorhanden sein und darf nicht länger als 34 Zeichen sein. Der Betrag darf nicht 0 <\/b>sein. Der Verwendungszweck darf leer sein, aber nicht länger als 140 Zeichen. Schließlich darf der Empfänger auch nicht leer sein und darf maximal 70 Zeichen haben. Immer wenn eine der Bedingungen nicht erfüllt ist, wird der Rückgabeparameter strErgebnis <\/b>mit einem entsprechenden Text gefüllt und die Funktion mit Return False <\/b>verlassen. Auch das ist anders als unter VBA, wo man den Rückgabewert explizit festlegen und die Funktion mit Exit Function <\/b>verlassen müsste.<\/p>\n
In den folgenden Zeilen fasst die Funktion in der Variablen strText <\/b>den Text für den EPC-QR-Code zusammen. Hier nutzen wir nicht wie unter VBA Anweisungen wie strText = strText & „…“<\/b>, um einer Variablen einen weiteren Text anzuhängen, sondern einfach den Operator +=<\/b>. Hinter jedem Element fügen wir mit vbCrLf <\/b>einen Zeilenumbruch an.<\/p>\n
Dann folgt der eigentlich interessante Teil. Wir legen mit einem neuen Objekt auf Basis der Klasse FixedModuleSize <\/b>die Größe der „Module“ des QR-Codes fest. Ein Modul ist eines der schwarzen oder weißen Elemente in der QR-Code-Matrix. Mit dem Wert 2 als ersten Parameter geben wir an, dass jedes „Modul“ mit 2×2 Pixeln dargestellt werden soll. Die folgende Anweisung erzeugt ein neues Objekt des Typs GraphicsRenderer <\/b>und übergibt das soeben erstellte Objekt sowie die Farben für die verschiedenen „Module“. Einen QR-Code können Sie mit verschiedenen Farben gestalten – wichtig ist nur, dass es etwas Kontrast zwischen den Farben gibt. Das neue Objekt auf Basis der Klasse QrEncoder <\/b>nimmt den Fehlerkorrekturlevel entgegen. Für EPC-QR-Codes muss dieser M <\/b>lauten. Mit der Methode Encode <\/b>kodiert das Objekt objQREncoder <\/b>dann den mit strText <\/b>übergebenen Text.<\/p>\n
Danach kommen noch die Grafik-Objekte zum Zuge. Zunächst erstellt die Funktion ein neues Bitmap<\/b>-Objekt mit der entsprechenden Größe, wobei die Höhe und die Breite den Eigenschaften Matrix.Width <\/b>und Matrix.Height <\/b>des Objekts objQRCode <\/b>entnommen werden.<\/p>\n
Auf dessen Basis erstellt die Funktion ein Graphics<\/b>-Objekt und die Draw<\/b>-Methode des GraphicsRenderer<\/b>-Objekts zeichnet die Matrix des QR-Codes hinein. Schließlich speichert die Save<\/b>-Methode das neu erstellte und mit dem QR-Code gefüllte Bitmap<\/b>-Objekt. Die Funktion liefert schließlich den Wert True <\/b>zurück.<\/p>\n
Letzte Einstellungen für die COM-DLL<\/h2>\n
Nun müssen wir noch zwei Eigenschaften des Projekts anpassen, damit die COM-DLL funktioniert. Dazu öffnen Sie mit einem Rechtsklick auf den Projekt-Eintrag im Projektmappen-Explorer das Kontextmenü und wählen dort den Befehl Eigenschaften <\/b>aus. Im nun erscheinenden Eigenschaften-Fenster wird normalerweise direkt der Bereich Anwendung <\/b>angezeigt. Hier finden Sie eine Schaltfläche namens Assemblyinformationen…<\/b>, mit der Sie den Dialog Assemblyinformationen <\/b>öffnen. Hier aktivieren Sie die Option Assembly COM-sichtbar machen <\/b>(siehe Bild 6). Danach schließen Sie dieses Fenster wieder.<\/p>\n
![\"Aktivieren](\"..\/fileadmin\/_temp_\/2022_05\/pic_1378_006.png\")
<\/p>\nBild 6: Aktivieren der Option Assembly COM-sichtbar machen<\/span><\/b><\/p>\n
Wir bleiben noch bei den Eigenschaften und wechseln dort zum Bereich Kompilieren<\/b>. Hier finden wir im unteren Bereich die Eigenschaft Für COM-Interop registrieren<\/b>, die wir ebenfalls aktivieren (siehe Bild 7).<\/p>\n
![\"Aktivieren](\"..\/fileadmin\/_temp_\/2022_05\/pic_1378_007.png\")
<\/p>\nBild 7: Aktivieren der Option Für COM-Interop registrieren<\/span><\/b><\/p>\n
COM-DLL erstellen<\/h2>\n
Danach sind wir fast bereit für das Erstellen der COM-DLL. Sie müssen nur noch rekapitulieren, ob Sie Visual Studio im Administrator-Modus gestartet haben oder nicht. Falls nicht, klicken Sie mit der rechten Maustaste auf das Programm Visual Studio 2019 <\/b>(oder die bei Ihnen installierte Version) und wählen Sie aus dem Kontextmenü den Eintrag Als Administrator ausführen<\/b>. Nach dem erneuten Laden des Projekts betätigen Sie den Menübefehl Erstellen|Projektmappe erstellen<\/b>. Dies sorgt für verschiedene Aktionen, unter anderem die Folgenden:<\/p>\n
- \n
- Im Ordner bin\\debug <\/b>im Projektordner werden einige Dateien erstellt wie aiuEPCQRCode.dll <\/b>oder aiuEPCQRCode.tlb<\/b>.<\/li>\n
- Außerdem hat dies einige Registryeinträge vorgenommen, die nun dafür sorgen, dass die COM-DLL beim nächsten Start von Access im VBA-Editor im Verweise<\/b>-Dialog referenziert werden kann.<\/li>\n<\/ul>\n
Mit der COM-DLL arbeiten<\/h2>\n
Und genau das probieren wir nun aus. Wenn das Erstellen erfolgreich war und auch der Ordner bin\\debug <\/b>die genannten Dateien mit aktuellem Datum enthält, stehen die Chancen gut, dass Sie die COM-DLL nun unter Access verwenden können.<\/p>\n
Dazu starten Sie Access und öffnen eine beliebige Datenbank. Dann wechseln Sie mit Alt + F11 <\/b>in den VBA-Editor.<\/p>\n
Hier wählen Sie den Menüeintrag Extras|Verweise <\/b>aus und öffnen so den Verweise<\/b>-Dialog. Hier navigieren Sie zum Eintrag aiuEPCQRCode<\/b> und aktivieren diesen (siehe Bild 8). Anschließend schließen Sie den Dialog wieder.<\/p>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2022_05\/pic_1378_008.png\")
<\/p>\nBild 8: Hinzufügen eines Verweises auf die neue COM-DLL<\/span><\/b><\/p>\n
Öffnen Sie nun den Objektkatalog und wählen Sie im oberen Auswahlfeld den Eintrag aiuEPCQRCode <\/b>aus. Unten finden Sie dann die Klasse EPCQRCodeGenerator<\/b> vor (siehe Bild 9).<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2022_05\/pic_1378_009.png\")
<\/p>\nBild 9: Die COM-DLL im Objektkatalog<\/span><\/b><\/p>\n
EPC-QR-Code generieren<\/h2>\n
Damit bleibt noch, die Generierung eines EPC-QR-Codes zu testen. Dazu legen wir in einem neuen Modul eine Prozedur wie in Listing 3 an. Diese erstellt ein neues Objekt auf Basis der Klasse EPCQRCodeGenerator<\/b> und referenziert dieses mit der zuvor deklarierten Variablen objEPCQRCodeGenerator<\/b>.<\/p>\n
Public Sub <\/span>EPCQRCodeErstellen()\r\n Dim <\/span>objEPCQRCodeGenerator As <\/span>aiuEPCQRCode.EPCQRCodeGenerator\r\n Dim <\/span>strPfad As String<\/span>\r\n Dim <\/span>strErgebnis As String<\/span>\r\n Set<\/span> objEPCQRCodeGenerator = New<\/span> aiuEPCQRCode.EPCQRCodeGenerator\r\n With<\/span> objEPCQRCodeGenerator\r\n .IBAN = \"DE33100205000001194700\"\r\n .BIC = \"BFSWDE33BER\"\r\n .Empfaenger = \"Wikimedia Foerdergesellschaft\"\r\n .Betrag = 10\r\n .Verwendungszweck = \"Spende fuer Wikipedia\"\r\n strPfad = CurrentProject.Path & \"\\QRCode.png\"\r\n If <\/span>.Generate(strPfad, strErgebnis) = True<\/span> Then<\/span>\r\n Debug.Print<\/span> \"Erfolgreich erstellt.\"\r\n Else<\/span>\r\n Debug.Print<\/span> \"Nicht erfolgreich.\" & vbCrLf<\/span> & strErgebnis\r\n End If<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n - Außerdem hat dies einige Registryeinträge vorgenommen, die nun dafür sorgen, dass die COM-DLL beim nächsten Start von Access im VBA-Editor im Verweise<\/b>-Dialog referenziert werden kann.<\/li>\n<\/ul>\n
- strErgebnis<\/b>: Rückgabeparameter, der gegebenenfalls eine Fehlermeldung zurückgibt.<\/li>\n<\/ul>\n
- strPfad<\/b>: Erwartet den Pfad der zu erstellenden Bilddatei mit dem QR-Code.<\/li>\n
- Zeile 2 (Beispielwert: 002<\/b>): Version (001 <\/b>oder 002<\/b>)<\/li>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2022_05\/pic_1378_010.png\")
<\/p>\n