<\/p>\n
Es kommt vor, dass man als Access-Entwickler mit der Weiterbearbeitung von Datenbanken betraut wird. Oft geschieht es dann, dass Objekt- und Feldnamen nicht den gängigen Konventionen entsprechen. Tabellennamen kommen ohne Präfix, Objekt- und Feldnamen enthalten Umlaute, Leerzeichen et cetera. Um dadurch entstehende Probleme zu vermeiden, können wir die Benennungen anpassen. Wie dies gelingt, zeigt der vorliegende Beitrag.<\/b><\/p>\n
Die Tabelle und die Feldnamen des Beispiels aus Bild 1 hat jeder schon einmal gesehen. Die Tabelle wurde ohne Präfix benannt, hier würden wir uns ein führendes tbl <\/b>wünschen. Das Primärschlüsselfeld hätten wir lieber ohne Unterstrich (wobei das Geschmackssache ist). Definitiv sollten wir aber Straße in Strasse ändern und im Feld Telefon geschäftlich <\/b>wollen wir nicht nur den Umlaut durch die entsprechenden Vokale ersetzen und das Leerzeichen weglassen. Außerdem verwenden wir in der Regel Camel Case und schreiben das zweite und die folgenden Worte groß, hier also TelefonGeschaeftlich<\/b>.<\/p>\n
![\"Tabellenname](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_001.png\")
<\/p>\n
Bild 1: Tabellenname und Feldnamen sollten refaktoriert werden.<\/span><\/b><\/p>\n Das Ergebnis soll in unserem Fall also wie in Bild 2 aussehen.<\/p>\n Bild 2: Tabelle mit Präfix im Namen und mit angepassten Feldnamen<\/span><\/b><\/p>\n In unserem Beispiel ist es leicht, die zu ändernden Elemente zu finden. Bei einer Tabelle mit wenigen Feldern erledigt man den Job auch am einfachsten von Hand. Das bezieht sich allerdings nur auf die reine änderung der Objekt- und Feldbezeichnungen – es gibt ja auch Referenzen auf diese Bezeichnungen in anderen Tabellen, Abfragen, Formularen, Berichten, Makros und auch im VBA-Code. Und wenn Sie aber eine große Datenbankanwendung mit vielen Tabellen anpassen wollen, haben Sie noch mehr zu tun. Es ist also eine Frage der Datenbankgröße, wann Sie es aufgeben, die änderungen manuell zu erledigen und der Wunsch auftaucht, die änderungen automatisch auszuführen. Wie das gelingt, soll der vorliegende Beitrag zeigen. Vorher schauen wir uns aber noch an, welche änderungen im Detail anfallen und wo diese sich überall auswirken.<\/p>\n Die Namen von Tabellen und Feldnamen können bereits in anderen Tabellen auftauchen – nämlich dort, wo Sie Nachschlagefelder eingerichtet haben. Wenn wir unserer Anwendung also eine Tabelle namens Anreden m\/w <\/b>mit den Feldern Anrede-ID <\/b>und Anrede <\/b>finden, kann es sein, dass ein Fremdschlüsselfeld namens Anrede-ID <\/b>in der Kunden-Tabelle vorliegt, welches die Anreden-Tabelle referenziert – das sieht dann im Entwurf wie in Bild 3 aus. Wenn wir nun auch die Bezeichnungen der verknüpften Tabelle ändern, dann müssen wir darauf achten, dass auch die Verweise angepasst werden. Zum Glück unterstützt uns Access hier – wie, schauen wir uns weiter unten an.<\/p>\n Bild 3: Verweis auf andere Tabelle im Tabellenentwurf<\/span><\/b><\/p>\n Aber auch in Abfragen, Formularen und Berichten sowie in Makros finden wir unter Umständen Verweise auf die Namen von Objekten und Feldern. Ob diese automatisch angepasst werden, schauen wir uns ebenfalls an.<\/p>\n Auf keinen Fall erfolgt eine automatische Anpassung im VBA-Code. Hier müssen wir selbst Hand anlegen. Damit wir hier keine änderung auslassen, werden wir später ein wenig Code produzieren, der diese Aufgabe für uns übernimmt.<\/p>\n Access hat schon viele Versionen eine Funktion namens Objektnamen-Autokorrektur. Diese sorgt dafür, dass änderungen von Objekt- und Feldnamen direkt an Stellen übernommen werden, welche die betroffenen Objekte und Felder referenzieren.<\/p>\n Die Einstellungen für die Objektnamen-Autokorrektur nehmen Sie in den Access-Optionen vor. Dort finden Sie diese unter Aktuelle Datenbank im Bereich Optionen für die Objektnamen-Autokorrektur <\/b>(siehe Bild 4). Wir aktivieren hier zusätzlich noch die Option änderungen für Objektnamenautokorrektur protokollieren<\/b>.<\/p>\n Bild 4: Einstellungen für die Objektnamen-Autokorrektur<\/span><\/b><\/p>\n Zu Testzwecken enthält die Beispieldatenbank einige Objekte, die auf die Tabelle und die enthaltenen Felder verweisen. Auf diese Weise können wir nach der änderung prüfen, ob die änderungen auch auf die referenzierenden Objekte übertragen wurden.<\/p>\n Wir verwenden dazu ein Formular namens frmKunden<\/b>, das nur Daten der Tabelle Kunden <\/b>anzeigt, ein Formular namens frmKundenMitAnreden<\/b>, welches eine Abfrage mit den Daten aus den beiden Tabellen als Datenherkunft verwendet und ein Formular mit Unterformular, welches die Anreden im Hauptformular und die zugeordneten Kunden im Unterformular anzeigt.<\/p>\n Eine Abfrage namens qryKundenNachAnrede <\/b>fasst die Daten der beiden Tabellen Kunden und Anreden zusammen.<\/p>\n Auf Makros wollen wir an dieser Stelle verzichten.<\/p>\n Außerdem schreiben wir ein paar VBA-Prozeduren, welche auf die Daten der Tabellen Kunden <\/b>und Anreden <\/b>zugreifen.<\/p>\n Bevor wir die Tabellen- und Feldnamen angepasst haben, haben wir die vorherige Version der Datenbank gesichert, und zwar unter dem Namen FeldnamenRefaktorieren_Backup.accdb<\/b>.<\/p>\n Danach nehmen wir folgende änderungen vor:<\/p>\n Nachdem die änderungen an den Tabellen Kunden <\/b>und Anreden <\/b>durchgeführt wurden, sehen diese wie in Bild 5 aus. Durch die änderungen an der Tabelle Anreden<\/b>, die nun tblAnreden <\/b>heißt, müssten auch Anpassungen am Fremdschlüsselfeld AnredeID <\/b>der Tabelle tblKunden <\/b>vorgenommen worden sein.<\/p>\n Bild 5: Die Tabellen nach der änderung<\/span><\/b><\/p>\n Nach der änderung schauen wir uns den Entwurf der Tabelle tblKunden <\/b>an und wechseln dort für das Feld AnredeID <\/b>zur Registerseite Nachschlagen <\/b>der Feldeigenschaften. Hier finden wir die korrekt geänderte Abfrage vor (siehe Bild 6).<\/p>\n Bild 6: Fremdschlüsselfeld nach der änderung der verknüpften Tabelle<\/span><\/b><\/p>\n Wenn wir nun statt einer einfachen SELECT<\/b>-Anweisung einen komplizierteren, von Hand geänderten Ausdruck für die Abfrage in der Eigenschaft Datensatzherkunft <\/b>nutzen, funktioniert die Objektnamen-Autokorrektur in unseren Tests immer noch. Wenn Sie zum Beispiel einfach zwei Felder verknüpfen wie im folgenden Beispiel, wird die Abfrage ebenfalls ordnungsgemäß angepasst:<\/p>\n Da wir die Option änderungen für Objektnamenautokorrektur protokollieren aktiviert haben, erstellt Access nun eine neue Tabelle namens Objektnamen-Autokorrekturprotokoll, in der es die einzelnen durch die änderung verursachten änderungen einträgt. Genaugenommen muss man es etwas anders formulieren: Die automatischen änderungen werden nämlich nicht schon in die Tabelle eingetragen, sobald der Programmierer die auslösenden änderungen vornimmt, sondern erst, wenn die von den automatischen änderungen betroffenen Objekte erstmals nach der änderung geöffnet werden.<\/p>\n Access prüft also wohl erst beim öffnen der Objekte, ob es änderungen in den zugrunde liegenden Objekten gibt und nimmt dann die Autokorrektur vor. Dies ist auch der Grund, warum man bei Datenbanken, deren Performance nicht überzeugt, als eine der ersten Aktionen die Autokorrektur abschaltet.<\/p>\n Die Tabelle Objektnamen-Autokorrekturprotokoll <\/b>sieht schließlich wie in Bild 8 aus.<\/p>\n Bild 7: änderungen durch die Objektnamen-Autokorrektur<\/span><\/b><\/p>\n Sie enthält bereits Einträge, die durch die nachfolgend beschriebenen änderungen verursacht wurden.<\/p>\n Dann gehen wir weiter zur Abfrage qryKundenMitAnrede<\/b>. Diese sah zuvor wie in Bild 7 aus.<\/p>\n Bild 8: Die Abfrage qryKundenMitAnrede vor den änderungen<\/span><\/b><\/p>\n Nachdem wir sie nach den änderungen erneut geöffnet haben, finden wir dort ebenfalls die korrigierten Tabellen- und Feldnamen vor (siehe Bild 9).<\/p>\n Bild 9: Die Abfrage qryKundenMitAnrede nach den änderungen<\/span><\/b><\/p>\n <\/p>\n Auch die drei vorbereiten Formulare wollen wir uns anschauen. Beim ersten Formular namens frmKunden<\/b> hat dies gut geklappt. Wie Bild 10 zeigt, wurde nicht nur die als Datenherkunft verwendet Tabelle von Kunden <\/b>in tblKunden <\/b>geändert, sondern auch die Namen der von den Steuerelementen referenzierten Felder.<\/p>\n Bild 10: Formular mit geänderten Steuerelementinhalten und Quelltabelle<\/span><\/b><\/p>\n Das zweite Formular namens frmKundenMitAnrede<\/b>, das Sie in Bild 11 sehen, wurde wie gewünscht angepasst. Es bezieht seine Daten ja aus einer Abfrage, welche die Daten der beiden Tabellen tblKunden <\/b>und tblAnreden <\/b>zusammenfasst. Das dritte Formular frmKundenNachAnrede <\/b>hatte die Besonderheit, dass wir die Daten der Kunden<\/b>-Tabelle zu einer im Hauptformular ausgewählten Anrede in einem Unterformular anzeigen.<\/p>\n Bild 11: Auch mit einer Abfrage als Datenherkunft gelingt die Autokorrektur.<\/span><\/b><\/p>\n Hier haben wir nach der änderung der Tabellen- und Feldnamen also besonderes Augenmerk auf die beiden Eigenschaften Verknüpfen von <\/b>und Verknüpfen nach <\/b>des Unterformular-Steuerelements gelegt. Aber auch hier hat die Objektnamen-Autokorrektur wie erwartet gearbeitet (siehe Bild 12). An dieser Stelle gehen wir davon aus, dass die Objektnamen-Autokorrektur auch in Berichten und Makros funktioniert und wenden uns dem VBA-Code zu.<\/p>\n Bild 12: Sogar die Einstellung der Verknüpfungsfelder für das Unterformular erfolgt korrekt.<\/span><\/b><\/p>\n Eine Stelle, die definitiv nicht von der Objektnamen-Autokorrektur erfasst wird, ist der VBA-Code. Die von uns vorbereitete Testprozedur, welche die Kunden-Tabelle unter dem alten Namen referenziert und auch die alten Feldnamen verwendet, löst nach dem ändern von Objekt- und Feldnamen einen Fehler aus, weil die Tabelle nicht mehr gefunden werden konnte (siehe Bild 13). Selbst wenn der Tabellenname korrekt wäre, würde die übernächste Zeile beim Zugriff auf die alten Feldnamen eine Fehlermeldung liefern.<\/p>\n Bild 13: VBA-Code wird nicht automatisch korrigiert.<\/span><\/b><\/p>\n Was tun Es gibt drei Möglichkeiten:<\/p>\n Die erste Option fällt flach – außer, Sie haben nur extrem wenig Code in der Datenbank.<\/p>\n Die zweite Option ist möglich, aber je nach der Anzahl der zu ändernden Objektnamen und Feldnamen auch aufwendig.<\/p>\n Die dritte Option ist natürlich die Lieblingsoption des versierten VBA-Entwicklers, denn hier kann er selbst programmieren und muss keine niederen Arbeiten verrichten. Außerdem trainieren wir das Gehirn damit viel mehr als mit manuellem Suchen und Ersetzen!<\/p>\n Wir schauen uns also die zweite und die dritte Option an.<\/p>\n Bevor Sie eine der beiden verbleibenden Methoden nutzen, sollten Sie eine Liste der änderungen an den Objektnamen und Feldnamen anlegen, damit Sie später keine änderung im Code vergessen.<\/p>\n Diese Variante starten Sie im VBA-Editor über den Menü-Eintrag Bearbeiten|Ersetzen… <\/b>oder über die Tastenkombination Strg + H<\/b>. Letztere hat aber, wenn Sie das Tool MZ-Tools <\/b>nutzen, eine andere Funktion; Sie müssen dann den Menüeintrag bemühen. Der Dialog sieht wie in Bild 14 aus und bietet zunächst einmal zwei Felder, in die Sie den gesuchten Ausdruck und den ersetzenden Ausdruck eingeben müssen.<\/p>\n Bild 14: Suchen und Ersetzen per Dialog<\/span><\/b><\/p>\n Die Optionsgruppe Suchen in <\/b>legt den Bereich fest, in dem Sie suchen und ersetzen möchten. Hier wählen wir logischerweise das aktuelle Projekt aus.<\/p>\n Die Werte für die Suchrichtung und die beiden Optionen Nur ganzes Wort suchen <\/b>und Groß-\/Kleinschreibung beachten <\/b>lassen wir deaktiviert. Die Option Mit Mustervergleich <\/b>ist jedoch interessant. Warum, das erfahren Sie gleich.<\/p>\n Geben wir einmal den Tabellennamen Kunden <\/b>in das Feld Suchen nach: <\/b>des Dialogs ein und den neuen Namen tblKunden <\/b>in das Feld Ersetzen durch:<\/b>, führt das nicht ganz zum gewünschten Ergebnis: Auf diese Weise werden nämlich auch die Vorkommen der Zeichenkette Kunden <\/b>gefunden, die nicht ersetzt werden sollen und in einem anderen Zusammenhang verwendet werden – beispielsweise der Name der Objektvariablen rstKunden<\/b> (siehe Bild 15).<\/p>\n Bild 15: Beim Suchen und Ersetzen ist Vorsicht geboten.<\/span><\/b><\/p>\n Hier könnte man nun prüfen, in welchen Kontexten die Zeichenfolge Kunden <\/b>wirklich ersetzt werden soll. In unserem Fall wird der Tabellenname nur innerhalb eines SQL-Ausdrucks verwendet, aber es gibt noch andere Möglichkeiten. Die gleiche Anweisung könnte etwa nur den Namen der Tabelle Kunden <\/b>enthalten, wenn keine WHERE<\/b>-Klausel oder andere Einschränkungen benötigt werden:<\/p>\n Wir müssten also zumindest nach Vorkommen suchen, die auf ein Leerzeichen folgen oder auf ein Anführungszeichen. Das bedeutet, dass wir den Suchen und Ersetzen<\/b>-Dialog bereits zwei Mal füllen und ausführen müssten.<\/p>\n Wenn wir allerdings die Option Mit Mustervergleich <\/b>aktivieren, sollten wir theoretisch ein paar Schritte. Wir können dann nämlich festlegen, für welche Kombinationen aus führenden und folgenden Zeichen die Zeichenkette Kunden <\/b>durch tblKunden <\/b>ersetzt werden soll.<\/p>\n Im vorliegenden Fall wollen wir alle Vorkommen finden, denen ein Leerzeichen oder ein Anführungszeichen vorangeht und die mit einem Anführungszeichen abgeschlossen werden. Das gelingt mit dem Ausdruck aus Bild 16:<\/p>\n Bild 16: Suchen und Ersetzen mit Mustervergleich.<\/span><\/b><\/p>\n Nun kann es auch noch sein, dass hinter dem Tabellennamen noch ein Leerzeichen folgt, weil sich dahinter eine WHERE<\/b>-Klausel befindet. Kein Problem: Dann fügen wir noch das Leerzeichen in das hintere eckige Klammernpaar ein.<\/p>\n Dummerweise können wir aber nicht wie bei normalen regulären Ausdrücken die zu durchsuchende Information in Klammern fassen und diese später durch die gewünschten Informationen ersetzen. Damit fällt das Suchen und Ersetzen mit Mustervergleich leider aus und wir müssen Schritt für Schritt die verschiedenen Möglichkeiten durchlaufen.<\/p>\n In diesem Fall würden wir also etwa nach Ausdrücken suchen, die ein führendes Leerzeichen, den Ausdruck Kunden <\/b>und ein Anführungszeichen enthalten und diese durch ein Leerzeichen, den Tabellennamen tblKunden <\/b>und das Anführungszeichen ersetzen (siehe Bild 17).<\/p>\n Bild 17: Suchen und Ersetzen eines Tabellennamens<\/span><\/b><\/p>\n Allerdings können wir durchaus die Suche mit Mustervergleich nutzen, um alle möglichen Konstellationen zu finden. Dazu geben wir dann etwa den folgenden Suchausdruck an:<\/p>\n Wenn Sie alle möglichen zu ersetzenden Elemente identifiziert haben, können Sie das Suchen und Ersetzen auch per VBA durchführen.<\/p>\n Dazu benötigen Sie zunächst einen Verweis auf die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3<\/b>. Diese legen Sie an, indem Sie im VBA-Editor mit dem Menübefehl Extras|Verweise <\/b>den Verweise<\/b>-Dialog öffnen und hier die angegebene Bibliothek suchen und anhaken (siehe Bild 18).<\/p>\n Bild 18: Hinzufügen eines Verweises auf die Visual Basic-Erweiterungsbibliothek<\/span><\/b><\/p>\n Wenn wir nach einem Objektnamen suchen und diesen ersetzen wollen, müssten wir uns zunächst überlegen, wie das Biotop eines solchen Objektnamens in VBA-Code aussieht<\/p>\n Dabei ist vor allem wichtig, dass wir einen Objektnamen wie den Tabellennamen Kunden <\/b>von den Vorkommen der gleichen Zeichenkette innerhalb anderer Zeichenketten unterscheiden – wie etwa in rstKunden<\/b>.<\/p>\n Um es kurz zu machen: Wenn die gesuchte Zeichenkette für den Objektnamen keinen Buchstaben und keine Ziffer als führendes oder folgendes Zeichen aufweist, können wir davon ausgehen, dass es sich um einen Objektnamen handelt. Dabei gehen wir davon aus, dass die Variablen und Konstanten im Code mit entsprechenden Präfixen versehen sind – ansonsten wird es kompliziert.<\/p>\n Nachdem die Anforderung definiert ist, können Sie eine Funktion wie die aus Listing 1 anlegen. Diese durchläuft alle Elemente der Auflistung VBComponents <\/b>des aktuellen VBA-Projekts, was den Klassenmodulen und Standardmodulen entspricht, in einer For Each<\/b>-Schleife und speichert das aktuelle Element jeweils in der Laufvariablen objVBComponent<\/b>.<\/p>\n Listing 1: Die Funktion zum Suchen und Ersetzen von Objektnamen im VBA-Code<\/span><\/b><\/p>\n Die Ausnahme ist das Modul mdlSuchenErsetzen<\/b>, welches die Funktionen zum Suchen und Ersetzen selbst enthält. Dann stellen wir die Objektvariable objCodeModule <\/b>mit dem Typ CodeModule <\/b>auf das CodeModule<\/b>-Objekt von objVBComponent <\/b>ein.<\/p>\n Hier geschehen nun einige Operationen:<\/p>\n Neben den Objektnamen wollen wir uns auch um die Feldnamen kümmern, die wir geändert haben – also beispielsweise die Umbenennung von Kunde-ID <\/b>in KundeID<\/b>.<\/p>\n Dazu müssen identifizieren, in welcher Form Feldnamen im Code vorkommen.<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_002.png\")
<\/p>\nNotwendige änderungen finden<\/h2>\n
Referenzen auf Objektnamen und Feldnamen<\/h2>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_003.png\")
<\/p>\nDie Objektnamen-Autokorrektur<\/h2>\n
![\"Einstellungen](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_004.png\")
<\/p>\n\n
![\"Die](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_008.png\")
<\/p>\n![\"Fremdschlüsselfeld](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_009.png\")
<\/p>\nKomplexere Ausdrücke<\/h2>\n
SELECT [Anreden].[Anrede-ID], [Anreden].[Anrede m\/w] & Anreden.[Anrede-ID] FROM Anreden;<\/pre>\n
Die Tabelle Objektnamen-Autokorrekturprotokoll<\/h2>\n
![\"änderungen](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_010.png\")
<\/p>\nAbfragen<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_005.png\")
<\/p>\n<\/p>\nFormulare<\/h2>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_011.png\")
<\/p>\n![\"Auch](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_012.png\")
<\/p>\n![\"Sogar](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_013.png\")
<\/p>\nRefactoring im VBA-Code<\/h2>\n
![\"VBA-Code](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_014.png\")
<\/p>\n\n
änderungen notieren<\/h2>\n
Suchen und Ersetzen<\/h2>\n
![\"Suchen](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_015.png\")
<\/p>\nKunden-Tabelle im VBA-Code suchen und ersetzen<\/h2>\n
![\"Beim](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_016.png\")
<\/p>\nSet<\/span> rstKunden = db.OpenRecordset(\"Kunden\", dbOpenDynaset)<\/pre>\n![\"Suchen](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_017.png\")
<\/p>\n[\" ]Kunden[\"]<\/pre>\n
![\"Suchen](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_018.png\")
<\/p>\n[!a-zA-Z0-9]Kunden[!a-zA-Z0-9]<\/pre>\n
Suchen und ersetzen per VBA<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2018_03\/pic_1133_019.png\")
<\/p>\nSuchen nach Objektnamen<\/h2>\n
Public Sub <\/span>SuchenErsetzen(strSuchen As String<\/span>, strErsetzen As String<\/span>)\r\n Dim <\/span>objVBComponent As <\/span>VBComponent\r\n Dim <\/span>objCodeModule As <\/span>CodeModule\r\n Dim <\/span>strCode As String<\/span>\r\n Dim <\/span>lngStart As String<\/span>\r\n Dim <\/span>lngEnde As String<\/span>\r\n Dim <\/span>strVorher As String<\/span>\r\n Dim <\/span>strNachher As String<\/span>\r\n For Each objVBComponent In VBE.ActiveVBProject.VBComponents\r\n If <\/span>Not<\/span> objVBComponent.Name = \"mdlSuchenErsetzen\" Then<\/span>\r\n Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n strCode = objCodeModule.Lines(1, objCodeModule.CountOfLines)\r\n lngStart = InStr<\/span>(1, strCode, strSuchen)\r\n Do While<\/span> Not<\/span> lngStart = 0\r\n lngEnde = lngStart + Len<\/span>(strSuchen)\r\n strVorher = Mid<\/span>(strCode, lngStart - 1, 1)\r\n If <\/span>Not<\/span> strVorher Like \"[a-zA-Z0-9]\" Then<\/span>\r\n strNachher = Mid<\/span>(strCode, lngStart + Len<\/span>(strSuchen), 1)\r\n If <\/span>Not<\/span> strNachher Like \"[a-zA-Z0-9]\" Then<\/span>\r\n strCode = Left<\/span>(strCode, lngStart - 1) & strErsetzen & Mid<\/span>(strCode, lngEnde)\r\n lngEnde = lngEnde - Len<\/span>(strSuchen) + Len<\/span>(strErsetzen)\r\n End If<\/span>\r\n End If<\/span>\r\n lngStart = InStr<\/span>(lngEnde, strCode, strSuchen)\r\n Loop<\/span>\r\n objCodeModule.DeleteLines 1, objCodeModule.CountOfLines\r\n objCodeModule.AddFromString strCode\r\n End If<\/span>\r\n Next<\/span> objVBComponent\r\nEnd Sub<\/span><\/pre>\n\n
Suchen nach Feldnamen<\/h2>\n