<\/p>\n
Im Beitrag „Ungebundene Listen und Kombis mit Daten füllen“ (www.access-im-unternehmen.de\/1440) haben wir uns angesehen, wir man Kombinations- und Listenfelder über das Zuweisen einer Wertliste oder mit der AddItem-Methode füllen kann. Es gibt noch eine interessante Alternative, von der wir hoffen, dass wir damit sogar noch einige Einträg mehr zu den Listen-Steuerelementen hinzufügen können als mit den oben genannten Methoden. Bei dieser Alternative handelt es sich um eine Technik, die eher stiefmütterlich behandelt wird: Die Callbackfunktion. Wie man diese nutzt und ob man tatsächlich mehr Daten als mit einer Wertliste in ungebundenen Listen-Steuerelementen anzeigen, untersuchen wir in diesem Beitrag.<\/b><\/p>\nEinfaches Beispiel für das Füllen per Callbackfunktion<\/h2>\n
Bevor wir uns daran begeben, die Daten umfangreicher Tabellen in ein Listenfeld zu füllen, schauen wir und die grundlegende Vorgehensweise beim Verwenden von Callback-Funktionen zum Füllen von Kombinations- und Listenfeldern an. Bei Verwendung einer Callbackfunktion nutzen wir keine der drei bekannten Möglichkeiten für die Eigenschaft Herkunftsart<\/b>, sondern wir geben dort den Namen einer Funktion an.<\/p>\n
Diese legen wir außerdem im Klassenmodul des Formulars an, in dem sich auch das Kombinations- oder Listenfeld befindet. Die Callbackfunktion muss einen speziellen Aufbau haben. Zumindest die Parameter müssen nach einem festen Schema angegeben werden und auch innerhalb der Funktion sind einige Regel zu beachten, damit diese wie gewünscht arbeitet. Für ein einfaches Beispiel fügen wir einem Formular ein Listenfeld hinzu, für dessen Eigenschaft Herkunftstyp <\/b>wie den Namen der Callbackfunktion angeben, in diesem Fall Beispielcallback<\/b> (siehe Bild 1).<\/p>\n
![\"Listenfeld](\"..\/fileadmin\/_temp_\/2023_04\/pic_1443_001.png\")
<\/p>\n
Bild 1: Listenfeld mit Callback-Funktion<\/span><\/b><\/p>\n Die Callbackfunktion erwartet bestimmte Parameter, die beim Aufruf automatisch von dem Steuerelement, dem sie zugeordnet ist, übergeben werden. Der Kopf der Prozedur sieht so aus:<\/p>\n Die hier verwendeten Parameter liefern die folgenden Werte:<\/p>\n Mit dem Rückgabewert mit dem Datentyp Variant <\/b>übergeben wir die jeweils angeforderten Informationen an das Steuerelement.<\/p>\n Die Callbackfunktion muss, damit sie korrekt funktioniert und das Steuerelement wie gewünscht gefüllt wird, die mit dem Parameter intCode <\/b>angefragten Informationen zusammenstellen und zurückliefern. intCode kann verschiedene Werte annehmen, für die jeweils Konstanten definiert sind. Diese lauten:<\/p>\n Nachfolgend haben wir das denkbar einfachste Beispiel für eine Callbackfunktion zusammengestellt:<\/p>\n [<\/p>\n Dabei werden in diesem Fall alle Codes für den Parameter intCode <\/b>wie oben angegeben nacheinander durchlaufen. Wichtig dabei ist: Der Aufruf von acLBGetColumnCount <\/b>erfolgt einmal. Je nachdem, wieviele Spalten dort zurückgegeben werden, erfolgt die entsprechende Anzahl von Aufrufen mit dem Parameter acLBGetColumnWidth<\/b>. Dabei wird mit dem Parameter lngColumn <\/b>der 0-basierte Index der Spalte übergeben, für welche die Breite abgefragt werden soll. Hier liefern wir immer den Wert -1 <\/b>zurück, wenn wir keine explizite Spaltenbreite definieren wollen. Danach wird die Anzahl der Zeilen abgefragt (acLBGetRowCount<\/b>).<\/p>\n Schließlich erfolgen abwechselnde Aufrufe mit den Werten acLBGetValue <\/b>und acLBGetFormat <\/b>für den Parameter intCode <\/b>mit einer Anzahl Wiederholungen, die dem Produkt aus Spalten und Zeilen entspricht.<\/p>\n In dem Beispiel oben wollen wir nur eine Zeile und eine Spalte füllen, also insgesamt nur einen Wert im Listenfeld anlegen. Das führt zu dem Ergebnis aus Bild 2.<\/p>\n Bild 2: Listenfeld mit einem Beispielwert<\/span><\/b><\/p>\n Damit wenden wir uns nun einem echten Anwendungsfall zu – dem Füllen eines Listenfeldes mit acht Spalten und vielen hundert Zeilen. Dabei wollen wir ein Listenfeld namens lstKunden <\/b>mit den Daten der Tabelle tblKunden <\/b>füllen, die mehr als 3.000 Datensätze aufweist. Dies war für das Füllen eines Listenfeldes per Wertliste oder mit der AddItem<\/b>-Methode deutlich zu viel. Wir werden sehen, ob wir mit der Callbackfunktion mehr Daten in das Listenfeld einlesen können. Das Listenfeld bereiten wir wie in Bild 3 vor, indem wir die Eigenschaften Spaltenanzahl <\/b>und die Spaltenbreiten <\/b>einstellen. Außerdem legen wir für das Listenfeld die Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>auf Beide <\/b>fest. Als Herkunftstyp legen wir die Callbackfunktion Kundenliste <\/b>fest. Im Kopf des Klassenmoduls des Formulars deklarieren wir die folgenden beiden Variablen:<\/p>\n Bild 3: Vorbereiten des Listenfeldes für viele Kundendaten<\/span><\/b><\/p>\n Die Callbackfunktion gestalten wir wie folgt. Der Kopf unterscheidet sich im Namen vom vorherigen Beispiel:<\/p>\n Beim Initialisieren erfolgen jedoch einige neue Schritte. Wir lesen hier das Recordset basierend auf den Daten der Tabelle tblKunden <\/b>in die Variable rst <\/b>ein. Danach bewegen wir den Datensatzzeiger einmal auf den letzten und dann wieder auf den ersten Datensatz, damit wir später mit der RecordCount<\/b>-Funktion die Anzahl der Datensätze ermitteln können. Dann legen wir die Anzahl der benötigten Spalten für das Listenfeld fest, die wir mit rst.Fields.Count <\/b>aus der Anzahl der Felder der Datensatzherkunft beziehen. Als ersten Rückgabewert liefern wir True <\/b>zurück:<\/p>\n Der Schritt acLBOpen <\/b>erwartet wie zuvor den Wert 1<\/b>:<\/p>\n Für die Ermittlung der anzuzeigenden Zeilen im Schritt acLBGetRowCount <\/b>lesen wir dann aus dem in rst <\/b>gespeicherten Recordset die Anzahl der Datensätze und geben diese zurück:<\/p>\n Die Anzahl der zu berücksichtigenden Spalten ermitteln wir mit der Anzahl der Spalten des Recordsets:<\/p>\n Dann erfolgt die Festlegung der Spaltenbreiten. Wenn wir hier keine Werte angeben, werden die Spaltenbreiten übernommen, die wir mit der Eigenschaft Spaltenbreiten <\/b>definiert haben. Da wir aber auch schon die Anzahl der Spalten per Code angegeben haben, wollen wir auch gleich zeigen, wie wir die Spaltenbreiten auf diese Weise angeben. Wir bekommen mit dem Parameter lngColumn <\/b>mit jedem Aufruf die aktuelle Zeile. Wenn gleichzeitig intCode den Wert acLBGetColumnWidth <\/b>enthält, wird die Funktion einmal zur Ermittlung der Breite einer jeden Spalte aufgerufen.<\/p>\n Das nutzen wir wie folgt, indem wir den Wert von lngColumn <\/b>abfragen und den entsprechenden Wert zurückgeben. Die erste Spalte soll beispielsweise die Breite 0<\/b> erhalten, damit die Werte der gebundenen Spalte nicht angezeigt werden:<\/p>\n Für die folgenden Spalten geben wir dann die jeweilige Breite zurück. Diese ermitteln wir aus der Angabe der Zentimeter (zum Beispiel 1,2<\/b>) multipliziert mit dem Faktor 567<\/b>:<\/p>\n Schließlich lesen wir den Wert der jeweiligen Spalte und Zeile aus dem Recordset in das Listenfeld ein. Dabei liefert lngRow <\/b>die Zeile und lngColumn <\/b>die einzulesende Spalte. Wir bewegen den Datensatzzeiger mit der AbsolutePosition<\/b>-Eigenschaft auf den mit lngRow <\/b>angegebenen Datensatz. Den Wert für die gesuchte Spalte entnehmen wir dem Recordsets über die Fields<\/b>-Auflistung mit dem Wert aus lngColumn<\/b> als Parameter und ermitteln den Wert schließlich mit rst.Fields(lngColumn)<\/b>:<\/p>\n Schließlich legen wir mit den folgenden Abschnitten die fehlenden Einstellungen fest, wobei wir acLBClose <\/b>und acLBEnd <\/b>nicht nutzen – diese werden beim Schließen des Formulars ausgelöst:<\/p>\n Nach dem Anzeigen des Formulars in der Formularansicht erhalten wir das Ergebnis aus Bild 4. Wir konnten das Listenfeld damit problemlos mit über 3.000 Kundendatensätzen füllen. Also haben wir diese mehrfach erweitert und schließlich festgestellt, dass wir mit dem Listenfeld unter Verwendung der Callback-Funktion bis zu 65.536 Datensätze anzeigen können.<\/p>\n Bild 4: Listenfeld mit allen Datensätzen<\/span><\/b><\/p>\n Wie aber kann es sein, dass diese Datensätze so schnell eingelesen werden, dass man beim Öffnen des Formulars mit dem Listenfeld quasi keine Verzögerung feststellt? Hinweis: Zur besseren Reproduzierbarkeit haben wir die Spaltenbreite für die erste Spalte hier auf eien Zentimeter eingestellt:<\/p>\n Warum die Performance so gut ist, erfahren wir, wenn wir einen Haltepunkt in den Case<\/b>-Zweig mit dem Wert acLBGetValue <\/b>einfügen oder dort eine If…Then<\/b>-Bedingung mit einer Debug.Print<\/b>-Anweisung wie der folgenden anlegen:<\/p>\n Nun rufen wir das Formular auf und stellen den Direktbereich neben das Listenfeld. Wir leicht zu erkennen, scheint die Callbackfunktion nur für die aktuell sichtbaren Einträge aufgerufen worden zu sein – wobei der 16. Datensatz nur teilweise zu sehen ist (siehe Bild 5).<\/p>\n Bild 5: Ausgabe der per Callbackfunktion gelesenen Datensätze<\/span><\/b><\/p>\n Klicken wir nun auf die Nach unten<\/b>-Taste in der rechten Bildlaufleiste, werden die Einträge 16 <\/b>und 17 <\/b>erneut ausgegeben und so weiter. Klicken wir einen der Einträge an, wird die Callbackfunktion ebenfalls mehrere Male aufgerufen.<\/p>\n Klicken wir auf den Eintrag mit dem Wert 6 <\/b>im Feld KundeID<\/b>, wird die Callbackfunktion nacheinander für die Datensätze 7<\/b>, 6<\/b>, 5<\/b>, 6 <\/b>und wieder 7 <\/b>aufgerufen.<\/p>\n Selbst wenn wir die Breite des Formulars ändern und sich die Listenfeldbreite ebenfalls ändert, weil wir die Eigenschaft Horizontaler Anker <\/b>auf Beide <\/b>eingestellt haben, wird die Callbackfunktion für die angezeigten Datensätze erneut aufgerufen.<\/p>\n Betätigen wir die Tastenkombination Strg + Ende<\/b>, wird die Callbackfunktion nur für die letzten, dann angezeigten Datensätze aufgerufen.<\/p>\n Die gute Performance resultiert also daraus, dass nur die jeweils benötigten Datensätze ermittelt werden, keinesfalls aber alle Einträge der Datensatzherkunft.<\/p>\n Die üblichen Funktionen bei einem mit einer Callbackfunktion gefüllten Listenfeld können wir wie gewohnt nutzen – Markieren von Elementen, Doppelklick auf Elemente, Einstellen von markierten Elementen per Code und so weiter. Wir haben allerdings auch versucht, dieses Listenfeld in einem Beispiel wie im Beitrag Ungebundene Daten in Übersicht und Detailansicht <\/b>(www.access-im-unternehmen.de\/1444<\/b>) beschrieben zu nutzen. <\/p>\n Das gelingt, solange wir die Daten im Listenfeld nicht aktualisieren wollen. Beim Versuch, die Requery<\/b>-Methode aufzurufen, wurde ein scheinbar leeres Listenfeld angezeigt. Erst beim Anklicken einzeler Zeilen wurden Datensätze wieder eingeblendet. Sie können sich das Verhalten gern im Formular frmKundenuebersicht ansehen. Dort klicken Sie doppelt auf einen der Einträge, ändern diesen im Detailformular und schließen dieses dann per OK – danach sollte das beschriebenen Verhalten auftreten. Schreiben Sie mir gern unter andre@minhorst.com<\/b>, wenn Sie hier andere Beobachtungen machen.<\/p>\n Enthaltene Beispieldateien:<\/p>\n UngebundeneListenundKombisPerCallback.accdb<\/p>\nAufbau und Parameter der Callbackfunktion<\/h2>\n
Function <\/span>Beispielcallback(ctl As <\/span>Control, lngID As Long<\/span>, _\r\n lngRow As Long<\/span>, lngColumn As Long<\/span>, _\r\n intCode As Integer<\/span>) As Variant<\/span><\/pre>\n\n
Aufbau der Callbackfunktion<\/h2>\n
\n
Beispiel für eine Callbackfunktion<\/h2>\n
Function <\/span>Beispielcallback(ctl As <\/span>Control, _\r\n lngID As Long<\/span>, lngRow As Long<\/span>, _\r\n lngColumn As Long<\/span>, intCode As Integer<\/span>) _\r\n As Variant<\/span>\r\n Select Case intCode\r\n Case <\/span>acLBInitialize\r\n Beispielcallback = True<\/span>\r\n Case <\/span>acLBOpen\r\n Beispielcallback = 1\r\n Case <\/span>acLBGetRowCount\r\n Beispielcallback = 1\r\n Case <\/span>acLBGetColumnCount\r\n Beispielcallback = 1\r\n Case <\/span>acLBGetColumnWidth\r\n Beispielcallback = -1\r\n Case <\/span>acLBGetValue\r\n Beispielcallback = \"Test\"\r\n Case <\/span>acLBGetFormat\r\n Beispielcallback = Null\r\n Case Else<\/span>\r\n Debug.Print<\/span> intCode\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Listenfeld](\"..\/fileadmin\/_temp_\/2023_04\/pic_1443_002.png\")
<\/p>\nDaten aus einer Tabelle per Callbackfunktion laden<\/h2>\n
![\"Vorbereiten](\"..\/fileadmin\/_temp_\/2023_04\/pic_1443_003.png\")
<\/p>\nDim <\/span>db As <\/span>DAO.Database\r\nDim <\/span>rst As <\/span>DAO.Recordset<\/pre>\nFunction <\/span>Kundenliste(ctl As <\/span>Control, _\r\n lngID As Long<\/span>, lngRow As Long<\/span>, _\r\n lngColumn As Long<\/span>, intCode As Integer<\/span>) _\r\n As Variant<\/span><\/pre>\n Select Case intCode\r\n Case <\/span>acLBInitialize\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset( _\r\n \"SELECT * FROM tblKunden\", dbOpenSnapshot)\r\n rst.MoveLast\r\n rst.MoveFirst\r\n Me!lstKunden.ColumnCount = rst.Fields.Count\r\n Kundenliste = True<\/span><\/pre>\n Case <\/span>acLBOpen\r\n Kundenliste = 1<\/pre>\n Case <\/span>acLBGetRowCount\r\n Kundenliste = rst.RecordCount<\/pre>\n Case <\/span>acLBGetColumnCount\r\n Kundenliste = rst.Fields.Count<\/pre>\n Case <\/span>acLBGetColumnWidth\r\n Select Case lngColumn\r\n Case <\/span>0\r\n Kundenliste = 0<\/pre>\n Case <\/span>1\r\n Kundenliste = 1.2 * 567\r\n Case <\/span>2\r\n Kundenliste = 3 * 567\r\n Case <\/span>3\r\n Kundenliste = 3 * 567\r\n Case <\/span>4\r\n Kundenliste = 4.5 * 567\r\n Case <\/span>5\r\n Kundenliste = 1.5 * 567\r\n Case <\/span>6\r\n Kundenliste = 2.5 * 567\r\n Case <\/span>7\r\n Kundenliste = 3 * 567\r\n End Select<\/span><\/pre>\n Case <\/span>acLBGetValue\r\n rst.AbsolutePosition = lngRow\r\n Kundenliste = rst.Fields(lngColumn)<\/pre>\n Case <\/span>acLBGetFormat\r\n Kundenliste = Null\r\n Case <\/span>acLBClose\r\n Case <\/span>acLBEnd\r\n Case Else<\/span>\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\nTest und maximale Datenmenge<\/h2>\n
![\"Listenfeld](\"..\/fileadmin\/_temp_\/2023_04\/pic_1443_004.png\")
<\/p>\nPerformance<\/h2>\n
Case <\/span>0\r\n Kundenliste = 1 * 567<\/pre>\nIf <\/span>lngColumn = 1 Then<\/span>\r\n Debug.Print<\/span> rst.Fields(lngColumn)\r\nEnd If<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2023_04\/pic_1443_005.png\")
<\/p>\nPraktische Nutzung eines Listenfeldes mit Callbackfunktion<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n