<\/p>\n
Als ich bei verschiedenen Projekten die gleichen Module und Formulare einsetzte und diese unabhängig voneinander anpasste, hatte ich plötzlich verschiedene Versionen der Objekte. Das war nicht beabsichtigt, die Objekte sollten möglichst überall gleich aussehen. Um keinen der Entwicklungsschritte zu verlieren, musste ich den Code der Objekte vergleichen. Dummerweise bietet Access keine eingebaute Funktion für so etwas, also musste ich mich selbst an die Arbeit machen und eine entsprechend Lösung programmieren. Diese sollte schlicht und einfach zwei Textdateien Zeile für Zeile miteinander vergleichen und mir die unterschiedlichen Zeilen anzeigen.<\/b><\/p>\n
Zunächst einmal muss man sich überlegen, wie die Benutzeroberfläche eines solchen Tools aussehen könnte. Da hier zwei Dateien miteinander verglichen werden sollen, wird es auf jeden Fall zwei Textfelder zur Eingabe der Dateinamen geben beziehungsweise zwei Schaltflächen, mit denen Sie einen Dateidialog zum Auswählen der beiden Dateien aufrufen können. Darunter befinden sich der übersicht halber nebeneinander die Texte der beiden Dateien – gegebenenfalls mit den markierten unterschiedlichen Zeilen.<\/p>\n
Wenn man nun zwei Dateien zeilenweise vergleicht, sind weitere Fragen zu beantworten:<\/p>\n
Kommen wir zunächst zur zweiten Frage. Im Endergebnis soll unser Formular mit den beiden nebeneinander dargestellten Dateien etwa wie in Bild 1 aussehen.<\/p>\n
![\"So](\"..\/fileadmin\/_temp_\/2014_01\/pic_922_001.png\")
<\/p>\n
Bild 1: So soll das Formular später aussehen.<\/span><\/b><\/p>\n Gleiche Zeilen werden direkt nebeneinander dargestellt, unterschiedliche Zeilen werden nur auf der jeweiligen Seite angezeigt und außerdem rot markiert, damit man diese sofort erkennen kann.<\/p>\n Die erste Frage ist schon aufwendiger zu beantworten. In unserer Lösung verwenden wir etwa einen Ablauf wie den folgenden:<\/p>\n Wir beginnen bei der ersten Zeile der ersten Datei und vergleichen diese mit der ersten Zeile der zweiten Datei. Sind beide Zeilen gleich, ist alles okay – wir bilden einfach beide Zeilen ab. Dann schauen wir uns die zweite Zeile an, bei der beispielsweise die erste Datei noch einen zusätzlichen Kommentar am Ende der Zeile enthält. Wir stellen fest, dass die zweite Zeile nicht in beiden Dateien gleich ist. Das kann nun Verschiedenes bedeuten: Zum Beispiel kann es sein, dass sich wirklich nur die zweiten Zeilen der beiden Dateien unterscheiden. Vielleicht finden wir aber die zweite Zeile der ersten Datei auch in der dritten oder in einer späteren Zeile der zweiten Datei – oder umgekehrt! In diesem Fall schauen wir, ob die zweite Zeile der ersten Datei früher in der zweiten Datei auftaucht als die zweite Zeile der zweiten Datei in der ersten. Wenn die zweite Zeile der ersten Datei früher in der zweiten Datei auftaucht als andersherum, zeigen wir für die erste Datei einige leere Zeilen an, während für die zweite Datei die bis zur gesuchten Zeile enthaltenen Zeilen erscheinen. Erst dann sollen die beiden gleichen Zeilen nebeneinandergestellt werden.<\/p>\n Am besten lässt sich dies anhand eines einfachen Beispiels erklären. Schauen wir uns dazu die beiden Textdateien aus Bild 2 an. Diese enthalten jeweils einen Satz, dessen Wörter auf jeweils einer eigenen Zeile abgebildet wurden. Wenn Sie diese beiden Dateien vergleichen, sollte sich das Ergebnis aus Bild 3 ergeben.<\/p>\n Bild 2: Beispieldateien für den Vergleich<\/span><\/b><\/p>\n Bild 3: Ergebnis des Vergleichs<\/span><\/b><\/p>\n Die Zeilen 0, 1 und 2 stimmen in beiden Dateien überein. Zeile 3 jedoch unterscheidet sich in den beiden Dateien. Also schauen wir zunächst, ob und wann sich der Inhalt von Zeile 3 der ersten Datei in der zweiten Datei wiederholt. Dies ist in Zeile 6 der Fall. Dann prüft der Algorithmus, wann sich Zeile 2 aus der zweiten Datei sich in der ersten Datei wiederholt. Dies ist gar nicht der Fall, also gehen wir davon aus, dass Zeile 2 der ersten Datei und Zeile 6 der zweiten Datei übereinstimmen und Zeile 3, 4 und 5 der zweiten Datei eingeschoben wurden. Dann geht der Vergleich weiter, und zwar mit der jeweils folgenden Zeile nach den zueinander passenden Zeilen (also 2 und 6). Zeile 4 der ersten Datei stimmt nicht mit Zeile 7 der zweiten Datei überein. Beide können auch im weiteren Verlauf nicht gefunden werden, also werden beide im Ergebnis in jeweils einer eigenen Zeile abgebildet.<\/p>\n Zeile 5 der ersten Datei und Zeile 8 der zweiten Datei stimmen wiede-rum wieder überein und werden folgerichtig nebeneinander abgebildet. Zeile 6, 7, 8 und 9 der ersten Datei finden sich hingegen nicht in der zweiten Datei wieder und erscheinen solo in je einer Zeile. Dann passen wieder Zeile 11 der ersten und Zeile 9 der zweiten Datei zueinander, die übrigen Zeilen hingegen nicht.<\/p>\n Formular anlegen<\/b><\/p>\n Das Formular der Lösung soll frmTextdateienVergleichen <\/b>heißen und soll keine Daten aus einer Tabelle oder Abfrage anzeigen – also stellen wir die Eigenschaften Bildlaufleisten<\/b>, Datensatzmarkierer<\/b>, Navigationsschaltflächen <\/b>und Trennlinien <\/b>auf Nein <\/b>ein.<\/p>\n Dateien auswählen<\/b><\/p>\n Beginnen wir mit der Auswahl der Dateien. Dazu fügen Sie dem Formular zwei Textfelder namens txtDatei1 <\/b>und txtDatei2 <\/b>hinzu. Rechts neben den Textfeldern platzieren Sie jeweils eine Schaltfläche namens cmdDatei1 <\/b>und cmdDatei2<\/b>.<\/p>\n Für die beiden Schaltflächen hinterlegen Sie eine Beim Klicken<\/b>-Ereignisprozedur wie in Listing 1. Die hier verwendete Prozedur OpenFileName <\/b>finden Sie im Modul mdlTools<\/b>.<\/p>\n Listing 1: Anzeigen eines Datei öffnen-Dialogs und Eintragen des Ergebnisses im Textfeld<\/span><\/b><\/p>\n Die Textfelder und Schaltflächen legen Sie etwa wie in Bild 4 im Formular an.<\/p>\n Bild 4: Textfelder zum Erfassen der Dateinamen<\/span><\/b><\/p>\n Damit ich beim Testen der Lösung nicht bei jedem Schließen und öffnen des Formulars die Dateien neu auswählen musste, habe ich die zuletzt verwendete Datei in den beiden Feldern Datei1 <\/b>und Datei2 <\/b>einer Tabelle namens tblOptionen<\/b> gespeichert (s. Bild 5).<\/p>\n Bild 5: Optionentabelle zum Speichern der zuletzt verwendeten Dateien<\/span><\/b><\/p>\n Das Formular ist an die Tabelle tblOptionen <\/b>gebunden, die beiden Textfelder txtDatei1 <\/b>und txtDatei2 <\/b>an die entsprechenden Felder der Tabelle.<\/p>\n Tabelle zum Speichern des Vergleichs<\/b><\/p>\n Um das Ergebnis des Vergleichs in einer Ansicht darzustellen, gibt es mehrere Möglichkeiten – zwei Unterformulare in der Datenblattansicht, zwei Listenfelder oder auch ein einzelnes Unterformular in der Datenblattansicht.<\/p>\n Nach einigen Experimenten wurde klar: Man muss durch die Ergebnisse scrollen können, und dies für die Zeilen aus beiden Dateien synchron. Außerdem sollten bei Bedarf die Spaltenbreiten mit den Zeileninhalten angepasst werden können. Das Ergebnis: Es sollte ein einziges Unterformular in der Datenblattansicht mit den Zeilen der beiden Dateien und weiteren Feldern werden. Um diese Informationen nach dem Vergleich per VBA schnell in einem Formular anzeigen zu können, sollte man diese am besten in einer Tabelle speichern. Diese sieht im Entwurf wie in Bild 6 aus und hat folgende Felder:<\/p>\n Bild 6: Tabelle zum Speichern des Ergebnisses des Vergleichs<\/span><\/b><\/p>\n Das Ergebnis für den Vergleich der beiden Beispieldateien von oben würde etwa wie in Bild 7 in der Tabelle gespeichert werden. Diese kann genau so als Datenherkunft für das Unterformular sfmTextdateienVergleichen <\/b>verwendet werden, fügen Sie dort alle Felder aus der Feldliste zum Formular hinzu. Stellen Sie außerdem die Eigenschaft Standardansicht <\/b>auf Datenblatt <\/b>ein.<\/p>\n Bild 7: In der Tabelle tblZeilen gespeichertes Vergleichsergebnis<\/span><\/b><\/p>\n Dateien vergleichen<\/b><\/p>\n Die Hauptarbeit beim Erstellen dieser Lösung steckte in der Programmierung der Routine, welche die Textdateien vergleicht und die Ergebnisse in die Tabelle tblZeilen <\/b>einträgt. Sie finden den ersten Teil dieser Prozedur, die durch das Anklicken der Schaltfläche cmdVergleichen <\/b>ausgelöst wird, in Listing 3.<\/p>\n <\/p>\n Listing 2: Textdateien vergleichen, Teil I<\/span><\/b><\/p>\n Die Prozedur löscht zunächst alle gegebenenfalls noch in der Tabelle tblZeilen <\/b>enthaltenen Datensätze. Dann füllt sie die beiden Array-Variablen strZeilen1 <\/b>und strZeilen2 <\/b>mit Arrays, die aus den einzelnen Zeilen der Dateien bestehen. Das heißt, dass jedes Feld des Arrays je eine Zeile aufnimmt. Das Einlesen und Umwandeln der Dateien übernimmt dabei die Funktion DateiInArray <\/b>aus Listing 2. Diese erwartet den Dateinamen als Parameter. Sie öffnet die Datei und durchläuft in einer Do While<\/b>-Schleife alle Zeilen der Datei. Dabei fügt sie jede Zeile durch einen Zeilenumbruch (vbCrLf<\/b>) getrennt zur Variablen strZeilen <\/b>hinzu.<\/p>\n Listing 3: Einlesen einer Textdatei in ein Array<\/span><\/b><\/p>\n Aus dem Ergebnis erzeugt die Routine mit der Split<\/b>-Funktion ein Array und gibt dieses an die aufrufende Prozedur zurück.<\/p>\n Dies geschieht für beide Textdateien, die entsprechenden Arrays befinden sich nun in den Variablen strZeilen1 <\/b>und strZeilen2<\/b>. Der Zähler für die aktuelle Zeile eines jeden Arrays wird mit den Variablen lngAktuelleZeile1 <\/b>und lngAktuelleZeile2 <\/b>jeweils auf 0 <\/b>eingestellt. Dann ermittelt die Prozedur die Gesamtzahl der Zeilen der längeren Datei.<\/p>\n Dazu liest sie erst die Anzahl der Zeilen im ersten Array ein und prüft dann, ob die Anzahl der Zeilen im zweiten Array größer als die des ersten Arrays ist. Der größere Wert landet in der Variablen lngZeilenGesamt<\/b>. Danach leert die Prozedur die Statuszeile von Access, die in der Folge den Fortschrift beim Vergleich der beiden Dateien anzeigen soll.<\/p>\n Dann geht es richtig los! Eine Do While<\/b>-Schleife wird solange durchlaufen, bis die in lngAktuelleZeile1<\/b> und lngAktuelleZeile2 <\/b>gespeicherten aktuell bearbeiteten Zeilen nicht mehr kleiner als die Gesamtzahl der Zeilen der jeweiligen Datei sind. Dabei stellt die Prozedur zunächst den Statustext von Access auf einen Ausdruck wie Zeile 1\/100 <\/b>ein.<\/p>\n Es folgen nun zwei Do While<\/b>-Schleifen. Die erste ermittelt, in welcher Zeile der zweiten Datei die erste Zeile der ersten Datei erstmalig auftaucht und speichert die Anzahl der Zeilen, die dazwischen liegen, in der Variablen lngAbstand1<\/b>. Die zweite Do While<\/b>-Schleife erledigt diesen Job genau andersherum. Dabei stellen die Anweisungen in den beiden Do While<\/b>-Schleifen auch die Variablen bolTreffer1 <\/b>und bolTreffer2 <\/b>ein. bolTreffer1 <\/b>erhält beispielsweise den Wert True<\/b>, wenn in der zweiten Datei eine Zeile gefunden werden konnte, die der aktuellen Zeile der ersten Datei entspricht, sonst erhält sie den Wert False<\/b>. Für bolTreffer2 <\/b>wird der Wert genau andersherum ermittelt.<\/p>\n Im Detail vergleicht die erste Do While<\/b>-Schleife die aktuelle Zeile der ersten Datei mit der aktuellen Zeile der zweiten Datei. Sind die Zeilen gleich, stellt die Prozedur den Wert bolTreffer2 <\/b>auf den Wert True <\/b>ein. Ist mit dieser Zeile der zweiten Datei die letzte Zeile erreicht, stellt die Prozedur den Wert von bolEnde2 <\/b>auf True <\/b>ein. Enthalten die beiden Variablen bolTreffer2 <\/b>und bolEnde2 <\/b>nach diesen Prüfungen den Wert False<\/b>, erhöht die Prozedur den Zähler lngAbstand2 <\/b>um den Wert 1<\/b>, sodass im nächsten Durchlauf der Schleife die aktuelle Zeile der ersten Datei mit der nächsten Zeile der zweiten Datei verglichen werden kann. Dies wiederholt sich, bis die Abbruchbedingung der Do While<\/b>-Schleife erfüllt ist.<\/p>\n Die zweite Do While<\/b>-Schleife erledigt dies umgekehrt, indem sie die aktuelle Zeile der zweiten Datei zuerst mit der aktuellen Zeile der ersten Datei vergleicht und, falls kein Treffer gefunden wurde, auch mit den folgenden Zeilen.<\/p>\n Am Ende der beiden Schleifen erhalten wir also die folgenden Informationen:<\/p>\n Mit diesem Resultat gehen wir in den zweiten Teil der Schleife für die aktuell untersuchten Zeilen der beiden Dateien (s. Listing 4).<\/p>\n Listing 4: Textdateien vergleichen, Teil II<\/span><\/b><\/p>\n Hier folgt eine ganze Reihe verschachtelter If…Then<\/b>-Bedingungen. Die erste Bedingung prüft, ob bolTreffer1 <\/b>den Wert True <\/b>hat. Ist dies wahr, folgt direkt eine untergeordnete If…Then<\/b>-Abfrage, die prüft, ob auch bolTreffer2 <\/b>wahr ist.<\/p>\n Das bedeutet zunächst, dass beide aktuell untersuchten Zeilen der beiden Dateien irgendwo in der jeweils anderen Datei auftauchen.<\/p>\n Im besten Fall entsprechen die beiden untersuchten Zeilen der beiden Dateien einander (dies ist etwa bei den in Bild 8 markierten Einträgen der Fall).<\/p>\n Bild 8: übereinstimmende Zeilen in beiden Textdateien<\/span><\/b><\/p>\n Sprich: Die beiden Schleifen von oben mussten nur je einmal durchlaufen werden, dann waren die Bedingung bolTreffer1 <\/b>und bolTreffer2 <\/b>wahr und die beiden Variablen lngAbstand1 <\/b>und lngAbstand2 <\/b>behielten den Wert 0<\/b> (siehe in Listing 4). In diesem Fall ruft die Prozedur eine weitere Routine namens Einlesen12<\/b> auf (s. Listing 5), die mit db <\/b>einen Verweis auf das aktuelle Database<\/b>-Objekt, die Nummer der aktuellen Zeile der ersten Datei (lngAktuelleZeile1<\/b>), die entsprechende Zeile aus dem Array (strZeilen1(lngAktuelleZeile1)<\/b>), die Nummer der aktuellen Zeile der zweiten Datei (lngAktuelleZeile2 <\/b>sowie die Zeile der zweiten Datei aus dem Array (strZeilen2(lngAktuelleZeile2)<\/b>) als Parameter erwartet.<\/p>\n Listing 5: Einfügen eines Datensatzes mit übereinstimmenden Zeilen in die Tabelle tblZeilen<\/span><\/b><\/p>\n Sind lngAbstand1 <\/b>und lngAbstand2 <\/b>nicht beide gleich 0<\/b>, steuert die Prozedur den Else<\/b>-Teil der If…Then<\/b>-Bedingung an . In diesem Fall prüft die Prozedur in einer weiteren untergeordneten If…Then<\/b>-Bedingung, ob lngAbstand1 <\/b>kleiner oder gleich lngAbstand2 <\/b>ist. Das bedeutet, dass die zur aktuellen Zeile der zweiten Datei passende Zeile der ersten Datei näher als die zur aktuellen Zeile der ersten Datei passende Zeile der zweiten Datei ist. Ist dies der Fall, durchläuft die Prozedur eine For…Next<\/b>-Schleife für alle Zeilen von der mit dem Index lngAktuelleZeile1 <\/b>bis zu der mit dem Index lngAktuelleZeile + lngAbstand1 – 1<\/b>. Dabei fügt sie mit der in der Prozedur Einfuegen1 <\/b>alle Zeilen der ersten Datei in die Tabelle tblZeilen <\/b>ein, die zwischen der aktuellen Zeile und der Zeile liegen, die mit der aktuellen Zeile der zweiten Datei übereinstimmt. Ein Beispiel dazu finden Sie in Bild 9.<\/p>\n Bild 9: Beide erste Zeilen sind später zu finden, die aus der zweiten Datei jedoch früher<\/span><\/b><\/p>\n Die Prozedur Einfuegen1 <\/b>fügt einen neuen Datensatz zur Tabelle tblZeilen <\/b>hinzu, der nur die Zeile aus der ersten Datei enthält und die Zeile für die zweite Datei freilässt (s. Listing 6).<\/p>\n Listing 6: Einfügen eines Datensatzes mit der aktuellen Zeile aus der ersten Datei in die Tabelle tblZeilen<\/span><\/b><\/p>\n Erst wenn alle zwischen der aktuellen Zeile aus der ersten Datei und der mit der aktuellen Zeile der zweiten Datei übereinstimmenden Zeile der ersten Datei liegenden Zeilen der ersten Datei allein in Datensätze der Tabelle tblZeilen <\/b>eingetragen wurden, fügt die Prozedur mithilfe der Routine Einfuegen12<\/b>, die Sie bereits weiter oben kennen gelernt haben, die übereinstimmenden Datensätze in die Tabelle tblZeilen<\/b> ein (im Beispiel sind dies die beiden Zeilen mit dem Wert Zeile2<\/b>).<\/p>\n Andersherum sieht es im Else<\/b>-Teil dieser If…Then<\/b>-Bedingung aus : Hier wurde die aktuelle Zeile der ersten Datei schneller in der zweiten Datei wiedergefunden als die aktuelle Zeile der zweiten Datei in der ersten Datei. Deshalb trägt die Prozedur zuerst alle Zeilen der zweiten Datei allein in Datensätze der Tabelle tblZeilen <\/b>ein, die zwischen der aktuellen Zeile der zweiten Datei und der mit der aktuellen Zeile der ersten Datei übereinstimmenden Zeile der zweiten Datei liegen. Dies erledigt die Prozedur durch einen Aufruf der Routine Einlesen2 <\/b>aus Listing 7. Erst dann folgen wieder die beiden gleichen Zeilen in einem Datensatz der Tabelle tblZeilen<\/b>.<\/p>\n![\"Beispieldateien](\"..\/fileadmin\/_temp_\/2014_01\/pic_922_002.png\")
<\/p>\n![\"Ergebnis](\"..\/fileadmin\/_temp_\/2014_01\/pic_922_003.png\")
<\/p>\nPrivate Sub <\/span>cmdDatei1_Click()\r\n Dim <\/span>strDateiendung As String<\/span>\r\n Me!txtDatei1 = OpenFileName(CurrentProject.Path, \"Textdatei auswählen\", _\r\n \"Textdatei (*.txt)|Alle Dateien (*.*)\")\r\nEnd Sub<\/span><\/pre>\n![\"Textfelder](\"..\/fileadmin\/_temp_\/2014_01\/pic_922_004.png\")
<\/p>\n![\"Optionentabelle](\"..\/fileadmin\/_temp_\/2014_01\/pic_922_005.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2014_01\/pic_922_006.png\")
<\/p>\n\n
![\"In](\"..\/fileadmin\/_temp_\/2014_01\/pic_922_007.png\")
<\/p>\nPrivate Sub <\/span>cmdVergleichen_Click()\r\n Dim <\/span>strZeilen1() As String<\/span>, strZeilen2() As String<\/span>\r\n Dim <\/span>lngAktuelleZeile1 As Long<\/span>, lngAktuelleZeile2 As Long<\/span>\r\n Dim <\/span>lng1 As Long<\/span>, lng2 As Long<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngAbstand1 As Long<\/span>, lngAbstand2 As Long<\/span>\r\n Dim <\/span>bolTreffer1 As Boolean<\/span>, bolTreffer2 As Boolean<\/span>\r\n Dim <\/span>bolEnde1 As Boolean<\/span>, bolEnde2 As Boolean<\/span>\r\n Dim <\/span>lngZeilenGesamt As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblZeilen\", dbFailOnError\r\n strZeilen1 = DateiInArray(Me!txtDatei1)\r\n strZeilen2 = DateiInArray(Me!txtDatei2)\r\n lngAktuelleZeile1 = 0\r\n lngAktuelleZeile2 = 0\r\n lngZeilenGesamt = UBound<\/span>(strZeilen1)\r\n If <\/span>lngZeilenGesamt < UBound<\/span>(strZeilen2) Then<\/span>\r\n lngZeilenGesamt = UBound<\/span>(strZeilen2)\r\n End If<\/span>\r\n SysCmd acSysCmdClearStatus\r\n Do While<\/span> (lngAktuelleZeile1 < UBound<\/span>(strZeilen1) And lngAktuelleZeile2 < UBound<\/span>(strZeilen2))\r\n SysCmd acSysCmdSetStatus, \"Zeile \" & lngAktuelleZeile1 & \"\/\" & lngZeilenGesamt\r\n lngAbstand1 = 0\r\n lngAbstand2 = 0\r\n Do While<\/span> Not<\/span> bolTreffer2 And Not<\/span> bolEnde2\r\n If <\/span>(strZeilen1(lngAktuelleZeile1) = strZeilen2(lngAktuelleZeile2 + lngAbstand2)) Then<\/span>\r\n bolTreffer2 = True<\/span>\r\n End If<\/span>\r\n If <\/span>lngAktuelleZeile2 + lngAbstand2 = UBound<\/span>(strZeilen2) - 1 Then<\/span>\r\n bolEnde2 = True<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> bolTreffer2 And Not<\/span> bolEnde2 Then<\/span>\r\n lngAbstand2 = lngAbstand2 + 1\r\n End If<\/span>\r\n Loop<\/span>\r\n Do While<\/span> Not<\/span> bolTreffer1 And Not<\/span> bolEnde1\r\n If <\/span>strZeilen2(lngAktuelleZeile2) = strZeilen1(lngAktuelleZeile1 + lngAbstand1) Then<\/span>\r\n bolTreffer1 = True<\/span>\r\n End If<\/span>\r\n If <\/span>lngAktuelleZeile1 + lngAbstand1 = UBound<\/span>(strZeilen1) - 1 Then<\/span>\r\n bolEnde1 = True<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> bolTreffer1 And Not<\/span> bolEnde1 Then<\/span>\r\n lngAbstand1 = lngAbstand1 + 1\r\n End If<\/span>\r\n Loop<\/span><\/pre>\nPublic Function <\/span>DateiInArray(strDateiname As String<\/span>) As String<\/span>()\r\n Dim <\/span>lngFile As Long<\/span>\r\n Dim <\/span>strZeile As String<\/span>\r\n Dim <\/span>strZeilen As String<\/span>\r\n lngFile = FreeFile\r\n Open strDateiname For Input As <\/span>#lngFile\r\n Do While<\/span> Not<\/span> EOF(lngFile)\r\n Line Input #lngFile, strZeile\r\n strZeilen = strZeilen & strZeile & vbCrLf<\/span>\r\n Loop<\/span>\r\n Close #lngFile\r\n DateiInArray = Split<\/span>(strZeilen, vbCrLf<\/span>)\r\nEnd Function<\/span><\/pre>\n\n
If <\/span>bolTreffer1 = True<\/span> Then<\/span>\r\n If <\/span>bolTreffer2 = True<\/span> Then<\/span>\r\n If <\/span>lngAbstand1 = 0 And lngAbstand2 = 0 Then<\/span>\r\n Einfuegen12 db, lngAktuelleZeile1, strZeilen1(lngAktuelleZeile1), _\r\n lngAktuelleZeile2, strZeilen2(lngAktuelleZeile2)\r\n Else<\/span>\r\n If <\/span>lngAbstand1 <= lngAbstand2 Then<\/span>\r\n For lng1 = lngAktuelleZeile1 To lngAktuelleZeile1 + lngAbstand1 - 1\r\n Einfuegen1 db, lngAktuelleZeile1, strZeilen1(lng1)\r\n lngAktuelleZeile1 = lngAktuelleZeile1 + 1\r\n Next<\/span> lng1\r\n Einfuegen12 db, lngAktuelleZeile1, strZeilen1(lngAktuelleZeile1), _\r\n lngAktuelleZeile2, strZeilen2(lngAktuelleZeile2)\r\n Else<\/span>\r\n For lng2 = lngAktuelleZeile2 To lngAktuelleZeile2 + lngAbstand2 - 1\r\n Einfuegen2 db, lngAktuelleZeile2, strZeilen2(lng2)\r\n lngAktuelleZeile2 = lngAktuelleZeile2 + 1\r\n Next<\/span> lng2\r\n Einfuegen12 db, lngAktuelleZeile1, strZeilen1(lngAktuelleZeile1), _\r\n lngAktuelleZeile2, strZeilen2(lngAktuelleZeile2)\r\n End If<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n For lng1 = lngAktuelleZeile1 To lngAktuelleZeile1 + lngAbstand1 - 1\r\n Einfuegen1 db, lngAktuelleZeile1, strZeilen1(lng1)\r\n lngAktuelleZeile1 = lngAktuelleZeile1 + 1\r\n Next<\/span> lng1\r\n Einfuegen12 db, lngAktuelleZeile1, strZeilen1(lngAktuelleZeile1), _\r\n lngAktuelleZeile2, strZeilen2(lngAktuelleZeile2)\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>bolTreffer2 = True<\/span> Then<\/span>\r\n For lng2 = lngAktuelleZeile2 To lngAktuelleZeile2 + lngAbstand2 - 1\r\n Einfuegen2 db, lngAktuelleZeile2, strZeilen2(lng2)\r\n lngAktuelleZeile2 = lngAktuelleZeile2 + 1\r\n Next<\/span> lng2\r\n Einfuegen12 db, lngAktuelleZeile1, strZeilen1(lngAktuelleZeile1), lngAktuelleZeile2, _\r\n strZeilen2(lngAktuelleZeile2)\r\n Else<\/span>\r\n Einfuegen1 db, lngAktuelleZeile1, strZeilen1(lngAktuelleZeile1)\r\n Einfuegen2 db, lngAktuelleZeile2, strZeilen2(lngAktuelleZeile2)\r\n End If<\/span>\r\n End If<\/span>\r\n lngAktuelleZeile1 = lngAktuelleZeile1 + 1\r\n lngAktuelleZeile2 = lngAktuelleZeile2 + 1\r\n bolTreffer1 = False<\/span>\r\n bolTreffer2 = False<\/span>\r\n bolEnde1 = False<\/span>\r\n bolEnde2 = False<\/span>\r\n Loop<\/span><\/pre>\n![\"übereinstimmende](\"..\/fileadmin\/_temp_\/2014_01\/pic_922_008.png\")
<\/p>\nPrivate Sub <\/span>Einfuegen12(db As <\/span>DAO.Database, lngZeile1 As Long<\/span>, _\r\n strZeile1 As String<\/span>, lngZeile2 As Long<\/span>, strZeile2 As String<\/span>)\r\n db.Execute \"INSERT INTO tblZeilen(ZeileDatei1, TextDatei1, ZeileDatei2, TextDatei2) " _\r\n "VALUES(\" & lngZeile1 & \", ''\" _\r\n & Replace<\/span>(strZeile1, \"''\", \"''''\") & \"'', \" & lngZeile2 & \", ''\" _\r\n & Replace<\/span>(strZeile2, \"''\", \"''''\") & \"'')\", dbFailOnError\r\nEnd Sub<\/span><\/pre>\n![\"Beide](\"..\/fileadmin\/_temp_\/2014_01\/pic_922_010.png\")
<\/p>\nPrivate Sub <\/span>Einfuegen1(db As <\/span>DAO.Database, lngZeile As Long<\/span>, strZeile As String<\/span>)\r\n db.Execute \"INSERT INTO tblZeilen(Unterschied, ZeileDatei1, TextDatei1) VALUES(-1, \" _\r\n & lngZeile & \", ''\" _\r\n & Replace<\/span>(strZeile, \"''\", \"''''\") & \"'')\", dbFailOnError\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Einfuegen2(db As <\/span>DAO.Database, lngZeile