<\/p>\n
Im Beitrag „Daten in ungebundenen Formularen bearbeiten“ haben wir gezeigt, wie man die Daten einer Tabelle in einem ungebundenen Formular darstellt und dieses zum Bearbeiten und Anlegen von Datensätzen verwendet. Wenn wir dies konsequent umsetzen wollen, benötigen wir auch eine Möglichkeit, um Daten in Listenform anzuzeigen. Die Datenblatt- oder Endlosansicht fallen aus, also müssen wir uns um Alternativen kümmern. Für die mehrspaltige Listenansicht bietet Access das Listenfeld. Und für die Auswahl von Daten aus Lookup-Tabellen steht das Kombinationsfeld zur Verfügung. Beide sind jedoch, wie auch Formulare, für die Bindung an Tabellen oder Abfragen optimiert. Ungebundene Daten müssen wir dort erst einmal einpflegen. Auf welche Arten das gelingt, zeigt dieser Beitrag. <\/b><\/p>\nListen- oder Kombinationsfeld<\/h2>\n
Die folgenden Informationen beziehen sich jeweils auf Listen- und Kombinationsfelder, wenn nicht anders angegeben.<\/p>\n
Wenn wir Kombinations- oder Listenfelder an Tabellen oder Abfragen binden, brauchen wir nur noch festzulegen, aus welchen Feldern der Datensatzherkunft die anzuzeigenden Daten stammen und welches Feld als gebundene Spalte genutzt werden soll. Der Rest funktioniert fast automatisch.<\/p>\n
Wenn wir jedoch nicht auf die Datenbindung setzen können, brauchen wir alternative Techniken. Davon gibt es gleich drei, von denen zwei offensichtlich sind und eine nicht. Und von den beiden offensichtlichen können wir auch nur eine für unsere Zwecke nutzen. Bei den offensichtlichen Möglichkeiten reden wir von denen, die neben dem Eintrag Tabelle\/Abfrage <\/b>für die Eigenschaft Herkunftstyp<\/b> zur Verfügung stehen (siehe Bild 1).<\/p>\n
![\"Einstellungen](\"..\/fileadmin\/_temp_\/2023_04\/pic_1440_001.png\")
<\/p>\n
Bild 1: Einstellungen für die Eigenschaft Herkunftstyp<\/span><\/b><\/p>\n Dabei handelt es sich um die Folgenden:<\/p>\n Und es gibt noch eine Möglichkeit, die wir später betrachten werden: Dabei handelt es sich um die sogenannte Callback-Funktion. Dies ist eine Funktion, mit der wir definieren, welche Daten im Kombinations- oder Listenfeld enthalten sein sollen.<\/p>\n Der wesentliche Unterschied ist, dass wir mit dieser Methode mehr Einträge zu einem Kombinations- oder Listenfeld hinzufügen können als mit einer Wertliste. Diese Technik schauen wir uns in einem weiteren Beitrag namens Ungebundene List- und ComboBox per Callback<\/b> (www.access-im-unternehmen.de\/1443<\/b>).<\/p>\n Im ersten Beispiel schauen wir uns an, wie wir ein Kombinationsfeld über eine Wertliste mit den Daten einer Tabelle füllen. Wir wollen dabei extra eine Tabelle mit wenigen Datensätzen nutzen wie die Tabelle tblAnreden<\/b> (siehe Bild 2).<\/p>\n Bild 2: Beispieltabelle zum Füllen eines Kombinationsfeldes<\/span><\/b><\/p>\n Wenn wir nur so wenige Datensätze haben und es sich auch noch um solche Datensätze handelt, die sich eigentlich nie ändern, könnte man versucht sein, diese einfach statisch für die Eigenschaft Datensatzherkunft <\/b>einzustellen. Wenn man gleichzeitig die Eigenschaft Herkunftstyp<\/b> auf Wertliste <\/b>einstellt und die beiden Eigenschaften Spaltenanzahl <\/b>auf 2 <\/b>und Spaltenbreiten <\/b>auf 0cm<\/b>, werden die Daten genau angezeigt wie in einem an die Tabelle tblAnreden <\/b>gebundenen Kombinationsfeld. Die Eigenschaft Datensatzherkunft <\/b>füllen wir wie folgt (siehe Bild 3):<\/p>\n Bild 3: Einstellungen für ein statisch gefülltes Kombinationsfeld<\/span><\/b><\/p>\n Durch die Einstellung von Spaltenanzahl <\/b>auf 2 <\/b>werden jeweils zwei Elemente in einer Zeile angezeigt. Durch die Angabe des Wertes 0cm <\/b>für die Eigenschaft Spaltenbreiten <\/b>wird die erste Spalte dabei mit der Breite 0cm <\/b>angezeigt und die zweite nimmt den Rest der Breite ein. Das Ergebnis sehen wir in Bild 4 – es sieht aus wie ein übliches gebundenes Kombinationsfeld.<\/p>\n Bild 4: Ungebundenes Kombinationsfeld mit Daten<\/span><\/b><\/p>\n Wir wollen das Kombinationsfeld jedoch nicht statisch füllen, sondern auch für den Fall vorbereitet sein, dass die zugrunde liegende Tabelle nicht immer die gleichen Datensätze enthält.<\/p>\n Also fügen wir dem Formular ein weiteres Kombinationsfeld hinzu, dem wir diesmal den Namen cboAnredeRecordset <\/b>geben.<\/p>\n Dabei behalten wir die Einstellung Wertliste <\/b>für die Eigenschaft Herkunftsart <\/b>bei, und auch die beiden Eigenschaften Spaltenanzahl <\/b>und Spaltenbreiten <\/b>belassen wir bei den Werten 2 <\/b>und 0cm<\/b>. Die Eigenschaft Datensatzherkunft <\/b>lassen wir jedoch zunächst leer. Um diese zu füllen, legen wir eine VBA-Prozedur an, die wie in Listing 1aussieht.<\/p>\n Listing 1: Füllen der Wertliste beim Laden des Formulars<\/span><\/b><\/p>\n Sie wird wie folgt durch das Ereignis Bei Laden <\/b>des Formulars ausgelöst:<\/p>\n Diese Prozedur erstellt ein Recordset auf Basis der Tabelle tblAnreden<\/b> und durchläuft in einer Do While<\/b>-Schleife alle Datensätze dieser Tabelle. Dabei fügt sie bei jedem Durchlauf der Schleife die Daten eines Datensatzes zu einer Variablen namens strWertliste <\/b>hinzu. Nach dem Hinzufügen der Daten für den ersten Datensatz sieht der Inhalt von strWertliste <\/b>beispielsweise wie folgt aus:<\/p>\n Nach dem Durchlaufen aller beiden Datensätze erhalten wir fast den gleichen Inhalt wie beim vorherigen Beispiel – mit Ausnahme des abschließenden Semikolons:<\/p>\n Dieses wirkt sich jedoch nicht auf die Darstellung aus, weshalb wir es nicht noch nachträglich entfernen.<\/p>\n Auch mit dieser Vorgehensweise sehen wir nach dem Öffnen des Formulars die beiden Einträge Herr <\/b>und Frau <\/b>im Kombinationsfeld cboAnredenRecordset<\/b>.<\/p>\n Eine weitere Möglichkeit erlaubt das direkte Hinzufügen von Elementen zum Kombinationsfeld. Dabei verwenden wir die AddItem<\/b>-Methode des Kombinationsfeldes. In einer weiteren Prozedur, die wir ebenfalls von der Ereignisprozedur Form_Load <\/b>aus aufrufen, durchlaufen wir dabei ebenfalls eine Do…While<\/b>-Schleife über alle Datensätze der Tabelle tblAnreden<\/b> (siehe Listing 2). Diesmal stellen wir allerdings keine Liste in der Variablen strWertliste<\/b> zusammen, sondern weisen jedes Element direkt mit der AddItem<\/b>-Methode hinzu.<\/p>\n [<\/p>\n Listing 2: Füllen der Wertliste beim Laden des Formulars per AddItem<\/span><\/b><\/p>\n Wenn wir wie zuvor eine zweispaltige Darstellung erhalten wollen, bei der die erste Spalte mit der Breite 0cm <\/b>ausgeblendet wird, müssen wir die Inhalte der beiden Felder AnredeID <\/b>und Anrede <\/b>jeweils mit einem einzigen Aufruf der AddItem<\/b>-Methode hinzufügen, wobei wir beide durch ein Semikolon voneinander trennen und die Zeichenkette in Hochkommata einfassen.<\/p>\n Auch diese Methode liefert das gleiche Ergebnis wie die beiden zuvor beschriebenen. Wenn wir uns den Wert der Eigenschaft Datensatzherkunft <\/b>per VBA im Direktbereich ausgeben lassen, erhalten wir übrigens das folgende Ergebnis:<\/p>\n Die AddItem<\/b>-Methode macht also nichts anderes als die Wertliste zu einer langen Zeichenkette zusammenzusetzen. Sie ermöglicht lediglich noch, über den zweiten Parameter den Index für die Position anzugeben, an welcher der neue Datensatz angelegt werden soll.<\/p>\n Es gibt einen wichtigen Unterschied bei der Zuweisung der anzuzeigenden Daten für Listen, die entweder direkt durch die Zuweisung einer durch Semikola separierten Wertliste oder durch die Verwendung der AddItem<\/b>-Methode gefüllt werden. Das lässt sich an einem Beispiel am besten verdeutlichen:<\/p>\n Wenn wir hier die Eigenschaft Spaltenanzahl <\/b>auf den Wert 1 <\/b>einstellen, interpretiert Access jedes durch ein Semikolon getrenntes Element als Inhalt für eine Spalte. Das sieht dann so aus:<\/p>\n Würden wir Spaltenanzahl <\/b>auf 2 <\/b>einstellen, landen jeweils zwei Werte in den beiden Spalten in einer Zeile.<\/p>\n Bei Verwendung von AddItem <\/b>ist das etwas anders. Angenommen, wir stellen Spaltenanzahl <\/b>auf 1 <\/b>ein und weisen diesen Ausdruck per AddItem <\/b>zu:<\/p>\n Dann verwendet Access tatsächlich nur den Wert vor dem ersten Semikolon, der zweite wird verworfen. Das Ergebnis lautet also:<\/p>\n Wir müssen also hier direkt die Spaltenanzahl korrekt einstellen.<\/p>\n Ansonsten werden die überzähligen Spalten beim Einlesen verworfen und können auch nicht durch anschließendes Ändern der Eigenschaft Spaltenanzahl<\/b> zurückgeholt werden.<\/p>\n Nun wollen wir herausfinden, wo die Grenzen von Wertlisten liegen. Dazu haben wir zunächst die Tabelle tblKunden <\/b>mit einigen tausend Datensätzen gefüllt (siehe Bild 5).<\/p>\n Bild 5: Beispieltabelle mit vielen Datensätzen<\/span><\/b><\/p>\n Mit diesen wollen wir ein weiteres Kombinationsfeld namens cboKundenAddItem <\/b>füllen, das ansonsten die gleichen Einstellungen wie die vorherigen Beispiele enthält. Den Code haben wir insofern geändert, als das wir ein paar mehr Informationen in der zweiten Spalte ausgeben wollen – Anrede, Vorname und Nachname, jeweils durch ein Leerzeichen voneinander getrennt.<\/p>\n Diese Aufgaben hat die Prozedur aus Listing 3 übernommen, deren Aufruf wir ebenfalls in der Ereignisprozedur Form_Load <\/b>untergebracht haben. Das Ergebnis war interessant: Es wurden schlicht nicht alle Einträge zum Kombinationsfeld hinzugefügt, sondern nur 1.2. Was ist mit den übrigen Einträgen geschehen – und warum gab es keine Fehlermeldung? Um dies herauszufinden, haben wir der Prozedur in der Schleife eine Debug.Print<\/b>-Anweisung hinzugefügt, mit der wie den Index des aktuellen Datensatzes des Recordsets, die Länge der in der Eigenschaft Datensatzherkunft (RowSource<\/b>) gespeicherten Zeichenkette sowie die Anzahl der Einträge des Listenfeldes (ListCount<\/b>).<\/p>\n Listing 3: Füllen der Wertliste mit vielen Einträgen<\/span><\/b><\/p>\n Das Ergebnis: Ab einem bestimmten Eintrag hat die Prozedur schlicht keine neuen Einträge mehr hinzugefügt. Um zu prüfen, ob dieses Ergebnis von einer maximal zulässigen Länge der Zeichenkette abhängt, haben wir den Nachnamen aus der AddItem<\/b>-Methode entfernt:<\/p>\n Damit konnten nun einige hundert Einträge mehr angelegt werden. Die Frage ist nur, warum es keine Fehlermeldung gibt, wenn keine weiteren Einträge hinzugefügt werden können. Tatsache ist: Für sehr viele Daten ist diese Methode jedenfalls nicht geeignet.<\/p>\n Um die mögliche Länge der Eigenschaft Datensatzherkunft<\/b> genauer zu untersuchen, haben wir noch ein weiteres Kombinationsfeld namens cboKundenWertliste <\/b>hinzugefügt. Dieses füllen wir mit einer Prozedur namens cboKundenWertlisteFuellen<\/b> (siehe Listing 4).<\/p>\n Listing 4: Füllen mit sehr vielen Kundendaten<\/span><\/b><\/p>\n Hier haben wir die Kundendaten, die wir im vorherigen Beispiel mit der AddItem<\/b>-Methode Stück für Stück zum Kombinationsfeld hinzugefügt haben, zuerst in eine Variable namens strWertliste <\/b>geschrieben und diese dann der Eigenschaft Datensatzherkunft <\/b>zugewiesen.<\/p>\n Bei einer Länge von 73.870 Zeichen führt dies in der folgenden Zeile zum Fehler:<\/p>\n Den Fehler zeigt Bild 6. Durch Experimentieren haben wir schließlich herausgefunden, dass diese Kombinationsfeld genau 32.750 Zeichen aufnimmt. Genau genommen haben wir uns diese Arbeit durch einige zusätzliche Zeilen abnehmen lassen, die wir im Anschluss an das Zusammenstellen von strWertliste <\/b>eingebaut haben.<\/p>\n Bild 6: Laufzeitfehler beim Hinzufügen einer zu langen Wertliste<\/span><\/b><\/p>\n Hier haben wir in einer For…Next<\/b>-Schleife so lange die zuzuweisende Zeichenkette um jeweils ein Zeichen verkürzt, bis dies keinen Fehler mehr auslöste.<\/p>\n Anschließend haben wir uns die Anzahl der Zeichen im Direktbereich ausgeben lassen:<\/p>\n Wir sehen also: Der Verwendung von Wertlisten als ungebundene Datenquelle von Kombinations- und Listenfeldern sind Grenzen gesetzt.<\/p>\n Da Access bei Verwendung von AddItem <\/b>zum Füllen eines Kombinations- oder Listenfeldes keinen Fehler auslöst, wenn keine weiteren Daten aufgenommen werden können, haben wir Bedarf für eine Optimierung: Die Schleife über die Datensätze des Recordsets läuft nämlich dennoch weiter und das kostet Zeit. Wir können nun nach jedem Durchlauf prüfen, ob der aktuelle Datensatz überhaupt in die Datensatzherkunft aufgenommen wurde.<\/p>\n Dazu müssten wir prüfen, ob sich die Anzahl der Elemente des Kombinations- oder Listenfeldes seit dem letzten Aufruf von AddItem <\/b>verändert hat, was wiederum in jedem Durchlauf geschehen müsste. Das bedeutet eine zusätzliche Operation innerhalb einer Schleife, die gegebenenfalls sehr oft durchlaufen wird. Die Frage ist, ob es mehr Zeit kostet, wenn die Schleife einige Male umsonst durchlaufen wird, oder wenn wir nach jedem AddItem<\/b>-Aufruf eine entsprechende Prüfung durchführen.<\/p>\n Dies hängt letztlich von der Menge der Datensätze im Recordset ab. Wir fügen beispielsweise der Prozedur cboKundenAddItemFuellen <\/b>die folgende Variable hinzu:<\/p>\n In der Schleife vergleichen wir die Anzahl der Listenelemente mit dem in lngMengeVorher <\/b>gespeicherten Wert. Ist die Anzahl gleich, wurde kein neuer Eintrag mehr angelegt und wir können die Schleife verlassen. Danach speichern wir die neue aktuelle Anzahl der Listeneinträge in der Variablen lngMengeVorher<\/b>:<\/p>\n Dadurch wird die Schleife nach dem ersten vergeblichen Versuch, ein weiteres Element hinzuzufügen, verlassen.<\/p>\n Dennoch ein kurzer Blick auf die Verwendung eines Listenfeldes als Ersatz für die Datenblatt- oder Endlosformularansicht. Hier richtet sich unser Fokus zunächst darauf, mehrere Felder einer Tabelle in den Spalten eines Listenfeldes darzustellen. <\/p>\n Dazu legen wir ein neues Formular namens frmListenfeldUngebunden <\/b>an und fügen diesem ein neues Listenfeld-Steuerelement namens lstKundenUngebunden <\/b>hinzu. Für dieses stellen wir wieder die Eigenschaft Herkunftsart<\/b> auf Wertliste <\/b>ein.<\/p>\n Außerdem legen wir die Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>auf den Wert Beide <\/b>fest. Als Prozedur zum Füllen verwenden wir die Ereignisprozedur, die durch das Ereignis Bei Laden <\/b>des Formulars ausgelöst wird (siehe Listing 5). Diese enthält eine ähnliche Anweisung wie die zum Füllen des Kombinationsfeldes weiter oben und verwendet wieder die AddItem<\/b>-Methode zum Hinzufügen der Daten zum Listenfeld. In der Do While<\/b>-Schleife zum Durchlaufen der Einträge haben wir direkt eine Bedingung untergebracht, die prüft, ob im aktuellen Durchlauf ein neues Element hinzugefügt wurde. Wenn das nicht der Fall ist, verlässt die Prozedur die Schleife mit der Exit Do<\/b>-Anweisung.<\/p>\n Listing 5: Füllen des Listenfeldes mit der AddItem-Methode<\/span><\/b><\/p>\n Da Ergebnis sieht nach dem Einstellen der Spaltenanzahl <\/b>auf den Wert 8 <\/b>wie in Bild 7 aus. Um die Spaltenbreiten zu optimieren, nutzen wir hier die Layoutansicht für Formulare. Damit können wir einige Eigenschaften anpassen und sehen direkt nach der Eingabe die Auswirkung im Formular.<\/p>\n Bild 7: Mehrspaltiges Listenfeld mit Kundendaten<\/span><\/b><\/p>\n Im Beitrag Daten in ungebundenen Formularen bearbeiten <\/b>(www.access-im-unternehmen.de\/1442<\/b>) haben wir bereits ein Formular vorgestellt, mit dem wir die Daten aus einer Tabelle in einem ungebundenen Formular bearbeiten, neu anlegen und wieder in der Tabelle speichern können.<\/p>\n In dem oben vorgestellten Listenfeld können wir die Daten nicht wie in der Datenblatt- oder Endlosformularansicht bearbeiten. Deshalb müssen wir eine Alternative schaffen. Diese lautet: Wir rufen nach einem Doppelklick auf einen der Einträge des Listenfeldes das Detailformular zu diesem Datensatz auf. Wie das im Detail gelingt, zeigen wir im Beitrag Ungebundene Daten in Übersicht und Detailansicht <\/b>(www.access-im-unternehmen.de\/1444<\/b>).<\/p>\n Die oben vorgestellten Beispiele haben die Grenzen von Kombinations- und Listenfeldern für die ungebundene Anzeige von Daten aufgezeigt: Die Menge der angezeigten Daten ist begrenzt, und zwar auf rund 32.750 Zeichen.<\/p>\n Um dies zu umgehen, gibt es verschiedene Möglichkeiten. Man könnte immer nur eine begrenzte Menge an Datensätzen anzeigen und zwei Schaltflächen zum Vor- und Zurückblättern hinzufügen. Dann würden immer die nächsten beziehungsweise vorherigen Datensätze geladen.<\/p>\n Oder man fügt dem Formular mit dem Listenfeld Textfelder hinzu, mit denen der Benutzer nach den Inhalten der einzelnen Spalten suchen beziehungsweise filtern kann.<\/p>\n Auch hier würde man zu Beginn nur eine bestimmte Anzahl Datensätze anzeigen, die der aktuellen Sortierung nach einem bestimmten Feld entsprechen. Nach dem Eingeben eines Suchkriteriums wird das Listenfeld auf Basis dieses Kriteriums neu gefüllt.<\/p>\n Wie wir sehen, ist es grundsätzlich möglich, Kombinations- und Listenfelder nicht nur durch direkte Bindung an Tabellen oder Abfragen mit Daten zu füllen, sondern auch durch das direkte Zuweisen einer Wertliste oder das Einfügen einzelner Elemente mit der AddItem<\/b>-Methode.<\/p>\n Wir haben auch erkannt, dass es bei dieser Methode eine Grenze gibt, die in der Anzahl der Zeichen liegt, die im Listenfeld als Datensatzherkunft verwendet werden.<\/p>\n Deshalb schauen wir uns in einem weiteren Beitrag namens Listen- und Kombinationsfelder per Callback füllen <\/b>(www.access-im-unternehmen.de\/1443<\/b>) eine alternative Möglichkeit an und prüfen, ob diese die Anzeige umfangreicherer Datenmengen erlaubt.<\/p>\n In einigen weiteren Beiträgen werfen wir einen Blick darauf, wie wir aus den gelernten Techniken aus diesem Beitrag und aus dem Beitrag Daten in ungebundenen Formularen bearbeiten <\/b>(www.access-im-unternehmen.de\/1442<\/b>) eine Mini-Anwendung erstellen können, die komplett auf die Bindung von Formularen und Steuerelementen an Tabellen oder Abfragen verzichtet.<\/p>\n Enthaltene Beispieldateien:<\/p>\n UngebundeneListenundKombisMitDatenFuellen.accdb<\/p>\n\n
Weitere Variante: Callback-Funktion<\/h2>\n
Kombinationsfeld per Wertliste füllen<\/h2>\n
![\"Beispieltabelle](\"..\/fileadmin\/_temp_\/2023_04\/pic_1440_002.png\")
<\/p>\n![\"Einstellungen](\"..\/fileadmin\/_temp_\/2023_04\/pic_1440_003.png\")
<\/p>\n\"1\";\"Herr\";\"2\";\"Frau\"<\/pre>\n
![\"Ungebundenes](\"..\/fileadmin\/_temp_\/2023_04\/pic_1440_004.png\")
<\/p>\nKombinationsfeld aus Recordset füllen<\/h2>\n
Private Sub <\/span>cboAnredeRecordsetFuellen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strWertliste As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblAnreden\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n strWertliste = strWertliste & rst!AnredeID & \";''\" & rst!Anrede & \"'';\"\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n Me!cboAnredenRecordset.RowSource = strWertliste\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\r\n cboAnredeRecordsetFuellen\r\nEnd Sub<\/span><\/pre>\n1;''Herr'';<\/pre>\n
1;''Herr'';2;''Frau'';<\/pre>\n
Alternative Variante für das Hinzufügen per Recordset<\/h2>\n
Private Sub <\/span>cboAnredeRecordsetAddItemFuellen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strWertliste As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblAnreden\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Me!cboAnredenRecordsetAddItem.AddItem rst!AnredeID & \";''\" & rst!Anrede & \"''\"\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n Screen.ActiveControl.RowSource\r\n1;''Herr'';2;''Frau''<\/pre>\n
Hinweis zur Angabe der Spaltenzahl<\/h2>\n
lst.RowSource = \"1;''Wert 1'';2;''Wert 2\"<\/pre>\n
1\r\nWert 1\r\n2 \r\nWert 2<\/pre>\n
lst.AddItem 1;''Wert 1''<\/pre>\n
1\r\n2<\/pre>\n
Grenzen von Wertlisten<\/h2>\n
![\"Beispieltabelle](\"..\/fileadmin\/_temp_\/2023_04\/pic_1440_005.png\")
<\/p>\nPrivate Sub <\/span>cboKundenAddItemFuellen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strWertliste As String<\/span>\r\n Dim <\/span>lngCount As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblKunden\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Me!cboKundenAddItem.AddItem rst!KundeID & \";''\" & rst!Anrede & \" \" & rst!Vorname & \" \" & rst!Nachname & \"''\"\r\n Debug.Print<\/span> lngCount, Len<\/span>(Me!cboKundenAddItem.RowSource), Me!cboKundenAddItem.ListCount\r\n lngCount = lngCount + 1\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\nMe!cboKundenAddItem.AddItem rst!KundeID & \";''\" _\r\n & rst!Anrede & \" \" & rst!Vorname & \"''\" <\/pre>\n
Fehler beim Hinzufügen einer überlangen Wertliste<\/h2>\n
Private Sub <\/span>cboKundenWertlisteFuellen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strWertliste As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblKunden\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n strWertliste = strWertliste & rst!KundeID & \";''\" & rst!Vorname & \"'';''\" & rst!Nachname & \"'';\"\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n Me!cboKundenWertliste.RowSource = strWertliste\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\nMe!cboKundenWertliste.RowSource = strWertliste<\/pre>\n
![\"Laufzeitfehler](\"..\/fileadmin\/_temp_\/2023_04\/pic_1440_006.png\")
<\/p>\nDim <\/span>lngLaenge As Long<\/span>\r\nFor lngLaenge = Len<\/span>(strWertliste) To 1 Step -1\r\n On Error Resume Next<\/span>\r\n strWertliste = Left<\/span>(strWertliste, lngLaenge)\r\n Debug.Print<\/span> Me.cboKundenWertliste.RowSource\r\n Me!cboKundenWertliste.RowSource = strWertliste\r\n If <\/span>Err.Number = 0 Then<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\nNext<\/span> lngLaenge\r\nDebug.Print<\/span> \"Maximale Zeichenzahl: \" & lngLaenge<\/pre>\nAbbruch, wenn die Datensatzherkunft voll ist?<\/h2>\n
Dim <\/span>lngMengeVorher As Long<\/span><\/pre>\nIf <\/span>Me!lstKundenUngebunden.ListCount = lngMengeVorher Then<\/span>\r\n Exit Do<\/span>\r\nEnd If<\/span>\r\nlngMengeVorher = Me!lstKundenUngebunden.ListCount<\/pre>\nListenfeld statt Datenblatt<\/h2>\n
Private Sub <\/span>Form_Load()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>lngMengeVorher As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblKunden\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Me!lstKundenUngebunden.AddItem rst!KundeID & \";''\" & rst!Anrede & \"'';''\" & rst!Vorname & \"'';''\" & rst!Nachname _\r\n & \"'';''\" & rst!Strasse & \"'';''\" & rst!PLZ & \"'';''\" & rst!Ort & \"'';''\" & rst!Land & \"''\"\r\n If <\/span>Me!lstKundenUngebunden.ListCount = lngMengeVorher Then<\/span>\r\n Exit Do<\/span>\r\n End If<\/span>\r\n lngMengeVorher = Me!lstKundenUngebunden.ListCount\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n![\"Mehrspaltiges](\"..\/fileadmin\/_temp_\/2023_04\/pic_1440_007.png\")
<\/p>\nAnzeige von zu bearbeitenden Datensätzen<\/h2>\n
Suchen und Sortieren von ungebundenen Listen<\/h2>\n
Zusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n