{"id":55001609,"date":"2026-08-01T00:00:00","date_gmt":"2026-07-04T14:10:29","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1609"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Gebundene_abhaengige_Kombinationsfelder","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/","title":{"rendered":"Gebundene abhängige Kombinationsfelder"},"content":{"rendered":"

Im Beitrag „Abhängige Kombinationsfelder“ (www.access-im-unternehmen.de\/****) haben wir beschrieben, wie wir per 1:n-Beziehung verknüpfte Daten in zwei aufeinanderfolgenden Kombinationsfeldern erst filtern und dann auswählen können. Im vorliegenden Beitrag gehen wir einen Schritt weiter und schauen uns an, wie wir abhängige Kombinationsfelder in gebundenen Formularen darstellen. In Formularen in der Einzelansicht gelingt dies ohne Probleme. In der Endlosansicht und der Datenblattansicht stoßen wir jedoch auf Einschränkungen, die wir mehr oder weniger gut umgehen können. Wie das gelingt, lesen Sie ebenfalls in diesem Beitrag.<\/b><\/p>\n

Datenmodell der Beispieldatenbank<\/h2>\n

Die Beispieldatenbank erweitert das Modell aus dem ersten Beitrag um eine Ebene.<\/p>\n

In tblKategorien<\/b> stehen die Kategorien, in tblUnterkategorien<\/b> die Unterkategorien – jede Unterkategorie gehört über den Fremdschlüssel KategorieID<\/b> zu genau einer Kategorie.<\/p>\n

Die Produkte in tblProdukte<\/b> verweisen mit den beiden Fremdschlüsseln KategorieID<\/b> und UnterkategorieID<\/b> zugleich auf ihre Kategorie und ihre Unterkategorie (siehe Bild 1).<\/p>\n

\"Das<\/p>\n

Bild 1: Das Datenmodell mit tblKategorien, tblUnterkategorien und tblProdukte<\/span><\/b><\/p>\n

So entstehen zwei gestufte 1:n-Beziehungen, an denen sich das Zusammenspiel gebundener abhängiger Kombinationsfelder gut zeigen lässt.<\/p>\n

Außerdem haben wir noch eine 1:n-Beziehung zwischen den Tabellen tblKategorien<\/b> und tblUnterkategorien <\/b>hinzugefügt, damit festgelegt ist, welche Unterkategorien zu welcher Kategorie gehören.<\/p>\n

Abhängige Kombinationsfelder in gebundenen Formularen<\/h2>\n

In der Einzelansicht ist die Sache unkompliziert. Als Beispiel dient das Formular frmProdukteDetail<\/b>, das an die Tabelle tblProdukte<\/b> gebunden ist und ihre Felder in vier Steuerelementen zeigt (siehe Bild 2): die Textfelder ProduktID<\/b> und Produkt<\/b> sowie die beiden Kombinationsfelder cboKategorieID<\/b> und cboUnterkategorieID<\/b>, die an die Fremdschlüssel KategorieID<\/b> und UnterkategorieID<\/b> gebunden sind. Zum Erstellen dieses Formulars haben wir als Datensatzquelle die Tabelle tblProdukte <\/b>eingestellt und alle Einträge der Feldliste in den Detailbereich gezogen.<\/p>\n

\"Der<\/p>\n

Bild 2: Der Entwurf des Formulars frmProdukteDetail<\/span><\/b><\/p>\n

Als Datensatzherkunft erhält cboKategorieID<\/b> eine Abfrage über alle Kategorien:<\/p>\n

SELECT [tblKategorien].[KategorieID], [tblKategorien].[Kategorie] FROM tblKategorien ORDER BY [Kategorie];<\/pre>\n
Das abhängige Feld cboUnterkategorieID<\/b> bekommt zunächst eine Abfrage über sämtliche Unterkategorien als Datensatzherkunft – diese Liste schränken wir gleich per VBA auf die gewählte Kategorie ein.<\/p>\n
SELECT [tblUnterkategorien].[UnterkategorieID], [tblUnterkategorien].[Unterkategorie] FROM tblUnterkategorien ORDER BY [Unterkategorie];<\/pre>\n
Den eigentlichen Mechanismus übernimmt die Ereignisprozedur cboKategorieID_AfterUpdate<\/b>, die wir für das Ereignis Nach Aktualisierung<\/b> des Kombinationsfeldes cboKategorieID<\/b> hinterlegen (siehe Listing 1).<\/p>\n
Private Sub <\/span>cboKategorieID_AfterUpdate()\r\n    Dim <\/span>strSQL As String<\/span>\r\n    strSQL = \"SELECT UnterkategorieID, Unterkategorie FROM tblUnterkategorien WHERE KategorieID = \" _\r\n        & Me.cboKategorieID & \" ORDER BY Unterkategorie\"\r\n    With<\/span> Me.cboUnterkategorieID\r\n        .Value = Null\r\n        .RowSource = strSQL\r\n        .SetFocus\r\n        .Dropdown\r\n    End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Die Unterkategorien an die gewählte Kategorie anpassen<\/span><\/b><\/p>\n
Wir stellen eine SELECT<\/b>-Anweisung zusammen, die nur die Unterkategorien der gewählten Kategorie liefert; das Kriterium bildet der gebundene Wert von cboKategorieID<\/b>, also die KategorieID<\/b>. Innerhalb eines With<\/b>-Blocks setzen wir cboUnterkategorieID<\/b> zunächst mit Value = Null<\/b> zurück – so verschwindet eine womöglich noch gespeicherte, nicht mehr passende Unterkategorie -, weisen anschließend die neue Datensatzherkunft zu und klappen die Liste über SetFocus<\/b> und Dropdown<\/b> gleich auf.<\/p>\n
Das Ergebnis zeigen die beiden folgenden Abbildungen: Bild 3 hält die Auswahl einer Kategorie im Feld cboKategorieID<\/b> fest.<\/p>\n
\"Auswahl<\/p>\n
Bild 3: Auswahl einer Kategorie im Feld cboKategorieID<\/span><\/b><\/p>\n
Unmittelbar nach der Auswahl eines dieser Einträge bietet cboUnterkategorieID<\/b> nur noch die dazugehörigen Einträge an (siehe Bild 4).<\/p>\n
\"Das<\/p>\n
Bild 4: Das gefilterte Kombinationsfeld cboUnterkategorieID nach der Kategorieauswahl<\/span><\/b><\/p>\n
In der Einzelansicht war das – wie versprochen – ohne Hürden. Interessant, und stellenweise widerspenstig, wird es in der Endlos- und der Datenblattansicht; ihnen wenden wir uns im nächsten Abschnitt zu.<\/p>\n
Abhängige Kombinationsfelder in gebundenen Endlosformularen<\/h2>\n
Um die abhängigen Kombinationsfelder in einem Endlosformular zu nutzen, bauen wir das Formular zunächst wie zuvor auf und speichern dieses unter dem Namen frmProdukteEndlos<\/b>. Hier nutzen wir nun die Anordnen-Funktion von Access.<\/p>\n
Wir markieren zunächst alle Steuerleemente des Formulars. Dann wählen wir im Ribbon unter Anordnen den Befehl Tabelle|Tabelle <\/b>aus. Dies verschiebt die Bezeichnungsfelder in den Formularkopf und belässt die gebundenen Steuerelemente im Detailbereich. Außerdem werden die Steuerelemente tabellarisch wie in Bild 5 angeordnet.<\/p>\n
\"Entwurf<\/p>\n
Bild 5: Entwurf des Formulars in der Endlosansicht<\/span><\/b><\/p>\n
Anschließend markieren wir die Anordnung und entfernen diese durch einen Klick auf Tabelle|Layout entfernen<\/b>.<\/p>\n
Außerdem stellen wir für die Eigenschaft Standardansicht <\/b>den Wert Endlosformular <\/b>ein.<\/p>\n
Für das Ereignis Nach Aktualisierung<\/b> des Steuerelements cboKategorieID <\/b>hinterlegen wir wieder die folgende Ereignisprozedur:<\/p>\n
Private Sub <\/span>cboKategorieID_AfterUpdate()\r\n    Dim <\/span>strSQL As String<\/span>\r\n    strSQL = \"SELECT UnterkategorieID, Unterkategorie \" _\r\n        & \"FROM tblUnterkategorien WHERE KategorieID = \" _\r\n        & Me.cboKategorieID & \" ORDER BY Unterkategorie\"\r\n    With<\/span> Me.cboUnterkategorieID\r\n        .Value = Null\r\n        .RowSource = strSQL\r\n        .SetFocus\r\n        .Dropdown\r\n    End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Verhalten der abhängigen Kombinationsfelder im Endlosformular<\/h2>\n
Danach wechseln wir in die Endlosformular-Ansicht und legen einen neuen Datensatz an, für den wir den Produktnamen festlegen. Wir können nun im Feld cboUnterkategorieID <\/b>noch alle verfügbaren Kategorien auswählen (siehe Bild 6). Für bereits vorhandene Datensätze werden die Unterkategorien noch korrekt angezeigt.<\/p>\n
\"Auswahl<\/p>\n
Bild 6: Auswahl der Unterkategorie ohne vorherige Auswahl einer Kategorie<\/span><\/b><\/p>\n
Hier treffen wir keine Auswahl, sondern selektieren zunächst eine Kategorie. Anschließend klappen wir erneut das Kombinationsfeld cboUnterkategorieID<\/b> auf.<\/p>\n
Wie Bild 7 zeigt, hat die Prozedur cboUnterkategorieID_AfterUpdate <\/b>korrekt funktioniert: Das Kombinationsfeld cboUnterkategorieID <\/b>zeigt nur noch die zu der gewählten Kategorie gehörenden Unterkategorien an.<\/p>\n
\"Auswahl<\/p>\n
Bild 7: Auswahl der Unterkategorie nach vorheriger Auswahl einer Kategorie<\/span><\/b><\/p>\n
Wenn wir eine Unterkategorie ausgewählt haben und den Datensatz verlassen, geschieht jedoch etwas, mit dem wir zunächst nicht gerechnet haben: Das Feld UnterkategorieID <\/b>wird für alle Datensätze, deren Kategorie nicht der zuletzt gewählten Kategorie entspricht, geleert (siehe Bild 8).<\/p>\n
\"Verschiedene<\/p>\n
Bild 8: Verschiedene Unterkategorien werden scheinbar willkürlich geleert.<\/span><\/b><\/p>\n
Das Verhalten ändert sich, wenn wir die Kategorie und die Unterkategorie für einen vorhanden Datensatz neu auswählen.<\/p>\n
Hier bleiben zunächst alle Einträge im Steuerelement cboUnterkategorieID <\/b>erhalten. Erst wenn wir einen Datensatz markieren, dessen Kategorie nicht der zuletzt gewählten Kategorie entspricht, wird dessen Feld cboUnterkategorieID <\/b>geleert.<\/p>\n
Der Grund ist in beiden Fällen schnell erläutert: Wir filtern die Datensatzherkunft von cboUnterkategorieID, sodass die anzuzeigenden Werte für die Datensätze mit einer anderen übergeordneten Kategorie nicht mehr verfügbar sind. Dadurch können diese schlicht nicht mehr angezeigt werden.<\/p>\n
Tatsächlich sind die gespeicherten Werte für alle Datensätze der Tabelle noch vorhanden, wovon wir uns durch das Schließen und erneute Öffnen des Formulars frmProdukteEndlos <\/b>überzeugen können (siehe Bild 9).<\/p>\n
\"Nach<\/p>\n
Bild 9: Nach dem erneuten Öffnen des Formulars sind alle Unterkategorien wieder sichtbar.<\/span><\/b><\/p>\n
Dennoch ist dieses Verhalten äußerst ungünstig, denn wir wollen den Benutzer nicht unnötig verwirren.<\/p>\n
Einfache Lösung zum Anzeigen aller Unterkategorien<\/h2>\n
Unsere Idee zu diesem Problem ist, die Datensatzherkunft des Kombinationsfeldes cboUnterkategorieID <\/b>nach dem Verlassen des zuletzt bearbeiteten Datensatzes wieder auf die Abfrage einzustellen, die alle Unterkategorien liefert.<\/p>\n
Dazu können wir am einfachsten das Ereignis Nach Aktualisierung <\/b>von cboUnterkategorieID <\/b>verwenden. Für dieses hinterlegen wir die Ereignisprozedur aus Listing 2.<\/p>\n
Private Sub <\/span>cboUnterkategorieID_AfterUpdate()\r\n    Dim <\/span>strSQL As String<\/span>\r\n    strSQL = \"SELECT UnterkategorieID, Unterkategorie FROM tblUnterkategorien ORDER BY Unterkategorie\"\r\n    With<\/span> Me.cboUnterkategorieID\r\n        .RowSource = strSQL\r\n    End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 2: Zurücksetzen der Datensatzherkunft von cboUnterkategorieID<\/span><\/b><\/p>\n
Wenn wir einen Datensatz speichern, dessen Kategorie wir geändert und damit die Datensatzherkunft gefiltert haben, erhält das Kombinationsfeld cboUnterkategorieID <\/b>wieder alle Unterkategorien zur Auswahl. Somit zeigt dieses Kombinationsfeld nach dem Speichern auch nach dem Speichern des Datensatzes wieder alle Unterkategorien für die übrigen Datensätze an.<\/p>\n
Nachteil dieser Lösung<\/h2>\n
Der einzige offensichtliche Nachteil dieser Vorgehensweise ist, dass nun beim Auswählen der Unterkategorie für jeden Datensatz alle Einträge angezeigt werden – unabhängig davon, welche Kategorie für diesen Datensatz ausgewählt wurde (siehe Bild 10).<\/p>\n
\"Nun<\/p>\n
Bild 10: Nun können alle Unterkategorien für einen Datensatz ausgewählt werden.<\/span><\/b><\/p>\n
Auswahl der Unterkategorie einschränken<\/h2>\n
Wir wünschen uns, dass wir das Kombinationsfeld cboUnterkategorieID <\/b>öffnen können und dass nur die zur Kategorie passenden Unterkategorien angezeigt werden – ohne, dass die Unterkategorien der übrigen Datensätze ausgeblendet werden.<\/p>\n
Das realisieren wir über einige Umwege, die wir nachfolgend genau erläutern.<\/p>\n
Die Grundidee<\/h2>\n
Der Ausweg ist verblüffend einfach, wenn man ihn einmal gesehen hat: Wir drehen die Sache um.<\/p>\n
Statt die Liste dauerhaft einzuschränken, lassen wir sie die ganze Zeit vollständig – mit allen Unterkategorien. Dann findet jede Zeile ihren gespeicherten Wert in der Liste und zeigt ihn an.<\/p>\n
Nur für den kurzen Moment, in dem der Benutzer in einer Zeile tatsächlich eine neue Unterkategorie auswählt, blenden wir die passende, kurze Liste ein. Sobald er fertig ist, schalten wir wieder auf die vollständige Liste zurück.<\/p>\n
Man kann sich das wie eine Speisekarte vorstellen: Würde man alle Gerichte bis auf eine Kategorie durchstreichen, stünden alle Tische, die schon etwas anderes bestellt haben, plötzlich ohne Angabe da. Also lassen wir die volle Karte hängen und reichen nur dem Tisch, der gerade neu bestellt, für einen Augenblick die kurze Auswahl.<\/p>\n
Wenn sich die Kategorie ändert<\/h2>\n
Beginnen wir mit dem ersten Feld. Wählt der Benutzer in der aktuellen Zeile eine Kategorie, bauen wir die Liste des Unterkategorie-Feldes passend dazu neu auf, wie Listing 3 zeigt.<\/p>\n
Private Sub <\/span>cboKategorieID_AfterUpdate()\r\n    Dim <\/span>strSQL As String<\/span>\r\n    strSQL = \"SELECT UnterkategorieID, Unterkategorie FROM tblUnterkategorien WHERE KategorieID = \" _\r\n        & Me.cboKategorieID & \" ORDER BY Unterkategorie\"\r\n    With<\/span> Me.cboUnterkategorieID\r\n        .Value = Null\r\n        .RowSource = strSQL\r\n        .SetFocus\r\n        .Dropdown\r\n    End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 3: Nach der Kategoriewahl die passenden Unterkategorien zeigen<\/span><\/b><\/p>\n
Wir setzen cboUnterkategorieID<\/b> zunächst mit Value = Null<\/b> zurück, weisen dann die auf die Kategorie gefilterte Liste zu und klappen sie über SetFocus<\/b> und Dropdown<\/b> gleich auf. So weit ist das der bekannte Ablauf aus dem Einzelformular.<\/p>\n
Der Normalzustand: die vollständige Liste<\/h2>\n
Damit alle Zeilen ihren Wert anzeigen, braucht das Unterkategorie-Feld im Ruhezustand die vollständige Liste. Diese kleine Hilfsprozedur stellt sie her (Listing 4).<\/p>\n
Private Sub <\/span>AlleUnterkategorienAnzeigen()\r\n    Dim <\/span>strSQL As String<\/span>\r\n    strSQL = \"SELECT UnterkategorieID, Unterkategorie FROM tblUnterkategorien ORDER BY Unterkategorie\"\r\n    With<\/span> Me.cboUnterkategorieID\r\n        .RowSource = strSQL\r\n    End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 4: Die Liste auf alle Unterkategorien setzen<\/span><\/b><\/p>\n
Sie schreibt schlicht eine Datensatzherkunft ohne Filter in cboUnterkategorieID<\/b> – also alle Unterkategorien.<\/p>\n
Aufgerufen wird sie immer dann, wenn wir zu einem Datensatz wechseln. Dafür sorgt das Ereignis Beim Anzeigen<\/b>, das im Endlosformular für die jeweils aktuelle Zeile ausgelöst wird:<\/p>\n
Private Sub <\/span>Form_Current()\r\n    Call<\/span> AlleUnterkategorienAnzeigen\r\nEnd Sub<\/span><\/pre>\n
Beim Bearbeiten kurz die kurze Liste<\/h2>\n
Jetzt der eigentliche Kniff. Betritt der Benutzer das Unterkategorie-Feld, um eine Auswahl zu treffen, möchten wir ihm nur die passenden Einträge zeigen und die Liste sofort aufklappen.<\/p>\n
Beides lässt sich aber nicht im selben Augenblick erledigen – Access braucht einen winzigen Moment, bis der Wechsel in das Feld abgeschlossen ist. Deshalb arbeiten wir mit einem kurzen Timer, wie folgendes Listing zeigt:<\/p>\n
Private Sub <\/span>cboUnterkategorieID_GotFocus()\r\n    Call<\/span> AlleUnterkategorienAnzeigen\r\n    Me.TimerInterval = 50\r\nEnd Sub<\/span><\/pre>\n
Beim Fokuserhalt stellen wir zunächst wieder die volle Liste her – so bleibt der gespeicherte Wert in allen Datensätzen sichtbar – und setzen dann TimerInterval<\/b> auf 50<\/b>. Damit bitten wir Access, in 50 Millisekunden das Timer-Ereignis auszulösen. Dieses erledigt anschließend die eigentliche Arbeit (siehe Listing 5).<\/p>\n
Private Sub <\/span>Form_Timer()\r\n    Dim <\/span>strSQL As String<\/span>\r\n    Me.TimerInterval = 0\r\n    strSQL = \"SELECT UnterkategorieID, Unterkategorie FROM tblUnterkategorien WHERE KategorieID = \" _\r\n        & Me.cboKategorieID & \" ORDER BY Unterkategorie\"\r\n    With<\/span> Me.cboUnterkategorieID\r\n        .RowSource = strSQL\r\n        .SetFocus\r\n        .Dropdown\r\n    End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 5: Kurz darauf die gefilterte Liste zeigen und aufklappen<\/span><\/b><\/p>\n
Zuerst schalten wir den Timer mit TimerInterval = 0<\/b> wieder aus, damit er nur ein einziges Mal feuert. Dann bauen wir die auf die aktuelle Kategorie gefilterte Liste, setzen den Fokus und klappen sie auf. Für den Benutzer sieht es aus, als öffne sich sofort die richtige, kurze Liste. Er sieht maximal ganz kurz das Aufklappen der vollständigen Liste.<\/p>\n
Auch der Mausklick soll es auslösen<\/h2>\n
Nicht jeder betritt ein Feld mit der Tastatur – viele klicken es einfach an. Diesen Fall fangen wir zusätzlich ab, indem wir das Ereignis MouseDown <\/b>von cboUnterkategorieID <\/b>implementieren (siehe Listing 6).<\/p>\n
Private Sub <\/span>cboUnterkategorieID_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n    If <\/span>fIsComboOpen = True<\/span> Then<\/span>\r\n        Exit Sub<\/span>\r\n    End If<\/span>\r\n    If <\/span>Not<\/span> Y > Me.cboUnterkategorieID.Top + Me.cboUnterkategorieID.Height Then<\/span>\r\n        Call<\/span> cboUnterkategorieID_GotFocus\r\n    End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 6: Beim Anklicken dieselbe Auswahl-Logik starten<\/span><\/b><\/p>\n
Zuerst fragen wir mit der Hilfsfunktion fIsComboOpen<\/b> nach, ob bereits eine Liste offen ist – wenn ja, tun wir nichts weiter. Diese Funktion stammt aus einem eigenen Modul namens mdlAPI <\/b>und meldet über die Windows-API, ob ein Kombinationsfeld gerade aufgeklappt ist.<\/p>\n
Andernfalls prüfen wir, ob der Klick oben auf das Feld selbst ging und nicht in die bereits geöffnete Liste darunter, und rufen dann dieselbe Prozedur wie beim Fokuserhalt auf.<\/p>\n
Warum diese Hilfsfunktion? Wenn wir zum Beispiel über die Auswahl einer Kategorie bereits das Kombinationsfeld cboUnterkategorieID <\/b>geöffnet haben oder auch durch einen Mausklick auf das Steuerelement selbst, und klicken dann erneut darauf, soll sich das Kombinationsfeld wie üblich einfach wieder schließen.<\/p>\n
Da Access keine eingebaute Möglichkeit bietet, den „Ausgeklappt“-Zustand eines Kombinationsfeldes zu prüfen, müssen wir hier die Windows-API hinzuziehen.<\/p>\n
Stellt diese fest, dass das Kombinationsfeld bereits geöffnet ist, wird die Prozedur beendet und der Klick bewirkt das Schließen des Kombinationsfeldes.<\/p>\n
Andernfalls prüfen wir, ob der Benutzer in das Kombinationsfeld geklickt hat oder ob er einen der Einträge ausgewählt hat – das Mouse Down-Ereignis wird nämlich in beiden Fällen ausgelöst.<\/p>\n
Hier untersuchen wir die vertikale Position des Mauszeigers zum Zeitpunkt des Mausklicks. Diese erhalten wir über den Y-Parameter der entsprechenden Ereignisprozedur und prüfen, ob dieser Wert kleiner ist als die Summe der Eigenschaften Top <\/b>und Height <\/b>des Kombinationsfeldes.<\/p>\n
Nur in diesem Fall wollen wir mit dem Aufruf von cboUnterkategorie_GotFocus <\/b>dafür sorgen, dass das Kombinationsfeld mit der korrekten Datensatzherkunft geöffnet wird.<\/p>\n
Nach der Auswahl zurück zur vollen Liste<\/h2>\n
Hat der Benutzer seine Unterkategorie gewählt, ist der Ausnahmezustand vorbei.<\/p>\n
Wir schalten sofort wieder auf die vollständige Liste zurück, damit alle Zeilen weiterhin ihre Werte anzeigen können:<\/p>\n
Private Sub <\/span>cboUnterkategorieID_AfterUpdate()\r\n    Call<\/span> AlleUnterkategorienAnzeigen\r\nEnd Sub<\/span><\/pre>\n
Die Prozedur ruft nur unsere Hilfsprozedur AlleUnterkategorienAnzeigen<\/b> auf – mehr ist nicht nötig.<\/p>\n
Falsche Kombinationen verhindern<\/h2>\n
Sollte doch einmal die vollständige Liste angezeigt werden und nicht die für die aktuelle Kategorie gefilterte, beugen wir Fehleingaben durch eine entsprechende Prüfung vor.<\/p>\n
Dabei prüfen wir im Ereignis Vor Aktualisierung<\/b>, ob der gewählte Wert in cboUnterkategorieID <\/b>der Kategorie aus cboKategorieID <\/b>entspricht. Das erledigt die Ereignisprozedur aus Listing 7.<\/p>\n
Private Sub <\/span>cboUnterkategorieID_BeforeUpdate(Cancel As Integer<\/span>)\r\n    Dim <\/span>lngKategorieID As Long<\/span>\r\n    Dim <\/span>lngUnterkategorieID As Long<\/span>\r\n    lngKategorieID = Me.cboKategorieID\r\n    lngUnterkategorieID = Me.cboUnterkategorieID\r\n    If Nz(DLookup(\"UnterkategorieID\", \"tblUnterkategorien\", \"UnterkategorieID = \" & lngUnterkategorieID _\r\n            & \" AND KategorieID = \" & lngKategorieID), 0) = 0 Then\r\n        MsgBox<\/span> \"Diese Unterkategorie kann nicht für diese Kategorie ausgewählt werden.\", vbOKOnly + vbExclamation, _\r\n            \"Ungültige Unterkategorie\"\r\n        Cancel = True<\/span>\r\n        Me.cboUnterkategorieID.Dropdown\r\n    End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 7: Prüfen, ob Unterkategorie und Kategorie zusammenpassen<\/span><\/b><\/p>\n
Mit DLookup<\/b> schlagen wir nach, ob es in tblUnterkategorien<\/b> einen Eintrag gibt, dessen UnterkategorieID<\/b> und KategorieID<\/b> beide zur aktuellen Auswahl passen.<\/p>\n
Kommt dabei nichts heraus – der Nz<\/b>-Ausdruck liefert dann 0<\/b> -, passt die Kombination nicht: Wir zeigen eine kurze Meldung, setzen Cancel<\/b> auf True<\/b>, wodurch die Eingabe verworfen wird, und klappen die Liste erneut auf, damit der Benutzer es gleich richtig wählen kann.<\/p>\n
Zusammenfassung und Ausblick<\/h2>\n
Damit arbeiten abhängige Kombinationsfelder auch im Endlosformular sauber: Alle Zeilen zeigen ihre Werte, und beim Bearbeiten erscheint trotzdem die passende, kurze Auswahl.<\/p>\n
Der Kern ist der Wechsel zwischen zwei Zuständen – vollständige Liste zum Anzeigen, gefilterte Liste zum Auswählen -, gesteuert über die Ereignisse des Formulars und des Kombinationsfeldes.<\/p>\n
Leider funktioniert dies nicht vollständig in der Datenblattansicht, da hier die im Timer<\/b>-Ereignis angegebene Filterung nicht greift.<\/p>\n
Für Endlosformulare haben wir damit jedoch eine gute Lösung, deren einziger Nachteil das kurze Aufflackern der gesamten Liste vor der eigentlichen Filterung ist.<\/p>\n
Wichtig: Die vorgestellten Ereignisprozeduren müssen wie gezeigt übernommen werden – vor allem aber muss der Teil, der in die Timer-Prozedur ausgelagert wurde, dort verbleiben, andernfalls wird nach dem Anzeigen aller Einträge in cboUnterkategorieID <\/b>das erneute Filtern auf die der Kategorie entsprechenden Einträge nicht durchgeführt werden.<\/p>\n","protected":false},"excerpt":{"rendered":"
Im Beitrag „Abhängige Kombinationsfelder“ (www.access-im-unternehmen.de\/****) haben wir beschrieben, wie wir per 1:n-Beziehung verknüpfte Daten in zwei aufeinanderfolgenden Kombinationsfeldern erst filtern und dann auswählen können. Im vorliegenden Beitrag gehen wir einen Schritt weiter und schauen uns an, wie wir abhängige Kombinationsfelder in gebundenen Formularen darstellen. In Formularen in der Einzelansicht gelingt dies ohne Probleme. In der Endlosansicht und der Datenblattansicht stoßen wir jedoch auf Einschränkungen, die wir mehr oder weniger gut umgehen können. Wie das gelingt, lesen Sie ebenfalls in diesem Beitrag.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662026,66042026,44000052],"tags":[],"class_list":["post-55001609","post","type-post","status-publish","format-standard","hentry","category-662026","category-66042026","category-Formulare_und_Steuerelemente"],"yoast_head":"\nGebundene abhängige Kombinationsfelder - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Gebundene abhängige Kombinationsfelder\" \/>\n<meta property=\"og:description\" content=\"Im Beitrag "Abhängige Kombinationsfelder" (www.access-im-unternehmen.de\/****) haben wir beschrieben, wie wir per 1:n-Beziehung verknüpfte Daten in zwei aufeinanderfolgenden Kombinationsfeldern erst filtern und dann auswählen können. Im vorliegenden Beitrag gehen wir einen Schritt weiter und schauen uns an, wie wir abhängige Kombinationsfelder in gebundenen Formularen darstellen. In Formularen in der Einzelansicht gelingt dies ohne Probleme. In der Endlosansicht und der Datenblattansicht stoßen wir jedoch auf Einschränkungen, die wir mehr oder weniger gut umgehen können. Wie das gelingt, lesen Sie ebenfalls in diesem Beitrag.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2026-07-04T14:10:29+00:00\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"14\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Gebundene_abhaengige_Kombinationsfelder\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Gebundene_abhaengige_Kombinationsfelder\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"Gebundene abhängige Kombinationsfelder\",\"datePublished\":\"2026-07-04T14:10:29+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Gebundene_abhaengige_Kombinationsfelder\\\/\"},\"wordCount\":2527,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"articleSection\":[\"2026\",\"4\\\/2026\",\"Formulare und Steuerelemente\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Gebundene_abhaengige_Kombinationsfelder\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Gebundene_abhaengige_Kombinationsfelder\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Gebundene_abhaengige_Kombinationsfelder\\\/\",\"name\":\"Gebundene abhängige Kombinationsfelder - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"datePublished\":\"2026-07-04T14:10:29+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Gebundene_abhaengige_Kombinationsfelder\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Gebundene_abhaengige_Kombinationsfelder\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Gebundene_abhaengige_Kombinationsfelder\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Gebundene abhängige Kombinationsfelder\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Gebundene abhängige Kombinationsfelder - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/","og_locale":"de_DE","og_type":"article","og_title":"Gebundene abhängige Kombinationsfelder","og_description":"Im Beitrag \"Abhängige Kombinationsfelder\" (www.access-im-unternehmen.de\/****) haben wir beschrieben, wie wir per 1:n-Beziehung verknüpfte Daten in zwei aufeinanderfolgenden Kombinationsfeldern erst filtern und dann auswählen können. Im vorliegenden Beitrag gehen wir einen Schritt weiter und schauen uns an, wie wir abhängige Kombinationsfelder in gebundenen Formularen darstellen. In Formularen in der Einzelansicht gelingt dies ohne Probleme. In der Endlosansicht und der Datenblattansicht stoßen wir jedoch auf Einschränkungen, die wir mehr oder weniger gut umgehen können. Wie das gelingt, lesen Sie ebenfalls in diesem Beitrag.","og_url":"https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/","og_site_name":"Access im Unternehmen","article_published_time":"2026-07-04T14:10:29+00:00","author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"14\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"Gebundene abhängige Kombinationsfelder","datePublished":"2026-07-04T14:10:29+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/"},"wordCount":2527,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"articleSection":["2026","4\/2026","Formulare und Steuerelemente"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/","url":"https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/","name":"Gebundene abhängige Kombinationsfelder - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"datePublished":"2026-07-04T14:10:29+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/Gebundene_abhaengige_Kombinationsfelder\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"Gebundene abhängige Kombinationsfelder"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55001609","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55001609"}],"version-history":[{"count":0,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55001609\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55001609"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55001609"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55001609"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}