![\"Der](\"..\/tl_files\/images\/pic_470_001.png\")
<\/a><\/p>\nBild 1: Der Verweise-Dialog von Access<\/p>\n
Bei umfangreicheren Anwendungen kommen meist noch Verweise auf weitere Bibliotheken hinzu, zum Beispiel um Word, Excel oder Outlook zu automatisieren, die Datenzugriffs-Bibliothek ADODB zu nutzen oder auch um die Befehle für die Verarbeitung von XML hinzuzufügen.<\/p>\n
Wenn Sie nun einen Verweis auf Outlook hinzufügen, die Datenbank auf den Zielrechner übertragen und dann aber Outlook gar nicht auf dem Zielrechner vorliegt, gibt es Probleme wegen des fehlenden Verweises.<\/p>\n
Manchmal gibt es auch Probleme, wenn Sie mit einem Verweis auf die Objektbibliothek von Outlook 2016 programmieren und auf dem Zielrechner ist eine ältere Version von Outlook vorhanden.<\/p>\n
Manuelle Lösung<\/h2>\n
Vorausgesetzt, die Bibliothek, auf die der Verweis zeigen soll, ist auf dem Zielrechner installiert und registriert, können Sie wie folgt vorgehen, um den Verweis zu erneuern:<\/p>\n
- \n
- öffnen Sie den Verweise<\/b>-Dialog.<\/li>\n
- Entfernen Sie den mit NICHT VORHANDEN <\/b>markierten Verweis.<\/li>\n
- Fügen Sie den Verweis auf die gewünschte Bibliothek zur Liste der Verweise hinzu, indem Sie den entsprechenden Eintrag per Haken selektieren.<\/li>\n
- Schließen Sie den Verweise<\/b>-Dialog.<\/li>\n<\/ul>\n
Danach sollte die Anwendung dann wie gewohnt funktionieren. Eine Ausnahme könnte sein, dass Sie in Ihrer Anwendung tatsächlich Funktionen einer neueren Bibliothek verwenden, die in der älteren, auf dem Zielrechner vorhandenen Version noch nicht verfügbar ist.<\/p>\n
Wenn Sie eine Anwendung beim Kunden laufen haben, für die Sie regelmäßig neue Versionen liefern, dann ist es für den Kunden natürlich mühselig, immer die Verweise zu aktualisieren – daher stellen wir nun eine Alternative vor.<\/p>\n
Verweise automatisch beim Start aktualisieren<\/h2>\n
Die Alternative lautet, beim Start einer Anwendung die Verweise zu prüfen und diese gegebenenfalls zu erneuern. Wenn ein Verweis nicht gesetzt werden kann, weil die entsprechende Bibliothek nicht verfügbar ist, soll eine Meldung erscheinen, die den Benutzer darüber informiert, damit dieser mit dem Entwickler der Software herausfinden kann, wo das Problem in diesem Fall liegt.<\/p>\n
Zu Beispielzwecken nehmen wir an, dass wir Verweise auf die Bibliotheken für den Zugriff auf die Office-Anwendungen Excel, Outlook und Word hinzufügen sowie einen auf die Bibliothek Microsoft XML, v6.0 <\/b>(siehe Bild 2).<\/p>\n
![\"Verweise-Dialog](\"..\/tl_files\/images\/pic_470_007.png\")
<\/a><\/p>\nBild 2: Verweise-Dialog mit zusätzlichen Verweisen<\/p>\n
Bei den mit diesen Verweisen referenzierten Bibliotheken handelt es sich sämtlich um registrierte Bibliotheken, für die es eine GUID gibt. Diese wollen wir nun zunächst ermitteln, indem wir diese per VBA-Routine im Direktbereich des VBA-Editors ausgeben:<\/p>\n
Public Sub <\/span>VerweisePruefenUndErneuern()\r\n Dim <\/span>objReference As <\/span>Reference\r\n Dim <\/span>strGUID As String<\/span>\r\n For Each objReference In References\r\n Debug.Print<\/span> objReference.Name\r\n Debug.Print<\/span> objReference.FullPath\r\n Debug.Print<\/span> objReference.Guid\r\n Next<\/span> objReference\r\nEnd Sub<\/span><\/pre>\nDas Ergebnis sieht dann so aus:<\/p>\n
VBA\r\nC:\\Program Files (x86)\\...\\VBA7.1\\VBE7.DLL\r\n{000204EF-0000-0000-C000-000000000046}\r\nAccess\r\nC:\\Program Files (x86)\\...\\MSACC.OLB\r\n{4AFFC9A0-5F99-101B-AF4E-00AA003F0F07}\r\nstdole\r\nC:\\Windows\\SysWOW64\\stdole2.tlb\r\n{00020430-0000-0000-C000-000000000046}\r\nDAO\r\nC:\\Program Files (x86)\\...\\OFFICE16\\ACEDAO.DLL\r\n{4AC9E1DA-5BAD-4AC7-86E3-24F4CDCECA28}\r\nExcel\r\nC:\\Program Files (x86)\\...\\EXCEL.EXE\r\n{00020813-0000-0000-C000-000000000046}\r\nOutlook\r\nC:\\Program Files (x86)\\...\\MSOUTL.OLB\r\n{00062FFF-0000-0000-C000-000000000046}\r\nWord\r\nC:\\Program Files (x86)\\...\\MSWORD.OLB\r\n{00020905-0000-0000-C000-000000000046}\r\nMSXML2\r\nC:\\Windows\\SysWOW64\\msxml6.dll\r\n{F5078F18-C551-11D3-89B9-0000F81FE221}<\/pre>\nNun wollen wir ja gar nicht alle Einträge prüfen, sondern nur diejenigen, die nicht eingebaut sind. Das prüfen wir durch eine If…Then<\/b>-Bedingung, mit der wir den Wert der Eigenschaft BuiltIn <\/b>untersuchen. Ist diese True<\/b>, handelt es sich um eine eingebaute Eigenschaft, die wir nicht ersetzen müssen, da diese meist vorhanden sind. Hat BuiltIn <\/b>den Wert False<\/b>, müssen wir handeln: Dann könnte es sein, dass ein falscher Verweis zu Fehlern führt. Mit der folgenden geänderten Version der Prozedur VerweisePruefenUndErneuern <\/b>geben wir nur noch die Verweise aus, die wir erneuern können:<\/p>\n
Public Sub <\/span>VerweisePruefenUndErneuern()\r\n Dim <\/span>objReference As <\/span>Reference\r\n Dim <\/span>strGUID As String<\/span>\r\n For Each objReference In References\r\n If <\/span>objReference.BuiltIn = True<\/span> Then<\/span>\r\n Debug.Print<\/span> objReference.Name\r\n Debug.Print<\/span> objReference.FullPath\r\n Debug.Print<\/span> objReference.Guid\r\n End If<\/span>\r\n Next<\/span> objReference\r\nEnd Sub<\/span><\/pre>\nDamit erhalten wir dann ein ähnliches Ergebnis wie weiter oben, nur dass diesmal die eingebauten Verweise nicht berücksichtigt werden.<\/p>\n
Was fangen wir nun damit an Wir könnten direkt in dieser Prozedur ein paar Zeilen unterbringen, die dafür sorgen, dass die Verweise auf Gültigkeit überprüft und gegebenenfalls erneuert werden. Das würde dann etwa wie in Listing 1 aussehen. Hier durchlaufen wir wieder alle Reference<\/b>-Objekte, schließen aber durch die ersten beiden If…Then<\/b>-Bedingungen zuerst die eingebauten und dann die vorhandenen Verweise aus.<\/p>\n
Public Sub <\/span>VerweisePruefenUndErneuern()\r\n Dim <\/span>objReference As <\/span>Reference\r\n Dim <\/span>objReferenceNew As <\/span>Reference\r\n Dim <\/span>strReference As String<\/span>\r\n Dim <\/span>strGUID As String<\/span>\r\n For Each objReference In References\r\n If <\/span>objReference.BuiltIn = False<\/span> Then<\/span>\r\n If <\/span>objReference.IsBroken = True<\/span> Then<\/span>\r\n strGUID = objReference.Guid\r\n strReference = objReference.Name\r\n References.Remove objReference\r\n Set<\/span> objReferenceNew<\/span> = References.AddFromGuid(strGUID, 0, 0)\r\n If <\/span>objReference Is Nothing Then<\/span>\r\n MsgBox<\/span> \"Der Verweis auf die Bibliothek '\" & strReference & \"' fehlt.\"\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> objReference\r\nEnd Sub<\/span><\/pre>\nListing 1: Fehlende Verweise werden direkt erneuert<\/p>\n
Sind beide If…Then<\/b>-Bedingungen wahr, merken wir uns in den Variablen strGUID <\/b>und strReference <\/b>die GUID und den Namen der referenzierten Bibliothek. Dann fügen wir die Referenz auf eine Bibliothek über die Methode AddFromGUID <\/b>wieder zur Liste References <\/b>hinzu. Dabei übergeben wir als Parameter die GUID der Bibliothek sowie den Wert 0 <\/b>für die beiden Parameter Major <\/b>und Minor<\/b>.<\/p>\n
Eine fehlende Bibliothek sollte damit wieder referenziert werden können.<\/p>\n
Diese Prozedur rufen wir am besten beim Start der Anwendung auf, damit keine Fehler durch fehlende Verweis auftreten. Wie das gelingt, zeigen wir am Ende des Beitrags.<\/p>\n
Benötigte Verweise an anderer Stelle speichern<\/h2>\n
Das Problem ist nur: Wenn der Benutzer auf irgendeine Weise einen der Verweise entfernt, ohne diesen wieder hinzuzufügen, treten in der Folge Probleme auf an den Stellen, wo im Code Elemente dieser Bibliothek verwendet werden.<\/p>\n
Wenn wir dann beim Starten der Anwendung die Prozedur aufrufen, durchläuft diese wieder alle Verweise und prüft die Verweise mit der Eigenschaft IsBroken<\/b>. Wenn jedoch ein Verweis auf eine Bibliothek gar nicht mehr in der Liste der Verweise enthalten ist, kann er mit der hier vorliegenden Version der Prozedur auch nicht ersetzt werden – die Prozedur erfährt ja gar nicht, das ein Verweis fehlt. Das wird erst später offensichtlich, wenn die Anwendung das erste Mal auf Elemente der mit dem Verweis referenzierten Bibliothek zugreift und dadurch Laufzeitfehler ausgelöst werden.<\/p>\n
Also wollen wir, bevor wir die Anwendung an den Benutzer weitergeben, die Verweise, die überprüft werden sollen, in irgendeiner Form speichern. Dabei gibt es zwei Möglichkeiten:<\/p>\n
- \n
- Wir speichern die GUIDs fest im Code.<\/li>\n
- Wir legen eine Tabelle an, der wir die Informationen über die Verweise hinzufügen. Diese Tabelle sollte dann im Frontend der Datenbankanwendung liegen, wenn diese in Frontend und Backend aufgeteilt ist.<\/li>\n<\/ul>\n
Die Basis für beide Varianten sieht beispielsweise wie in Listing 2 aus. Diese Funktion nimmt den Parameter strGUID <\/b>entgegen. Im Direktbereich könnten wir die Funktion wie folgt aufrufen:<\/p>\n
Public Function <\/span>VerweiseErneuern(strGUID As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>objReference As <\/span>Reference\r\n Dim <\/span>bolReferenceMissing As Boolean<\/span>\r\n Dim <\/span>bolReferenceBroken As Boolean<\/span>\r\n bolReferenceBroken = False<\/span>\r\n bolReferenceMissing = True<\/span>\r\n VerweiseErneuern = True<\/span>\r\n For Each objReference In References\r\n If <\/span>objReference.Guid = strGUID Then<\/span>\r\n bolReferenceMissing = False<\/span>\r\n If <\/span>objReference.IsBroken = True<\/span> Then<\/span>\r\n bolReferenceBroken = True<\/span>\r\n End If<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> objReference\r\n If <\/span>bolReferenceMissing = True<\/span> Or bolReferenceBroken = True<\/span> Then<\/span>\r\n On Error Resume Next<\/span>\r\n References.Remove objReference\r\n Set<\/span> objReference = References.AddFromGuid(strGUID, 0, 0)\r\n If <\/span>objReference Is Nothing Then<\/span>\r\n VerweiseErneuern = False<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nListing 2: Erneuern des Outlook-Verweises<\/p>\n
VerweiseErneuern(\"{00062FFF-0000-0000-C000-000000000046}\")<\/pre>\nDie Funktion stellt die Variablen bolReferenceBroken <\/b>auf False <\/b>und bolReferenceMissing <\/b>auf True <\/b>ein. Dann versucht sie, einen Verweis auf die Bibliothek mit der mit strGUID <\/b>übergebenen GUID zu finden. Dies geschieht in einer For Each<\/b>-Schleife über alle Elemente der Auflistung References<\/b>. Wenn der aktuell mit objReference <\/b>referenzierte Verweis die gesuchte GUID enthält, können wir die Variable bolReferenceMissing <\/b>schon einmal auf False <\/b>einstellen, denn der Verweis ist ja zumindest vorhanden.<\/p>\n
Dann prüft die Prozedur mit der Eigenschaft IsBroken <\/b>noch, ob der Verweis als NICHT VORHANDEN <\/b>markiert ist. Das ist etwas missverständlich, denn NICHT VORHANDEN <\/b>gibt ja nicht an, dass der Verweis fehlt, sondern die referenzierte Bibliothek. Jedenfalls stellt die Funktion die Variable bolReferenceBroken <\/b>auf True <\/b>ein, wenn IsBroken <\/b>den Wert True <\/b>aufweist. Sobald der Verweis passend zu strGUID <\/b>gefunden wurde, verlassen wir dann auch mit Exit For <\/b>die Schleife.<\/p>\n
objReference <\/b>enthält somit auch einen Verweis auf das Reference<\/b>-Objekt. Damit gehen wir in eine If…Then<\/b>-Bedingung, in der wir prüfen, ob entweder bolReferenceMissing <\/b>oder bolReferenceBroken <\/b>den Wert True <\/b>hat. Das ist nun entweder der Fall, wenn der Verweis gar nicht vorhanden ist oder dieser „broken“ ist.<\/p>\n
Dann versucht die Funktion, den Verweis mit der Remove<\/b>-Methode der References<\/b>-Auflistung zu entfernen und diesen dann über die Methode AddFromGUID <\/b>erneut hinzuzufügen, wobei ein Verweis auf das neue Reference<\/b>-Objekt in der Variablen objReference <\/b>landet – aber auch nur, wenn das Hinzufügen erfolgreich war.<\/p>\n
Wenn etwa die Datei hinter der GUID nicht vorhanden ist, gelingt dies nicht und objReference <\/b>bleibt leer.<\/p>\n
Ist objReference <\/b>danach leer, wird der Wert False<\/b> mit dem Funktionswert zurückgegeben.<\/p>\n
Von einer Prozedur aus könnten wir diese Funktion wie etwa in Listing 3 aufrufen. Dies würde, wenn die Outlook-Bibliothek nicht vorhanden oder fehlerhaft ist, eine Meldung liefern.<\/p>\n
Public Sub <\/span>VerweiseErneuernAufruf()\r\n Dim <\/span>strGUID As String<\/span>\r\n Dim <\/span>strReference As String<\/span>\r\n strGUID = \"{00062FFF-0000-0000-C000-000000000046}\"\r\n strReference = \"Microsoft Outlook x.0 Object Library\"\r\n If <\/span>VerweiseErneuern(strGUID, strReference) = False<\/span> Then<\/span>\r\n MsgBox<\/span> \"Der Verweis auf die Bibliothek '\" & strReference & \"' ist fehlerhaft und wurde entfernt oder ist nicht \" _\r\n & \"vorhanden. Fügen Sie den Verweis auf die Bibliothek manuell hinzu.\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nListing 3: Aufruf der Funktion VerweiseErneuern<\/p>\n
Reparieren eines Verweises testen<\/h2>\n
Das wollen wir nun ausprobieren. Solange der Verweis nicht auf eine nicht vorhandene Datei zeigt, was man nach dem öffnen des Verweise<\/b>-Dialog schnell durch eine Prüfung auf den Hinweis NICHT VORHANDEN<\/b> prüfen kann.<\/p>\n
Ist der Verweis fehlerhaft, sieht der Eintrag im Verweise<\/b>-Dialog wie in Bild 3 aus.<\/p>\n
![\"Der](\"..\/tl_files\/images\/pic_470_009.png\")
<\/a><\/p>\nBild 3: Der mit NICHT VORHANDEN markierte Eintrag<\/p>\n
Gegebenenfalls erhalten Sie beim öffnen des Verweise-Dialogs auch gleich eine Meldung wie in Bild 4.<\/p>\n
![\"Hinweis](\"..\/tl_files\/images\/pic_470_008.png\")
<\/a><\/p>\nBild 4: Hinweis auf ein Verweis-Problem<\/p>\n
Wie aber wollen Sie das Reparieren eines Verweises testen, wenn sich auf Ihrem System überhaupt kein Probleme verursachender Verweis befindet Dann können Sie selbst ein solches Problem schaffen. Dazu suchen Sie beispielsweise die Datei MSOUTL.OLB <\/b>auf, unter Windows 10 und Office 2016 etwa im Verzeichnis C:\\Program Files (x86)\\Microsoft Office\\root\\Office16 <\/b>zu finden (den Pfad finden Sie aber auch über die FullPath<\/b>-Eigenschaft des Reference<\/b>-Objekts).<\/p>\n
Diese benennen wir einfach in _MSOUTL.OLB <\/b>um. Die dabei erscheinende Meldung, die nach Administratorberechtigungen verlangt, können Sie bestätigen. Vergessen Sie nicht, die Datei später wieder umzubenennen!<\/p>\n
Wenn Sie nun die Beispieldatenbank starten und in den Verweise<\/b>-Dialog schauen, finden Sie einen als NICHT VORHANDEN <\/b>markierten Eintrag der Bibliothek Microsoft Outlook 16.0 Object Library<\/b>.<\/p>\n
Diesen können Sie dann versuchen, mit der obigen Funktion wiederherzustellen. Das wird in diesem Fall scheitern, da der Verweis tatsächlich ins Leere zeigt und die hinter der GUID angegebene Datei MSOUTL.OLB <\/b>nicht vorhanden ist.<\/p>\n
Den Fall, dass die Outlook-Bibliothek nicht in der gewünschten Version vorhanden ist und es dadurch einen Fehler gibt, konnten wir mangels anderer Outlook-OLB-Datei nicht nachstellen. Die Prozedur sollte jedoch in diesem Fall den alten Verweis löschen und den auf die korrekte Version hinzufügen können.<\/p>\n
Funktion für mehrere Verweise aufrufen<\/h2>\n
Wenn Sie gleich für mehrere Verweise prüfen wollen, ob diese noch vorhanden und einsatzbereit sind, können Sie die Funktion auch für mehrere Verweise in einer Routine aufrufen (siehe Listing 4).<\/p>\n
Public Sub <\/span>VerweiseErneuernAufrufMehrere()\r\n Dim <\/span>strGUID As String<\/span>\r\n Dim <\/span>strReference As String<\/span>\r\n Dim <\/span>strMeldung As String<\/span>\r\n strGUID = \"{00062FFF-0000-0000-C000-000000000046}\" 'Outlook\r\n strReference = \"Microsoft Outlook x.0 Object Library\"\r\n If <\/span>VerweiseErneuern(strGUID, strReference) = False<\/span> Then<\/span>\r\n strMeldung = strMeldung & strReference & vbCrLf<\/span>\r\n End If<\/span>\r\n strGUID = \"{00020813-0000-0000-C000-000000000046}\" 'Excel\r\n strReference = \"Microsoft Excel x.0 Object Library\"\r\n If <\/span>VerweiseErneuern(strGUID, strReference) = False<\/span> Then<\/span>\r\n strMeldung = strMeldung & strReference & vbCrLf<\/span>\r\n End If<\/span>\r\n ... weitere Verweise\r\n If <\/span>Len<\/span>(strMeldung) > 0 Then<\/span>\r\n strMeldung = \"Ein oder mehrere Verweise konnten nicht wiederhergestellt werden:\" _\r\n & vbCrLf<\/span> & vbCrLf<\/span> & strMeldung\r\n strMeldung = strMeldung & vbCrLf<\/span> & \"Fügen Sie diese manuell hinzu oder kontaktieren \" _\r\n & \"Sie den Entwickler.\"\r\n MsgBox<\/span> strMeldung, , \"Fehlerhafte Verweise\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nListing 4: Erneuern mehrerer Verweise<\/p>\n
Hier übergeben wir nacheinander die Parameter für die Prüfung und gegebenenfalls Erneuerung verschiedener Verweise. Immer wenn die Funktion den Wert False <\/b>zurückliefert, wird der Variablen strMeldung <\/b>eine Zeile mit der Bezeichnung der jeweils nicht reparierten Referenz hinzugefügt. Am Ende prüft die Prozedur, ob mindestens eine Referenz nicht repariert werden konnte und ergänzt die Meldung aus strMeldung <\/b>aus eine führende und eine folgende Zeile, die dem Benutzer mitteilen, welche Schritte nun nötig sind.<\/p>\n
Speichern der Referenzen in einer Tabelle<\/h2>\n
Wir können die Daten für die Verweise statt im Code auch in einer Tabelle speichern, was ein späteres Hinufügen oder Entfernen der Verweise erleichtert. Diese Tabelle heißt tblReferences <\/b>und sieht nach dem Füllen etwa wie in Bild 5 aus.<\/p>\n
![\"Tabelle](\"..\/tl_files\/images\/pic_470_010.png\")
<\/a><\/p>\nBild 5: Tabelle zum Speichern der Verweisinformationen<\/p>\n
Um uns die Arbeit zu erleichtern, schreiben wir eine Prozedur, mit der wir die Daten der Verweise in die Tabelle eintragen. Diese sieht wie in Listing 5 aus. Hier durchlaufen wir alle Verweise der aktuellen Datenbank und prüfen, welche davon nicht eingebaut sind. Für diese fügen wir dann per INSERT INTO<\/b>-Anweisung jeweils einen Datensatz zur Tabelle tblReferences <\/b>hinzu.<\/p>\n
Public Sub <\/span>VerweiseInDB()\r\n Dim <\/span>objReference As <\/span>Reference\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblReferences\", dbOpenDynaset\r\n For Each objReference In References\r\n If <\/span>objReference.BuiltIn = False<\/span> Then<\/span>\r\n db.Execute \"INSERT INTO tblReferences(ReferenceGUID, ReferenceName) \" _\r\n & \"VALUES('\" & objReference.Guid & \"', '\" _\r\n & objReference.Name & \"')\", dbFailOnError\r\n End If<\/span>\r\n Next<\/span> objReference\r\nEnd Sub<\/span><\/pre>\nListing 5: Eintragen der Verweisdaten in die Tabelle tblReferences<\/p>\n
Vorher leeren wir die Tabelle noch per DELETE<\/b>-Anweisung.<\/p>\n
Sie können nach dem Durchlaufen dieser Prozedur noch manuell die Bezeichnungen der Verweise anpassen, also etwa Microsoft Outlook x.0 Object Library <\/b>statt Outlook<\/b>. Das Ergebnis sieht dann wie in Bild 6 aus.<\/p>\n
![\"Verweisinformationen](\"..\/tl_files\/images\/pic_470_011.png\")
<\/a><\/p>\nBild 6: Verweisinformationen mit ausgeschriebenen Bibliotheken<\/p>\n
Um die Funktion VerweiseErneuern <\/b>für jeden Eintrag der Tabelle einmal aufzurufen, verwenden wir die Prozedur aus Listing 6. Diese erstellt ein Recordset auf Basis der Tabelle tblReferences<\/b>. Danach durchläuft sie alle Datensätze dieses Recordsets und ruft für jeden Datensatz die Funktion VerweiseErneuern <\/b>auf und übergibt den Wert des Feldes ReferenceGUID <\/b>an die Funktion.<\/p>\n
Public Sub <\/span>VerweiseErneuernAusTabelleAufruf()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblReferences\", dbOpenDynaset)\r\n Dim <\/span>strMeldung As String<\/span>\r\n Do While<\/span> Not<\/span> rst.EOF\r\n If <\/span>VerweiseErneuern(rst!ReferenceGUID) = False<\/span> Then<\/span>\r\n strMeldung = strMeldung & rst!ReferenceName & vbCrLf<\/span>\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n If <\/span>Len<\/span>(strMeldung) > 0 Then<\/span>\r\n strMeldung = \"Ein oder mehrere Verweise konnten nicht wiederhergestellt werden:\" & vbCrLf<\/span> & vbCrLf<\/span> & strMeldung\r\n strMeldung = strMeldung & vbCrLf<\/span> & \"Fügen Sie diese manuell hinzu oder kontaktieren Sie den Entwickler.\"\r\n MsgBox<\/span> strMeldung, , \"Fehlerhafte Verweise\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nListing 6: Verweise aus der Tabelle erneuern<\/p>\n
Liefert die Funktion den Wert False <\/b>zurück, was bedeutet, dass ein fehlerhafter Verweis nicht repariert werden konnte, wird die Zeichenkette strMeldung <\/b>um den Namen der Bibliothek in jeweils einer eigenen Zeile ergänzt. Ist mindestens ein Verweis nicht wiederherstellbar, erscheint eine Meldung wie aus Bild 7.<\/p>\n
![\"Ein](\"..\/tl_files\/images\/pic_470_012.png\")
<\/a><\/p>\nBild 7: Ein Verweis konnte nicht wiederhergestellt werden.<\/p>\n
Prozedur beim Start der Anwendung aufrufen<\/h2>\n
Um diese Prozedur beim Start einer Anwendung aufzurufen, haben Sie zwei Möglichkeiten:<\/p>\n
- \n
- Sie legen das AutoExec<\/b>-Makro an und fügen den Namen der Prozedur für eine neue Makroaktion namens AusführenCode<\/b> hinzu. Dazu ändern Sie die Prozedur VerweiseErneuernAusTabelleAufruf <\/b>in eine Funktion um (Entwurf des Makros siehe Bild 8).<\/li>\n
- Entfernen Sie den mit NICHT VORHANDEN <\/b>markierten Verweis.<\/li>\n