<\/p>\n
Schon seit einer Weile drücke ich mich um dieses Thema herum: Beim Import der Adressen aus meinem Onlineshop in meine Kundendatenbank treten manchmal Fehler auf, die dazu führen, dass die Daten nicht konsistent sind. Außerdem hätte ich gern grundsätzlich eine Funktion, welche die Shopdaten mit der Kundendatenbank abgleicht – immerhin können Kunden dort ihre Daten ändern, ohne dass man es mitbekommt. In diesem Beitrag werfe ich nun einen genaueren Blick auf die Möglichkeiten zum Auffinden und Abgleichen inkonsistenter Adressdaten.<\/b><\/p>\n
Die Grundlage für diesen Beitrag sind zwei Datenquellen mit Adressdaten, die eigentlich immer den gleichen Bestand aufweisen sollten. Noch besser wäre es natürlich, den Datenbestand nur an einem Ort zu pflegen, aber dies ist aus verschiedenen Gründen nicht möglich.<\/p>\n
Im Onlineshop müssen die Daten vorliegen, damit der Benutzer darauf zugreifen kann, um die Daten zu ändern oder Aktionen mit seinem Benutzerkonto durchzuführen – beispielsweise das Auslösen neuer Bestellungen oder, im Falle meines Shops, das Abrufen von Downloads zu seinen Produkten.<\/p>\n
Andererseits erfolgen die nach der Bestellung durchgeführten Schritte auf Basis der Daten einer Access-Datenbank, in die ich die Kundendaten und Bestelldaten einlese – also beispielsweise der Versand der Bestellung oder die Zusammenstellung der Rechnungslisten für die Buchhaltung.<\/p>\n
Ich bin sicher, dass Ihre Kunden noch viel interessantere Gründe finden, die Daten nicht nur an einem Ort zu pflegen – geben wir also auf und programmieren einfach eine schöne Lösung zum Abgleichen der Adressdaten aus zwei verschiedenen Quellen.<\/p>\n
Voraussetzung: Feld-zu-Feld-Zuordnung<\/b><\/p>\n
Eine Grundlage für die Ermittlung von Inkonsistenzen ist, dass die Felder der Datenquelle, in diesem Fall also der Datenbank des Onlineshops, sich den Feldern des Ziels für die Daten, also der Kundendatenbank, zuweisen lassen. Die Daten müssen nicht auf beiden Seiten genau gleich strukturiert sein und dürfen durchaus auf verschiedene Tabellen aufgeteilt sein. Sie müssen sich aber durch geschickte Formulierung von Abfragen so umwandeln lassen, dass die Daten sich in einer gleichen Struktur darstellen lassen.<\/p>\n
Voraussetzung: Zuordnung per Schlüssel<\/b><\/p>\n
Die zweite Grundlage ist, dass die Datensätze bereits einander zugeordnet sind. In diesem Fall handhabe ich es so, dass ich einen neuen Kundendatensatz aus dem Onlineshop in die Kundendatenbank übertrage und dabei ein Feld etwa namens Kundennummer-ImShop <\/b>verwende, um diesen Kundendatensatz dem entsprechenden Kundendatensatz des Shops zuzuweisen.<\/p>\n
Auf diese Weise lässt sich auch leicht prüfen, ob ein Kundendatensatz aus dem Shop überhaupt schon in die lokale Kundendatenbank eingelesen wurde – liegt dort noch kein Datensatz vor, dessen Feld KundennummerInShop <\/b>die Kundennummer aus dem Shop aufweist, handelt es sich offensichtlich um einen neuen Kunden, der erst noch angelegt werden muss.<\/p>\n
Flexible Zuordnung<\/b><\/p>\n
Wie immer möchten wir eine möglichst flexible und anpassbare Lösung programmieren. Das heißt, dass wir zunächst die beiden Tabellen oder Abfragen auswählen können wollen, welche die Daten aus dem Shop und aus der Kundendatenbank liefern. Dann wollen wir alle Felder, die auf Unterschiede geprüft werden sollen, festlegen und einander zuordnen können. Das heißt, dass wir für jedes Feld der Shopdatenbank, das wir abgleichen wollen, das entsprechende Feld der Kundendatenbank festlegen müssen.<\/p>\n
Um überhaupt einen Datensatz der Kundendatenbank einem Datensatz der Shopdatenbank zuordnen zu können, müssen wir natürlich auch noch das Primärschlüsselfeld der Tabelle aus der Shopdatenbank und das entsprechende Verknüpfungsfeld (bisher KundennummerImShop <\/b>genannt) auswählen.<\/p>\n
Dies ist nur die Konfiguration, die wir in Tabellen speichern wollen, damit Sie diese jederzeit anpassen können. Außerdem benötigen wir natürlich eine entsprechende Benutzeroberfläche, damit Sie die Informationen für den Abgleich leicht auswählen können. Dies ist jedoch der leichtere Teil dieser Lösung.<\/p>\n
Die Optionen stellen Sie mit dem Formular frmAbgleichoptionen<\/b>. Dieses sieht wie in Bild 1 aus und bietet ganz oben zunächst zwei Kombinationsfelder, mit denen Sie die Originaltabelle auswählen und die abzugleichende Tabelle.<\/p>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2015_02\/pic_979_002.png\")
<\/p>\n
Bild 1: Einstellen der Optionen<\/span><\/b><\/p>\n Direkt darunter finden Sie ein Kombinationsfeld zum Auswählen des Primärschlüsselfeldes der Originaltabelle. Für die abzugleichende Tabelle wählen Sie ebenfalls ein Feld aus, und zwar das, über das die Tabelle mit der Originaltabelle verknüpft ist.<\/p>\n In diesem Beispiel haben wir einfach eine Kundentabelle namens tblKunden_Original <\/b>mit ein paar Feldern und einigen Beispieldatensätzen erstellt und eine Kopie dieser Tabelle namens tblKunden <\/b>angelegt – gefüllt mit den gleichen Daten. Dann haben wir einige Datensätze einer der beiden Tabellen geändert.<\/p>\n Wir haben der Tabelle tblKunden <\/b>also kein spezielles Feld hinzugefügt, mit dem ein Datensatz dem entsprechenden Datensatz der Tabelle tblKunden_Original <\/b>zugeordnet werden kann – dies ist in diesem Fall nicht nötig, da diese ja die gleichen Primärschlüsselwerte wie die Originaltabelle enthält. Dies ist also auch eine Konfigurationsvariante – Sie können so zwei Versionen einer Tabelle miteinander vergleichen.<\/p>\n Hier wählen Sie also für beide Tabellen das Feld KundeID <\/b>für den Abgleich aus. Danach müssen Sie festlegen, welche Felder verglichen und auch angezeigt werden sollen. Dies erledigen Sie mit dem Unterformular darunter, wo jeder Datensatz jeweils ein Feld der ersten Tabelle und das abzugleichende Feld der zweiten Tabelle aufnimmt.<\/p>\n Wenn Sie die Tabellen oder Abfragen so gestaltet haben, dass die Feldnamen übereinstimmen, können Sie mit einem Klick auf die Schaltfläche Automatisch erkennen <\/b>eine Menge Zeit sparen – die dahinter liegende Prozedur weist identische Feldnamen dann einfach einander zu. Das Ergebnis sieht dann schließlich wie in der Abbildung aus.<\/p>\n Daten abgleichen<\/b><\/p>\n Der kompliziertere Teil ist der eigentliche Abgleich der Daten. Dabei soll ein Formular in einem Listenfeld alle Datensätze der abzugleichenden Tabelle anzeigen, die nicht genau mit den Daten aus der Originaltabelle übereinstimmen.<\/p>\n Klickt der Benutzer nun auf einen dieser Datensätze, sollen die Daten aus der Originaltabelle und die aus der abzugleichenden Tabelle im unteren Bereich des Formulars nebeneinander angezeigt werden. Die Felder mit unterschiedlichen Inhalten sollen dabei auf irgendeine Weise hervorgehoben werden – beispielsweise durch eine entsprechende Hintergrundfarbe. Der Benutzer soll nun drei Optionen haben:<\/p>\n Das Formular sieht nun etwa wie in Bild 2 aus. Hier sehen Sie im oberen Listenfeld bereits die Datensätze der Tabelle tblKunden<\/b>, die sich vom zugeordneten Datensatz aus der Tabelle tblKunden_Original <\/b>unterscheiden. Klicken Sie einen der Einträge im Listenfeld an, zeigt der untere Bereich die Felder beider Datensätze nebeneinander an. Dabei werden die Felder, die sich unterscheiden, farbig hervorgehoben.<\/p>\n Bild 2: Formular zum Abgleichen der Unterschiede zwischen zwei Datensätzen aus verschiedenen Tabellen<\/span><\/b><\/p>\n Danach können Sie aktiv werden:<\/p>\n Damit können Sie alle gewünschten änderungen vornehmen, um die Datensätze anzugleichen.<\/p>\n Dies gelingt natürlich nicht, wenn Sie beispielsweise als Originaltabelle auf der linken Seite eine Abfrage verwenden, die auf komplizierte Weise die Tabellen eines Shopsystems abbildet und dadurch nicht aktualisierbar ist – in diesem Fall gelingt die Anpassung nur in Richtung der im rechten Bereich dargestellten Daten.<\/p>\n Formularaufbau<\/b><\/p>\n Die Gestaltung des Formulars ist so interessant, weil es eigentlich kein Steuerelement gibt, mit dem man so einfach zwei Datensätze nebeneinander anzeigen kann.<\/p>\n <\/p>\n Wir könnten zwar vielleicht zwei Unterformulare verwenden, allerdings sollten diese auch nicht allzu hoch sein: Wenn Sie dann nämlich den Inhalt des einen Unterformulars nach oben scrollen, um den unteren Bereich zu sehen, bleibt das andere stehen und zeigt die Daten nicht passend zum anderen Unterformular an.<\/p>\n Also machen wir es so: Wir legen zwei Unterformulare, die hoch genug sind, in einem weiteren Unterformular an, das wir wiederum nach oben und nach unten scrollen können. Diesen beiden Unterformularen weisen wir einige Textfelder zu, die wir allerdings nicht mit einem festen Steuerelementinhalt versehen, da wir die für den Abgleich zu verwendenden Felder ja gegebenenfalls flexibel anpassen wollen.<\/p>\n Um genau zu sein, brauchen wir sogar nur ein Unterformular anzuzeigen, dass wir dann zweimal in das übergeordnete Unterformular einfügen und mit verschiedenen Datenherkünften versehen.<\/p>\n Unterformular für die Felder erstellen<\/b><\/p>\n Das Unterformular für die Felder soll sfmAbgleichfelder <\/b>heißen und 20 Textfelder enthalten. Diese benennen wir mit dem Präfix txt <\/b>und einer laufenden Nummer im zweistelligen Format (also txt01 <\/b>bis txt20<\/b>). Platzieren Sie die Textfelder wie in Bild 3 so, dass diese mit den Rändern des Formulars abschließen. Sie sollen lediglich ein Pixel Abstand vom linken Rand des Formulars erhalten, damit der linke Rand der Textfelder nicht verdeckt wird.<\/p>\n Bild 3: Unterformular zur Darstellung der Feldinhalte eines Datensatzes<\/span><\/b><\/p>\n Die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen <\/b>und Trennlinien <\/b>stellen wir auf Nein <\/b>ein.<\/p>\n Unterformular für die beiden Unterformulare erstellen<\/b><\/p>\n Nun erstellen wir das Unterformular namens sfmAbgleich<\/b>, das zwei Exemplare des soeben erstellten Unterformulars sfmAbgleichfelder <\/b>aufnimmt.<\/p>\n Fügen Sie diesem zweimal das Unterformular hinzu und benennen Sie die Unterformularsteuerelemente sfmAbgleich1 <\/b>und sfmAbgleich2<\/b>. Stellen Sie die Eigenschaft Rahmenart <\/b>beider Unterformularsteuerelemente auf den Wert Transparent <\/b>ein.<\/p>\n Legen Sie für die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen <\/b>und Trennlinien <\/b>auch hier den Wert Nein <\/b>fest.<\/p>\n Fügen Sie dann links die Beschriftungsfelder wie in Bild 4 hinzu. Beim Ausrichten müssen Sie ein wenig experimentieren, denn die Felder in den Unterformularen werden etwas anders positioniert als es in der Entwurfsansicht zu erkennen ist. Schließlich fügen Sie noch die beiden Schaltflächen cmdAlleAbgleichen1 <\/b>und cmdAlleAbgleichen2 <\/b>hinzu.<\/p>\n Bild 4: Unterformular, das die Beschriftungen und die beiden Unterformulare mit den Feldern der zu vergleichenden Tabellen enthält<\/span><\/b><\/p>\n Im letzten Schritt legen Sie das Hauptformular an, dem Sie im Kopf ein Listenfeld namens lstDatensaetze<\/b> hinzufügen. Darunter positionieren Sie das Unterformular sfmAbgleich<\/b>.<\/p>\n Danach folgt der wirklich interessante Stoff – die Programmierung des Formulars.<\/p>\n Formular füllen<\/b><\/p>\n Die Prozedur, die durch das Ereignis Beim Laden <\/b>des Hauptformulars frmAbgleichen<\/b> ausgelöst wird, sieht wie in Listing 1 aus.<\/p>\n Listing 1: Füllen der Formulardaten beim Laden des Formulars<\/span><\/b><\/p>\n Die Prozedur liest zunächst die Konfigurationsdaten aus der Tabelle tblAbgleichOptionen <\/b>ein. Dann erstellt sie ein neues Recordset auf Basis der Tabelle tblAbgleichfelder<\/b>, die ja die im Konfigurationsformular festgelegten Felder enthält. Dieses Recordset durchläuft die Prozedur dann in einer Do While<\/b>-Schleife und stellt dort folgende Zeichenketten zusammen:<\/p>\n Nun stellt die Prozedur die SQL-Anweisung zusammen, die als Datensatzherkunft für das Listenfeld zum Einsatz kommen wird.<\/p>\n Diese besteht aus der Select<\/b>-Anweisung, dem Feld der Zieltabelle, das zum Verknüpfen der Datensätze mit denen der Quelltabelle verwendet wird, und den Feldern, die wir zuvor in einer Liste zusammengestellt haben. Als Kriterium dient zunächst der Ausdruck, der den Wert 0 <\/b>liefert, wenn ein oder mehrere Feldwerte der beiden Tabellen nicht übereinstimmen.<\/p>\n Außerdem muss aber auch noch der Wert des Verknüpfungsfeldes der Zieltabelle mit dem eindeutigen Feld der Quelltabelle übereinstimmen. Diese SQL-Anweisung landet schließlich als Datensatzherkunft im Listenfeld, das dann alle Datensätze mit Unterschieden zwischen den Tabellen auflistet.<\/p>\n Nun folgt der Aufruf der Prozedur UnterformularBe-stuecken<\/b>. Diese verwendet auch wieder das Recordset mit den Abgleichfeldern, außerdem übergibt die Prozedur ihr den Namen der Quell- und der Zieltabelle.<\/p>\n Danach sorgt eine Prozedur namens Unterformularereignisse<\/b> dafür, dass die Textfelder im Unterformular jeweils mit einem Ereignis ausgestattet werden, das durch einen Doppelklick ausgelöst wird und dafür sorgt, dass der Inhalt des angeklickten Feldes im entsprechenden Feld der abzugleichenden Tabelle landet.<\/p>\n Schließlich prüft die Prozedur noch, ob ein Eintrag im Listenfeld markiert ist, und liest den entsprechenden Datensatz in die Unterformulare ein.<\/p>\n Unterformular füllen<\/b><\/p>\n Die Prozedur UnterformularBestuecken<\/b> aus Listing 2 stellt zunächst die Datenherkunft der beiden Unterformulare in sfmAbgleich1 <\/b>und sfmAbgleich2 <\/b>auf die in der Optionentabelle gespeicherten Tabellen\/Abfragen ein. Dann durchläuft sie erneut die Datensatzgruppe mit den zu verwendenden Feldern aus der Tabelle tblAbgleichfelder<\/b>.<\/p>\n Listing 2: Füllen der Unterformulare<\/span><\/b><\/p>\n Dabei trägt sie zunächst den Feldnamen als Beschriftung für die Bezeichnungsfelder links von den beiden Unterformularen ein und blendet diese ein. Dann kümmert sie sich um die Textfelder im ersten Unterformular. Auch hier werden die Felder von oben nach unten durchlaufen, eingeblendet und mit dem Feldnamen als Steuerelementinhalt gefüllt. Dies erledigt die Prozedur auch noch für die Textfelder im zweiten Unterformular.<\/p>\n Nun wurde die Schleife für jedes anzuzeigende Feld einmal durchlaufen. Dabei hat es die Steuerelementnamen jeweils über das Präfix (lbl<\/b>\/txt<\/b>) und den Wert der Eigenschaft AbsolutePosition <\/b>des aktuellen Datensatzes referenziert. Wenn dabei weniger als 20 Felder benötigt werden, durchläuft die Prozedur später noch eine For…Next<\/b>-Schleife vom x. bis zum 20. Steuerelement und blendet das Bezeichnungsfeld sowie die beiden Textfelder aus.<\/p>\n Textfeldereignisse einrichten<\/b><\/p>\n Schließlich haben wir eine Klasse namens clsAbgleichtextfeld <\/b>angelegt, welche einen Verweis auf das Textfeld aufnimmt, auf dessen Doppelklick es reagieren soll – und einen weiteren Verweis auf das Textfeld, dessen Wert auf den Wert des angeklickten Feldes eingestellt werden soll.<\/p>\n Die Prozedur Unterformularereignisse <\/b>erstellt für jedes Textfeld eine solche Klasse und weist den beiden Eigenschaften der Klasse die beiden Textfelder zu, welche die Klasse automatisieren soll. Dies sieht wie in Listing 3 aus. Die Prozedur durchläuft eine äußere Schleife zweimal (für das linke und das rechte Unterformular) und die innere 20 Mal, also für die maximal mögliche Anzahl Felder. Dabei erstellt sie eine neue Instanz der Klasse und weist die beiden beteiligten Textfelder zu. Damit die Instanzen der Klasse nach dem Beenden der Prozedur nicht im Nirwana verschwinden, speichert die Prozedur diese in einer Collection, die wir wie folgt deklarieren:<\/p>\n Listing 3: Einrichtung der Unterformularereignisse<\/span><\/b><\/p>\n Die Klasse selbst hat zwei lokale Variablen zum Speichern der Textfelder:<\/p>\n Die folgenden beiden Prozeduren stellen sich nach außen als Eigenschaften der Klasse dar und ermöglichen die Zuweisung der Textfelder:<\/p>\n Die einzige Ereignisprozedur wird beim Doppelklick ausgelöst. Sie überträgt den Wert des angeklickten Textfeldes an sein Pendant und hebt die graue Hintergrundfarbe auf:<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Mit dieser Lösung können Sie flexibel die Daten zweier Datenherkünfte wie von Tabellen oder Abfragen miteinander vergleichen.<\/p>\n Dabei ist es wichtig, dass die Datensätze der Tabellen einander zugeordnet werden können – zum Beispiel dadurch, dass es verschiedene Versionen der gleichen Tabelle sind, deren Datensätze aber die gleichen Primärschlüsselwerte verwenden.<\/p>\n Alternativ können Sie auch beispielsweise Daten aus einem Onlineshop, die Sie per ODBC in einer Kundendatenbank verfügbar machen, mit den dortigen Kundendaten abgleichen. Voraussetzung wäre hier, dass die Kundendaten beim übertragen in die Kundendatenbank eine Referenz auf den Primärschlüsselwert des Originaldatensatzes aus der Onlineshop-Datenbank enthalten.<\/p>\n Mit dem hier vorgestellten Formular können Sie die Unterschiede in beide Richtungen entweder in einem Rutsch oder feldweise vornehmen.<\/p>\n Im folgenden Teil erläutern wir die verbleibenden VBA-Prozeduren des Hauptformulars und gehen auch noch auf das Formular zum Festlegen der Konfiguration ein.<\/p>\n Enthaltene Beispieldateien:<\/p>\n AdressenAbgleichen.mdb<\/p>\n\n
![\"Formular](\"..\/fileadmin\/_temp_\/2015_02\/pic_979_001.png\")
<\/p>\n\n
![\"Unterformular](\"..\/fileadmin\/_temp_\/2015_02\/pic_979_003.png\")
<\/p>\n![\"Unterformular,](\"..\/fileadmin\/_temp_\/2015_02\/pic_979_004.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n ...\r\n Set<\/span> db = CurrentDb\r\n strTabelleQuelle = DLookup(\"AbgleichQuelltabelle\", \"tblAbgleichOptionen\")\r\n strTabelleZiel = DLookup(\"AbgleichZieltabelle\", \"tblAbgleichOptionen\")\r\n strAbgleichfeldQuelle = DLookup(\"AbgleichfeldQuelltabelle\", \"tblAbgleichOptionen\")\r\n strAbgleichfeldZiel = DLookup(\"AbgleichfeldZieltabelle\", \"tblAbgleichOptionen\")\r\n Set<\/span> rstAbgleichfelder = db.OpenRecordset(\"SELECT * FROM tblAbgleichfelder\", dbOpenDynaset)\r\n Set<\/span> rstZiel = db.OpenRecordset(\"SELECT * FROM \" & strTabelleZiel & \" WHERE 1 = 2\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstAbgleichfelder.EOF\r\n strSQL = strSQL & \", \" & strTabelleZiel & \".\" & rstAbgleichfelder!AbgleichfeldZiel\r\n strUnterschiede = strUnterschiede & \" * CInt(nz(\" & strTabelleQuelle & \".\" _\r\n & rstAbgleichfelder!AbgleichfeldQuelle & \") = nz(\" & strTabelleZiel & \".\" _\r\n & rstAbgleichfelder!AbgleichfeldZiel & \"))\"\r\n rstAbgleichfelder.MoveNext<\/span>\r\n Loop<\/span>\r\n strUnterschiede = Mid<\/span>(strUnterschiede, 3)\r\n strSQL = Mid<\/span>(strSQL, 3)\r\n strSQL = \"SELECT \" & strTabelleZiel & \".\" & strAbgleichfeldZiel & \" AS Verknüpfungsfeld, \" & strSQL & \" FROM \" _\r\n & strTabelleQuelle & \", \" & strTabelleZiel & \" WHERE \" & strTabelleZiel & \".\" & strAbgleichfeldZiel & \" = \" _\r\n & strTabelleQuelle & \".\" & strAbgleichfeldQuelle & \" AND \" & strUnterschiede & \" = 0\"\r\n Me!lstDatensaetze.RowSource = strSQL\r\n UnterformularBestuecken rstAbgleichfelder, strTabelleQuelle, strTabelleZiel\r\n Unterformularereignisse\r\n If <\/span>Not<\/span> IsNull(Me!lstDatensaetze) Then<\/span>\r\n lstDatensaetze_AfterUpdate\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
Private Sub <\/span>UnterformularBestuecken(rst As <\/span>DAO.Recordset, strTabelleQuelle As String<\/span>, strTabelleZiel As String<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>intAnzahl As Integer<\/span>\r\n Me!sfmAbgleich.Form!sfmAbgleich1.Form.RecordSource = strTabelleQuelle\r\n Me!sfmAbgleich.Form!sfmAbgleich2.Form.RecordSource = strTabelleZiel\r\n rst.MoveFirst\r\n Do While<\/span> Not<\/span> rst.EOF\r\n intAnzahl = intAnzahl + 1\r\n With<\/span> Me!sfmAbgleich.Form.Controls(\"lbl\" & Format(rst.AbsolutePosition + 1, \"00\"))\r\n .Visible = True<\/span>\r\n .Caption = rst!AbgleichfeldZiel & \":\"\r\n End With<\/span>\r\n With<\/span> Me!sfmAbgleich.Form!sfmAbgleich1.Form.Controls(\"txt\" & Format(rst.AbsolutePosition + 1, \"00\"))\r\n .Visible = True<\/span>\r\n .ControlSource = rst!AbgleichfeldQuelle\r\n End With<\/span>\r\n With<\/span> Me!sfmAbgleich.Form!sfmAbgleich2.Form.Controls(\"txt\" & Format(rst.AbsolutePosition + 1, \"00\"))\r\n .Visible = True<\/span>\r\n .ControlSource = rst!AbgleichfeldZiel\r\n End With<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n For i = intAnzahl + 1 To 20\r\n Me!sfmAbgleich.Form.Controls(\"lbl\" & Format(i, \"00\")).Visible = False<\/span>\r\n Me!sfmAbgleich.Form!sfmAbgleich1.Form.Controls(\"txt\" & Format(i, \"00\")).Visible = False<\/span>\r\n Me!sfmAbgleich.Form!sfmAbgleich2.Form.Controls(\"txt\" & Format(i, \"00\")).Visible = False<\/span>\r\n Next<\/span> i\r\n lstDatensaetze_AfterUpdate\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Unterformularereignisse()\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>intForm As Integer<\/span>\r\n Dim <\/span>objAbgleichtextfeld As <\/span>clsAbgleichtextfeld\r\n Set<\/span> col = New<\/span> Collection\r\n For intForm = 1 To 2\r\n For i = 1 To 20\r\n Set<\/span> objAbgleichtextfeld = New<\/span> clsAbgleichtextfeld\r\n With<\/span> objAbgleichtextfeld\r\n If <\/span>intForm = 1 Then<\/span>\r\n Set<\/span> .txtQuelle = Me!sfmAbgleich.Form.Controls(\"sfmAbgleich1\").Form.Controls(\"txt\" & Format(i, \"00\"))\r\n Set<\/span> .txtZiel = Me!sfmAbgleich.Form.Controls(\"sfmAbgleich2\").Form.Controls(\"txt\" & Format(i, \"00\"))\r\n Else<\/span>\r\n Set<\/span> .txtQuelle = Me!sfmAbgleich.Form.Controls(\"sfmAbgleich2\").Form.Controls(\"txt\" & Format(i, \"00\"))\r\n Set<\/span> .txtZiel = Me!sfmAbgleich.Form.Controls(\"sfmAbgleich1\").Form.Controls(\"txt\" & Format(i, \"00\"))\r\n End If<\/span>\r\n End With<\/span>\r\n col.Add objAbgleichtextfeld\r\n Next<\/span> i\r\n Next<\/span> intForm\r\nEnd Sub<\/span><\/pre>\nDim <\/span>col As <\/span>Collection<\/pre>\nPrivate <\/span>WithEvents m_txtQuelle As <\/span>TextBox\r\nPrivate <\/span>m_txtZiel As <\/span>TextBox<\/pre>\nPublic Property Set<\/span> <\/span>txtQuelle(txt As <\/span>TextBox)\r\n Set<\/span> m_txtQuelle = txt\r\n m_txtQuelle.OnDblClick = \"[Event Procedure]\"\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>txtZiel(txt As <\/span>TextBox)\r\n Set<\/span> m_txtZiel = txt\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>m_txtQuelle_DblClick(Cancel As Integer<\/span>)\r\n m_txtZiel = m_txtQuelle\r\n If m_txtQuelle = m_txtZiel Or (IsNull(m_txtQuelle) _\r\n And IsNull(m_txtZiel)) Then\r\n m_txtQuelle.BackColor = &HFFFFFF\r\n m_txtZiel.BackColor = &HFFFFFF\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDownloads zu diesem Beitrag<\/h3>\n