<\/p>\n
Wenn eine Datenbank beschädigt ist, können Sie diese oft retten, indem Sie eine neue Datenbank aufsetzen und alle Objekte der alten Datenbank in die neue Datenbank importieren. Leider berücksichtigt die Import-Funktion nicht die Verweise des VBA-Projekts. Je nach der Anzahl der Verweise kann das Übertragen der Verweise recht mühsam werden. Zum Glück kann man fast alles automatisieren, was sich sonst über die Benutzeroberfläche von Access erledigen lässt. In diesem Fall bauen wir uns ein Add-In, mit dem wir der aktuell geöffneten Datenbank die Verweise einer ausgewählten Datenbank hinzufügen können.<\/b><\/p>\n
Gründe dafür, Verweise aus anderen Datenbanken zu importieren, gibt es genug. Einen haben wir bereits genannt – wenn Sie eine Datenbank bestehend auf einer anderen, gegebenenfalls beschädigten Datenbank neu aufbauen wollen, dann sind die Verweise eines der wenigen Elemente, die Sie nicht mit der eingebauten Importieren-Funktion übertragen können.<\/p>\n
Ein anderer Grund ist die Unzulänglichkeit des Verweise<\/b>-Dialogs: Wenn dieser für das Quellprojekt beispielsweise Einträge enthält, die nicht in der Liste der Verweise enthalten sind, sondern die über den Durchsuchen<\/b>-Dialog hinzugefügt wurden, dann müssen Sie diese auch in der Zieldatenbank wieder über den Durchsuchen<\/b>-Dialog hinzufügen.<\/p>\n
Wenn der Pfad der Datei hinter dem Verweis wie in Bild 1 etwas länger ist, dann können Sie den hinteren Teil nicht mehr lesen, weil nur ein geringer Teil des Pfades angezeigt wird.<\/p>\n
![\"Zu](\"..\/fileadmin\/_temp_\/2020_03\/pic_1241_007.png\")
<\/p>\n
Bild 1: Zu kleines Textfeld für den Pfad zur Verweisdatei<\/span><\/b><\/p>\n Add-In zum Importieren von Verweisen<\/b><\/p>\n Deshalb haben wir ein Add-In entwickelt, das alle gängigen Verweise aus einem VBA-Projekt in ein anderes übertragen kann. Dieses sieht in Aktion wie in Bild 2 aus. Das Add-In zeigt zunächst nur die Verweise des VBA-Projekts der Datenbank an, für die das Add-In geöffnet wurde und in welche die Verweise aus einem anderen VBA-Projekt importiert werden sollen.<\/p>\n Bild 2: Das Add-In zum Importieren von Verweisen<\/span><\/b><\/p>\n Diese Verweise finden Sie in der rechten Liste unter Verweise der aktuellen Datenbank<\/b>. Wenn Sie mit dem Datei auswählen<\/b>-Dialog die Datenbankdatei ausgewählt haben, aus der die Verweise eingelesen werden sollen, zeigt das linke Listenfeld unter Verweise der gewählten Datenbank <\/b>alle Verweise der Quelldatenbank an.<\/p>\n Nun haben Sie verschiedene Möglichkeiten, die Verweise aus der linken Liste in die rechte Liste zu übertragen – und diese gleichzeitig zur aktuell geöffneten Datenbank hinzuzufügen:<\/p>\n Und Sie können auch noch Verweise aus der Zieldatenbank entfernen, indem Sie doppelt auf diese klicken.<\/p>\n Entwerfen des Formulars<\/b><\/p>\n Das Formular frmVerweiseImportieren<\/b> sieht in der Entwurfsansicht wie in Bild 3 aus. Das Textfeld zur Eingabe des Pfades der Quelldatenbank heißt txtImportVon<\/b>, die Schaltfläche zum Öffnen des Datei auswählen<\/b>-Dialogs heißt cmdDateiauswahl<\/b>. Die beiden Listenfelder nennen wir kurz lstQuelle <\/b>und lstZiel<\/b>. Die beiden Schaltflächen zum Übertragen eines oder aller Verweise heißen cmdHinzufuegen <\/b>und cmdAlleHinzufuegen<\/b>.<\/p>\n Bild 3: Entwurf des Formulars<\/span><\/b><\/p>\n Variablen vorbereiten<\/b><\/p>\n Im oberen Teil des Klassenmoduls des Formulars frmVerweiseImportieren <\/b>deklarieren wir einige modulweit verfügbare Variablen. Einige davon werden mit dem Typ VBIDE.VBProject <\/b>versehen. Um diese nutzen zu können, benötigen wir einen Verweis auf die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3 <\/b>(siehe Bild 4).<\/p>\n Bild 4: Verweis auf die Bibliothek zur Programmierung der VBIDE hinzufügen<\/span><\/b><\/p>\n Die Variablendeklarationen sehen wie folgt aus:<\/p>\n Die beiden Variablen zum Speichern der Verweise auf die VBA-Projekte von Add-In und Zieldatenbank deklarieren wir als Member-Variablen, weil wir diese später über Property Get<\/b>-Prozeduren füllen und bereitstellen.<\/p>\n Füllen des Listenfeldes mit den vorhandenen Verweisen<\/b><\/p>\n Beim Laden des Formulars wird die folgende Prozedur ausgelöst, die wiederum einige weitere Routinen ansteuert:<\/p>\n Referenzieren von AddIn- und Zieldatenbank<\/b><\/p>\n Wir greifen in den nachfolgend vorgestellten Prozeduren auf die VBA-Projekte der Add-In-Datenbank, der Datenbank, von der aus wir das Add-In starten und der Datenbank, aus der wir die Verweise importieren wollen, zu. Zwei davon referenzieren wir durch die folgenden Property Get<\/b>-Prozeduren, die sicherstellen, dass auch im Falle eines Fehlers immer eine Instanz geholt werden kann.<\/p>\n Die Prozeduren sehen wir folgt aus:<\/p>\n Die Variablen m_VBProjectZiel <\/b>und m_VBProjectAddIn <\/b>füllen wir mit der Funktion GetVBProject<\/b>, der wir den Pfad zu der Datenbankdatei übergeben, zu der das VBA-Projekt gehört (siehe Listing 1).<\/p>\n Listing 1: Referenzieren eines VBA-Projekts<\/span><\/b><\/p>\n Wenn Sie von einer Datenbankdatei aus einer Add-In-Datenbank öffnen, befinden sich im VBA-Editor bereits zwei VBA-Projekte (siehe Bild 5).<\/p>\n Bild 5: VBA-Projekte der geöffneten Datenbank und der Add-In-Datenbank<\/span><\/b><\/p>\n Um herauszufinden, welches VBA-Projekt zum Add-In gehört, durchläuft die Funktion in einer For Each<\/b>-Schleife alle VBProject<\/b>-Elemente, die aktuell im VBA-Editor verfügbar sind.<\/p>\n Dabei vergleicht sie jeweils den Dateinamen des VBA-Projekts, der mit dem Pfad der Datenbankdatei, den wir mit dem Parameter strPath <\/b>übergeben haben, übereinstimmen muss. Ist das in der For Each<\/b>-Schleife der Fall, verlassen wir diese. Das aktuell in objVBProject<\/b> befindliche VBA-Projekt wird dann als das zu der Datenbank aus strPath<\/b> gehörende VBA-Projekt zurückgegeben.<\/p>\n Auf diese Weise holen wir zwei Verweise auf das VBA-Projekt der Add-In-Datenbank und zu der Datenbank, von der aus das Add-In gestartet wurde und in welche die Verweise einer anderen Datenbank importiert werden sollen.<\/p>\n Für das Ermitteln des Verweises auf die Add-In-Datenbank übernehmen wir den Pfad der Datenbank, den wir mit dem Ausdruck CodeDb.Name <\/b>ermitteln.<\/p>\n Das VBA-Projekt der Datenbank, die das Add-In geöffnet hat, ermitteln wir durch die Übergabe des Pfades aus CurrentDb.Name <\/b>an die Funktion GetVBProject<\/b>.<\/p>\n Einlesen der aktuellen Verweise<\/b><\/p>\n Die Prozedur VerweiseEinlesen <\/b>liest Verweise des VBA-Projekts der mit dem ersten Parameter angegebenen VBA-Projekt ein und fügt diese zu dem mit dem zweiten Parameter angegebenen Listenfeld hinzu.<\/p>\n Hierzu müssen wir zunächst die Listenfelder vorbereiten. Diese werden nicht an Tabellen oder Abfragen gebunden, sondern sollen ihre Daten aus Wertlisten beziehen.<\/p>\n Daher stellen wir die Eigenschaft Herkunftstyp <\/b>für beide Listenfelder auf Wertliste <\/b>ein. Diese Wertlisten sollen in der ersten Spalte den Namen des Verweises anzeigen und in der zweiten und dritten Spalte die GUID und den Pfad zur referenzierten Bibliothek.<\/p>\n Deshalb stellen wir die Eigenschaft Spaltenanzahl <\/b>auf 3 <\/b>und Spaltenbreiten <\/b>auf ;0cm;0cm <\/b>ein – so wird die erste Spalte über die komplette Breite angezeigt und die zweite und die dritte Spalte werden ausgeblendet.<\/p>\n Die Prozedur VerweiseEinlesen <\/b>aus Listing 2 leert das mit dem Parameter lst <\/b>übergebene Listenfeld zunächst. Dann durchläuft es alle Verweise der Auflistung Reference <\/b>des VBA-Projekts aus objVBProject<\/b>, das wieder mit GetVBProject <\/b>ermittelt wird. <\/p>\n Listing 2: Einlesen der Verweise des VBA-Projekts einer Datenbank<\/span><\/b><\/p>\n Dann fügt sie der Variablen strEintrag <\/b>den Beschreibungstext aus der Eigenschaft Description <\/b>des Verweises hinzu – dies ist der Inhalt der ersten Spalte. Danach schalten wir die eingebaute Fehlerbehandlung aus, um strEintrag <\/b>um ein Semikolon und den Wert der Eigenschaft Guid <\/b>zu erweitern. Ist dieser leer, wird ein Fehler ausgelöst. In diesem Fall fügen wir einfach nur ein Semikolon zu strEintrag <\/b>hinzu – die zweite Spalte dieses Listenfeldeintrags bliebe also leer. Danach gehen wir auf die gleiche Weise vor, um den Inhalt der Eigenschaft FullPath <\/b>des Verweises zu strEintrag <\/b>hinzuzufügen.<\/p>\n Danach fügt die Prozedur den Inhalt von strEintrag <\/b>mit der Methode AddItem <\/b>des Listenfeldes als neue Zeile zum Listenfeld hinzu.<\/p>\n Damit haben wir nun das rechte Listenfeld gefüllt und der Zeitpunkt ist gekommen, wo der Benutzer die Datenbank auswählen soll, aus der Verweise importiert werden sollen.<\/p>\n Datenbank mit zu importierenden Verweisen auswählen<\/b><\/p>\n Die Schaltfläche cmdDateiauswahl <\/b>löst beim Anklicken die Prozedur aus Listing 3 aus. Diese merkt sich zunächst den Namen des VBA-Projekts der Add-In-Datenbank in der Variablen strAddInName<\/b>. Dann öffnet sie einen Datei auswählen<\/b>-Dialog, der nur Access-Datenbanken anzeigt. Die dazu notwendige Funktion OpenFileName <\/b>finden Sie im Modul mdlTools<\/b>. Das Ergebnis des OpenFileName<\/b>-Aufrufs nach der Auswahl durch den Benutzer landet im Textfeld txtImportVon<\/b>.<\/p>\n <\/p>\n Listing 3: Auswählen der Datenbank zum Importieren der Verweise<\/span><\/b><\/p>\n Nun wollen wir die Verweise des VBA-Projekts dieser Datenbank auslesen. Dazu binden wir das VBA-Projekt dieser Datenbank als Verweis in das VBA-Projekt der Add-In-Datenbank ein.<\/p>\n Das erledigen wir in der folgenden Anweisung, wo wir der References<\/b>-Auflistung des aktuellen VBA-Projekts aus objVBProjectAddIn<\/b>, also des Add-In-Projekts, einen Verweis auf die Datenbank zu, deren Verweise wir importieren wollen.<\/p>\n Tritt dabei ein Fehler auf, liegt es vermutlich daran, dass der Name des zu referenzierenden Projekts mit dem Namen des Add-In-VBA-Projekts übereinstimmt – was normalerweise nicht passieren sollte, außer die Datenbank heißt ebenfalls prjVerweiseImportieren wie das VBA-Projekt unseres Add-Ins. Der resultierende Fehler lautet Name steht in Konflikt mit vorhandenem Modul, Projekt oder vorhandener Objektbibliothek<\/b>.<\/p>\n In diesem Fall passen wir den Namen des VBA-Projekts aus objVBProjectAddIn <\/b>an, indem wir einen Unterstrich an den Projektnamen anhängen. Und nun wird auch klar, warum wir weiter oben den Projektnamen in der Variablen strAddInName <\/b>gespeichert haben – damit wir den Namen des VBA-Projekts nach Abschluss der Arbeit mit dem Add-In wieder in den vorherigen Zustand zurückversetzen können.<\/p>\n Im Projekt-Explorer im VBA-Editor finden Sie nun sogar gleich drei VBA-Projekte vor – das der aktuell geöffneten Datenbank, das für das Add-In und das der Datenbank, deren Verweise importiert werden sollen (siehe Bild 6).<\/p>\n Bild 6: Verweise auf drei VBA-Projekte gleichzeitig im VBA-Editor<\/span><\/b><\/p>\n Dann weisen wir der Variablen objVBProjectQuelle <\/b>das VBA-Projekt zu aus der Liste der aktuell verfügbaren VBA-Projekte zu, das den gleichen Dateinamen hat wie die Datei, die der Benutzer über den Datei auswählen<\/b>-Dialog selektiert hat.<\/p>\n Schließlich rufen wir noch die Prozedur VerweiseEinlesen <\/b>auf. Dabei geben wir mit dem ersten Parameter einen Verweis auf das VBA-Projekt mit den Verweisen und als zweiten Parameter den Verweis auf das linke Listenfeld an (lstQuelle<\/b>).<\/p>\n Danach zeigen nun beide Listenfelder die Verweise der jeweiligen Datenbanken an und wir können uns um die Programmierung für den Import oder für das Entfernen von Verweisen aus der aktuell geöffneten Datenbank kümmern.<\/p>\n Einzelnen Verweis importieren<\/b><\/p>\n Den Import eines einzelnen Verweises aus der Quelldatenbank erledigen Sie beispielsweise durch einen Klick auf die Schaltfläche cmdHinzufuegen<\/b>.<\/p>\n Dies löst die folgende Ereignisprozedur aus:<\/p>\n Hier rufen wir die Prozedur VerweisHinzufuegen <\/b>auf, der wir die Inhalte der drei Spalten des aktuell im Listenfeld markierten Eintrags übergeben – vorausgesetzt, der Wert des Listenfeldes ist zu diesem Zeitpunkt nicht Null, was bedeutet, dass kein Eintrag im Listenfeld markiert ist.<\/p>\n Die hier aufgerufene Prozedur VerweisHinzufuegen<\/b> finden Sie in Listing 4. Die Prozedur nimmt die übergebenen Werte aus dem Listeneintrag mit den beiden Parametern strGUID <\/b>und strPfad <\/b>entgegen. Sie verwendet zwei Variablen, um auf eine Auflistung der Referenzen des Zielprojekts sowie auf das neu erstellte Reference<\/b>-Objekt zu verweisen. Mit objReferences <\/b>referenziert die Prozedur die References<\/b>-Liste des Zielprojekts:<\/p>\n Listing 4: Hinzufügen eines Verweises<\/span><\/b><\/p>\n Dann prüft sie, ob strGUID <\/b>vorhanden ist. Falls ja, fügt sie die Bibliothek mit dieser GUID mit der Methode AddFromGUID<\/b> zu den Verweisen des Zielprojekts hinzu – allerdings bei deaktivierter Fehlerbehandlung:<\/p>\n Ist objReference <\/b>danach leer, war entweder keine GUID vorhanden oder der Verweis konnte damit nicht hinzugefügt werden. In diesem Fall prüfen wir, ob strPfad<\/b> einen Pfad liefert. Falls ja, versucht die Prozedur, den Verweis mit AddFromFile <\/b>hinzuzufügen:<\/p>\n Danach prüfen wir nochmal, ob objReference <\/b>mit einem Verweis gefüllt ist. Falls nicht, erscheint eine entsprechende Meldung:<\/p>\n Ist jedoch ein Verweis vorhanden, dann wird dieser noch als neuer Eintrag in das Listenfeld der Verweise der aktuellen Datenbank eingefügt. Dabei schreiben wir zunächst die Bezeichnung aus der Description<\/b>-Eigenschaft in die String-Variable strEintrag<\/b>:<\/p>\n Danach fügen wir, sofern diese Daten vorhanden sind, die Inhalt der Eigenschaften Guid <\/b>und FullPath <\/b>durch Semikola getrennt zum bereits vorhandenen Inhalt von strEintrag <\/b>hinzu:<\/p>\n Schließlich schreiben wir noch strEintrag <\/b>als neue Zeile in das Listelfeld lstZiel<\/b>:<\/p>\n Verweis per Doppelklick hinzufügen<\/b><\/p>\n Die zweite Möglichkeit, einen Verweis aus der Quelldatenbank zur Zieldatenbank hinzuzufügen, ist der Doppelklick auf einen der Einträge des Listenfeldes für die Verweise der Quelldatenbank. Dies löst die folgende Prozedur auf, die wiederum die Routine VerweisHinzufuegen <\/b>aufruft:<\/p>\n Alle nicht vorhandenen Verweise importieren<\/b><\/p>\n Der Anlass, diese Lösung zu programmieren, war eine korrupte Datenbank, die komplett neu aufgebaut werden musste. Eine neue Datenbank zu erstellen und alle Datenbankobjekte zu importieren ist schnell erledigt, aber dann die Verweise manuell neu hinzuzufügen kann je nach Anzahl der Verweise aufwendig sein.<\/p>\n Daher nun die Funktion, mit der Sie der Zielanwendung alle Verweise hinzufügen, die in der Quellanwendung enthalten sind, aber nicht in der Zielanwendung. Diese lösen wir mit der Schaltfläche cmdAlleHinzufuegen <\/b>aus, die wir wie folgt implementieren:<\/p>\n Die dadurch aufgerufene Prozedur ist sehr einfach aufgebaut, da Sie einfach alle Einträge des linken Listenfeldes durchläuft und für jeden Eintrag einmal die Prozedur VerweisHinzufuegen <\/b>aufruft:<\/p>\n Dabei durchlaufen wir eine For…Next<\/b>-Schleife mit der Laufvariablen i <\/b>über den Index 0 <\/b>bis zur Anzahl der Listenelemente minus 1, da der Index 0-basiert ist.<\/p>\n Für den Zugriff auf die Zeilen\/Spalten im Listenfeld verwenden wir als ersten Parameter der Column<\/b>-Eigenschaft die Spalte und mit dem zweiten die Zeile. Damit rufen wir dann die Prozedur VerweisHinzufuegen <\/b>auf, die wir ja bereits weiter oben beschrieben haben.<\/p>\n Kleiner Haken dabei: Es wird für jedes Element, das nicht hinzugefügt werden kann, eine Meldung ausgegeben – auch für solche Elemente, die bereits in der Zieldatenbank enthalten sind, was regelmäßig der Fall ist, da es einige eingebaute Verweise gibt, die immer vorhanden sind. Und es kann ja auch sein, dass Sie einen nicht eingebauten Verweis bereits zum Zielprojekt hinzugefügt haben.<\/p>\n Also verwenden wir eine Funktion, die prüft, ob ein bestimmter Verweis bereits in der Liste der Verweise des angegebenen VBA-Projekts enthalten ist (siehe Listing 5). Dieser Funktion übergeben wir einen Verweis auf das zu untersuchende VBA-Projekt sowie die GUID und den Pfad zur Bibliotheksdatei. Dann durchlaufen wir in einer For Each<\/b>-Schleife alle Verweise und prüfen, ob dieser Verweis entweder die übergebene GUID oder den übergebenen Pfad aufweist.<\/p>\n Listing 5: Prüfen, ob ein Verweis bereits vorhanden ist<\/span><\/b><\/p>\n Falls wir einen passenden Verweis gefunden haben, verlassen wir die Funktion und geben den Wert True <\/b>als Funktionswert zurück. Damit statten wir nun noch die Prozedur VerweisHinzufuegen <\/b>aus:<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2020_03\/pic_1241_006.png\")
<\/p>\n\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2020_03\/pic_1241_008.png\")
<\/p>\n![\"Verweis](\"..\/fileadmin\/_temp_\/2020_03\/pic_1241_009.png\")
<\/p>\nDim <\/span>strAddInName As String<\/span>\r\nPrivate <\/span>m_VBProjectAddIn As <\/span>VBIDE.VBProject\r\nPrivate <\/span>m_VBProjectZiel As <\/span>VBIDE.VBProject\r\nDim <\/span>objVBProjectQuelle As <\/span>VBIDE.VBProject<\/pre>\n<b>Private Sub Form_Load()\r\n<b> VerweiseEinlesen objVBProjectZiel, Me!lstZiel\r\n<b>End Sub<\/b><\/pre>\n
Public Property Get <\/span>VBProjectZiel() As <\/span>VBIDE.VBProject\r\n If <\/span>m_VBProjectZiel Is Nothing Then<\/span>\r\n Set<\/span> m_VBProjectZiel = GetVBProject(CurrentDb.Name)\r\n End If<\/span>\r\n Set<\/span> VBProjectZiel = m_VBProjectZiel\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>VBProjectAddIn() As <\/span>VBIDE.VBProject\r\n If <\/span>m_VBProjectAddIn Is Nothing Then<\/span>\r\n Set<\/span> m_VBProjectAddIn = GetVBProject(CodeDb.Name)\r\n End If<\/span>\r\n Set<\/span> VBProjectAddIn = m_VBProjectAddIn\r\nEnd Property<\/span><\/pre>\nPrivate Function <\/span>GetVBProject(strPath As String<\/span>) As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n For Each objVBProject In VBE.VBProjects\r\n If <\/span>objVBProject.FileName = strPath Then<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> objVBProject\r\n Set<\/span> GetVBProject = objVBProject\r\nEnd Function<\/span><\/pre>\n![\"VBA-Projekte](\"..\/fileadmin\/_temp_\/2020_03\/pic_1241_010.png\")
<\/p>\nPrivate Sub <\/span>VerweiseEinlesen(objVBProject As <\/span>VBIDE.VBProject, lst As <\/span>ListBox)\r\n Dim <\/span>objReference As <\/span>VBIDE.Reference\r\n Dim <\/span>strEintrag As String<\/span>\r\n lst.RowSource = \"\"\r\n For Each objReference In objVBProject.References\r\n strEintrag = objReference.Description\r\n On Error Resume Next<\/span>\r\n strEintrag = strEintrag & \";\" & objReference.Guid\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n strEintrag = strEintrag & \";\"\r\n End If<\/span>\r\n Err.Clear\r\n strEintrag = strEintrag & \";\" & objReference.FullPath\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n strEintrag = strEintrag & \";\"\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n lst.AddItem strEintrag\r\n Next<\/span> objReference\r\nEnd Sub<\/span><\/pre>\nPrivate Sub cmdDateiauswahl_Click()\r\n strAddInName = VBProjectAddIn.Name\r\n Me!txtImportVon = OpenFileName(CurrentProject.Path, \"Datenbank mit zu importierenden Verweisen wählen\", _\r\n\"Access-DB (*.mdb,*.accdb,*.mda,*.accda)|Alle DAteien (*.*)\")\r\n On Error Resume Next<\/span>\r\n VBProjectAddIn.References.AddFromFile Me!txtImportVon\r\n If Not<\/span> Err.Number = 0 Then\r\n VBProjectAddIn.Name = strAddInName & \"_\"\r\n VBProjectAddIn.References.AddFromFile Me!txtImportVon\r\n End If\r\nOn Error GoTo<\/span> 0\r\nSet<\/span> objVBProjectQuelle = GetVBProject(Me!txtImportVon)\r\n VerweiseEinlesen objVBProjectQuelle, Me!lstQuelle\r\nEnd Sub<\/pre>\n![\"Verweise](\"..\/fileadmin\/_temp_\/2020_03\/pic_1241_012.png\")
<\/p>\nPrivate Sub cmdHinzufuegen_Click()\r\n If Not<\/span> IsNull(Me!lstQuelle) Then\r\n VerweisHinzufuegen Me!lstQuelle.Column(0), Me!lstQuelle.Column(1), Me!lstQuelle.Column(2)\r\n End If\r\nEnd Sub<\/pre>\nPrivate Sub VerweisHinzufuegen(strBezeichnung As String<\/span>, strGUID As String<\/span>, strPfad As String<\/span>)\r\n Dim objReferences As <\/span>VBIDE.References\r\n Dim objReference As <\/span>VBIDE.Reference\r\n Dim strEintrag As String<\/span>\r\n Set<\/span> objReferences = VBProjectZiel.References\r\n If Len<\/span>(strGUID) > 0 Then\r\n On Error Resume Next<\/span>\r\n Set<\/span> objReference = objReferences.AddFromGuid(strGUID, 0, 0)\r\n End If\r\n If objReference Is Nothing Then\r\n If Len<\/span>(strPfad) > 0 Then\r\n On Error Resume Next<\/span>\r\n Set<\/span> objReference = objReferences.AddFromFile(strPfad)\r\n End If\r\n End If\r\nOn Error GoTo<\/span> 0\r\n If objReference Is Nothing Then\r\n MsgBox<\/span> \"Der Verweis '\" & strBezeichnung & \"' konnte nicht hinzugefügt werden.\", vbOKOnly + vbCr<\/span>itical, _\r\n \"Verweis nicht hinzugefügt\"\r\n Else\r\n strEintrag = objReference.Description\r\n On Error Resume Next<\/span>\r\n strEintrag = strEintrag & \";\" & objReference.Guid\r\n If Not<\/span> Err.Number = 0 Then\r\n strEintrag = strEintrag & \";\"\r\n End If\r\n Err.Clear\r\n strEintrag = strEintrag & \";\" & objReference.FullPath\r\n If Not<\/span> Err.Number = 0 Then\r\n strEintrag = strEintrag & \";\"\r\n End If\r\n On Error GoTo<\/span> 0\r\n Me!lstZiel.AddItem strEintrag\r\n End If\r\nEnd Sub<\/pre>\n Dim objReferences As <\/span>VBIDE.References\r\n Dim objReference As <\/span>VBIDE.Reference\r\n Dim strEintrag As String<\/span>\r\n Set<\/span> objReferences = VBProjectZiel.References<\/b><\/pre>\n If <\/span>Len<\/span>(strGUID) > 0 Then<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> objReference = objReferences.AddFromGuid(strGUID, 0, 0)\r\n End If<\/span><\/pre>\n If <\/span>objReference Is Nothing Then<\/span>\r\n If <\/span>Len<\/span>(strPfad) > 0 Then<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> objReference = objReferences.AddFromFile(strPfad)\r\n End If<\/span>\r\n End If<\/span><\/pre>\n On Error GoTo<\/span> 0\r\n If <\/span>objReference Is Nothing Then<\/span>\r\n MsgBox<\/span> \"Der Verweis '\" & strBezeichnung _\r\n & \"' konnte nicht hinzugefügt werden.\", _\r\n vbOKOnly + vbCr<\/span>itical, _\r\n \"Verweis nicht hinzugefügt\"<\/pre>\n Else<\/span>\r\n strEintrag = objReference.Description<\/pre>\n On Error Resume Next<\/span>\r\n strEintrag = strEintrag & \";\" & objReference.Guid\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n strEintrag = strEintrag & \";\"\r\n End If<\/span>\r\n Err.Clear\r\n strEintrag = strEintrag & \";\" & objReference.FullPath\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n strEintrag = strEintrag & \";\"\r\n End If<\/span>\r\n On Error GoTo<\/span> 0<\/pre>\n Me!lstZiel.AddItem strEintrag\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>lstQuelle_DblClick(Cancel As Integer<\/span>)\r\n If <\/span>Not<\/span> IsNull(Me!lstQuelle) Then<\/span>\r\n VerweisHinzufuegen Me!lstQuelle.Column(0), Me!lstQuelle.Column(1), Me!lstQuelle.Column(2)\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdAlleHinzufuegen_Click()\r\n AlleVerweiseHinzufuegen\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>AlleVerweiseHinzufuegen()\r\n Dim <\/span>i As Integer<\/span>\r\n For i = 0 To Me!lstQuelle.ListCount - 1\r\n VerweisHinzufuegen Me!lstQuelle.Column(0), Me!lstQuelle.Column(1, i), Me!lstQuelle.Column(2, i)\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n<b>Public Function VerweisVorhanden(objVBProject As <\/span>VBIDE.VBProject, strGUID As String<\/span>, strFullPath As String<\/span>) As Boolean<\/span>\r\n<b> Dim objReferences As <\/span>VBIDE.References\r\n<b> Dim objReference As <\/span>VBIDE.Reference\r\n<b> Set<\/span> objReferences = objVBProject.References\r\n<b> For Each objReference In objReferences\r\n<b> If objReference.Guid = strGUID Or objReference.FullPath = strFullPath Then\r\n<b> VerweisVorhanden = True<\/span>\r\n<b> Exit Function<\/span>\r\n<b> End If\r\n<b> Next<\/span> objReference\r\n<b>End Function<\/b><\/pre>\nPrivate Sub <\/span>VerweisHinzufuegen(...)\r\n ...\r\n If <\/span>Not<\/span> VerweisVorhanden(VBProjectZiel, strGUID, strFullPath)