<\/p>\n
Wenn Sie Listenfelder für die Anzeige von Daten aus m:n-Beziehungen nutzen, müssen Sie die änderungen an der Auswahl jeweils in der zugrunde liegenden m:n-Verknüpfungstabelle speichern und diese beim Anzeigen eines Datensatzes wiederherstellen. Das ist kein Hexenwerk, wie der Beitrag Persistente Mehrfachauswahl in Listenfeldern (www.access-im-unternehmen.de\/479) zeigt. Wenn Sie diese Technik häufiger verwenden, artet das Anlegen der entsprechenden Ereignisprozeduren jedoch in echte Arbeit aus. Warum also die Funktionalität nicht einfach in eine Klasse auslagern und diese wiederverwenden<\/b><\/p>\n
Beispiel<\/b><\/p>\n
Ein gutes Beispiel für einen solchen Fall ist das Formular frmMitarbeiterDetail <\/b>aus der Lösung, die der Beitrag Schichtplaner<\/b> (www.access-im-unternehmen.de\/906<\/b>) beschreibt. Dort finden Sie gleich zwei Listenfelder, welche die Daten aus m:n-Beziehungen darstellen. Dort sollen nämlich für einen Mitarbeiter sowohl die Schichten, für die er zur Verfügung steht, als auch die entsprechenden Wochentage markiert und natürlich auch gespeichert werden (s. Bild 1).<\/p>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2013_05\/pic_902_001.png\")
<\/p>\n
Bild 1: Formular mit zwei Listenfeldern zum Speichern von Daten aus m:n-Beziehungen<\/span><\/b><\/p>\n Wenn der Benutzer in diesem Formular zum nächsten Mitarbeiter wechselt, soll dieses natürlich auch gleich die richtigen Datensätze in den beiden Listenfeldern markieren. Und wenn der Benutzer einen der Listenfeldeinträge aus- oder abwählt, müssen natürlich die entsprechenden änderungen in den zugrunde liegenden Tabellen durchgeführt werden.<\/p>\n Woher kommen die Daten<\/b><\/p>\n Um das Beispiel zu verdeutlichen, schauen wir uns die Tabellen an, auf denen die einzelnen Elemente aufbauen.<\/p>\n Das Formular frmMitarbeiterDetail <\/b>zeigt die Daten der Tabelle tblMitarbeiter <\/b>an. Diese ist sehr einfach gehalten und enthält lediglich zwei Felder:<\/p>\n Das Listenfeld lstSchichtarten <\/b>verwendet die Tabelle tblSchichtarten <\/b>als Datensatzherkunft, wobei diese Tabelle über die Tabelle tblMitarbeiterSchichtarten <\/b>mit der Tabelle tblMitarbeiter <\/b>verknüpft wird (s. Bild 2).<\/p>\n Bild 2: Aufbau der an der m:n-Beziehung beteiligten Tabellen<\/span><\/b><\/p>\n Damit das Listenfeld zwar das Feld SchichtartID<\/b> als gebundene Spalte verwendet, diese aber nicht anzeigt, stellen Sie die beiden Eigenschaften Spaltenanzahl <\/b>und Spaltenbreite <\/b>auf die Werte 2 <\/b>und 0cm <\/b>ein. Auf diese Weise erscheint nur die entsprechende Schichtart im Listenfeld.<\/p>\n Um die Mehrfachauswahl zu ermöglichen, stellen Sie außerdem die gleichnamige Eigenschaft auf den Wert Einfach <\/b>ein (s. Bild 3).<\/p>\n Bild 3: Die Listenfelder bieten die Mehrfachauswahl für ihre Einträge an.<\/span><\/b><\/p>\n Voraussetzung<\/b><\/p>\n Eine Voraussetzung hat die hier vorgestellte Version der Klasse: Die Namen der Primärschlüsselfelder der verknüpften Tabellen sowie der Fremdschlüsselfelder der Verknüpfungstabelle müssen übereinstimmen. Anderenfalls müssten Sie die Klasse entsprechend erweitern.<\/p>\n Benötigte Ereignisse<\/b><\/p>\n Was ist nun zu tun Als Erstes sollen beim Anzeigen eines Datensatzes im Hauptformular die diesem Datensatz zugeordneten Einträge der im Listenfeld angezeigten Tabelle markiert werden. Sprich: Die Einträge des Listenfeldes werden einzeln durchlaufen und mit den Daten der Verknüpfungstabelle tblMitarbeiterSchichtarten <\/b>abgeglichen. Ist der aktuelle Eintrag über diese Tabelle mit dem im Formular angezeigten Mitarbeiter verknüpft, soll der Eintrag markiert werden.<\/p>\n Dies geschieht logischerweise, wenn das Ereignis Beim Anzeigen<\/b> ausgelöst wird.<\/p>\n Außerdem soll bei einem Klick auf einen der Einträge eine änderung in der Tabelle tblMitarbeiterSchichtarten <\/b>vorgenommen werden: Ist der Eintrag noch nicht markiert, soll der Tabelle ein Datensatz hinzugefügt werden, der im Feld MitarbeiterID <\/b>den Wert des gleichnamigen Feldes im Formular und im Feld SchichtartID <\/b>den Wert der gebundenen Spalte des angeklickten Eintrags des Listenfeldes aufnimmt.<\/p>\n Wenn der Eintrag beim Anklick bereits markiert war und somit deaktiviert wird, soll die Prozedur den Datensatz der Tabelle tblMitarbeiterSchichtarten<\/b> suchen, der dem Wert des Feldes MitarbeiterID <\/b>im Formular und dem Wert der gebundenen Spalte des angeklickten Eintrags im Listenfeld entspricht.<\/p>\n Und da wir schon von Anklicken reden, wissen wir auch, welches Ereignis gemeint ist: nämlich das Ereignis Beim Klicken<\/b>.<\/p>\n Diese beiden Ereignisse müssten wir also in einer Klasse implementieren, die uns die wiederkehrende Programmierarbeit für das Speichern und Wiederherstellen der Mehrfachauswahl in Listenfeldern abnehmen soll.<\/p>\n Benutzung der Klasse<\/b><\/p>\n Die Klasse soll clsPersistenteMehrfachauswahl<\/b> heißen, also deklarieren wir im Kopf des Klassenmoduls des Formulars mit den auszurüstenden Listenfeldern für jedes Listenfeld eine entsprechende Objektvariable.<\/p>\n In unserem Beispiel handelt es sich um die folgenden beiden Einträge:<\/p>\n Die Instanzierung der beiden Klassen erfolgt in der Prozedur, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird. Diese sieht wie in Listing 1 aus und führt die folgenden Schritte für die beiden Listenfelder durch:<\/p>\n Listing 1: Initialisieren der Klasse clsPersinstenteMehrfachauswahl für die beiden Listenfelder<\/span><\/b><\/p>\n Diese Schritte führt man für jedes mit der Klasse auszustattende Listenfeld aus.<\/p>\n Wenn Sie die Klasse clsPersistenteMehrfachauswahl <\/b>einfach in Ihre Anwendung übernehmen, war es das – die Anzeige und das Speichern der ausgewählten Werte funktioniert nun bereits.<\/p>\n <\/p>\n Die Klasse clsPersistenteMehrfachauswahl<\/b><\/p>\n Erstellen Sie im VBA-Editor zunächst ein neues Klassenmodul (Menüeintrag Einfügen|Klassenmodul<\/b>).<\/p>\n Wie Sie der oben beschriebenen Anleitung entnehmen konnten, soll die Klasse nach dem Instanzieren gleich fünf Variablen entgegennehmen.<\/p>\n Dafür benötigen wir natürlich erstens fünf Member-Variablen, die nur innerhalb der Klasse verwendet werden und von außen zugewiesen werden sollen.<\/p>\n Bei der Variablen für die übergabe der Tabelle benötigen wir beispielsweise die folgende Deklaration:<\/p>\n Damit man diese private deklarierte Variable nach dem Instanzieren von außen füllen kann, benötigen wir eine entsprechende Property Let<\/b>-Prozedur.<\/p>\n Diese sieht wie folgt aus:<\/p>\n Die Prozedur liefert beim Zugriff auf ein Objekt auf Basis der Klasse von außen die Möglichkeit, die Variable m_mnTable <\/b>wie folgt zu füllen:<\/p>\n Auf die gleiche Weise deklarieren wir die beiden Variablen zum Aufnehmen der betroffenen Tabellenfelder:<\/p>\n Die Property Let<\/b>-Prozeduren sehen so aus:<\/p>\n Fehlen noch die beiden Objektvariablen zum Referenzieren des Formulars und des Listenfeldes.<\/p>\n Diese deklarieren Sie wie folgt:<\/p>\n Der Unterschied zu den vorherigen Deklarationen ist, dass wir hier jeweils das Schlüsselwort WithEvents <\/b>verwenden.<\/p>\n Dies führt dazu, dass wir im aktuellen Klassenmodul die Ereignisprozeduren der beiden Objekte implementieren können. Das heißt, dass wir nicht etwa eine Ereignisprozedur namens Form_Current <\/b>im Klassenmodul des Formulars definieren, sondern eine namens m_Form_Current <\/b>in der neu erstellten Klasse.<\/p>\n Wir müssen jedoch noch angeben, dass beim Auslösen etwa des Ereignisses Beim Anzeigen<\/b> auch in der aktuellen Klasse nach Ereignisprozeduren gesucht werden soll. Dies erledigen wir gleich in der Public Property Set<\/b>-Prozedur für die Eigenschaft Form<\/b>:<\/p>\n Wir legen also für die Eigenschaft OnCurrent <\/b>den Wert [Event Procedure] <\/b>fest. Das ist das Gleiche, als wenn wir im Eigenschaftsfenster des Formulars für die Eigenschaft Beim Anzeigen <\/b>den Wert [Ereignisprozedur] <\/b>eintragen – nur dass wir dies hier zur Laufzeit durchführen.<\/p>\n Warum verwenden wir hier Set <\/b>und nicht Let<\/b> Nun: Set <\/b>ist den Objektvariablen vorbehalten, Let <\/b>den einfachen Datentypen wie String<\/b>, Long<\/b>, Boolean <\/b>et cetera.<\/p>\n Listenfeld referenzieren<\/b><\/p>\n ähnlich gehen wir beim Listenfeld vor, auf dessen Beim Klicken<\/b>-Ereignis die Klasse reagieren soll:<\/p>\n Hier stellen wir die Eigenschaft OnClick <\/b>auf den Wert [Event Procedure] <\/b>ein.<\/p>\n Ereignisse implementieren<\/b><\/p>\n Fehlen noch die beiden Ereignisprozeduren, die im Klassenmodul clsPersistenteMehrfachauswahl <\/b>implementiert und durch die entsprechenden Ereignisse im Formular ausgelöst werden sollen. Die erste Ereignisprozedur m_Form_Current<\/b> finden Sie in Listing 2. Die Prozedur sorgt dafür, dass die Einträge des Listenfeldes für den aktuell im Formular angezeigten Datensatz aktiviert oder deaktiviert werden – je nachdem, welche Daten die für die Eigenschaft mnTable <\/b>angegebene Tabelle für den aktuellen Datensatz bereithält.<\/p>\n Listing 2: Markieren der Listenfeldeinträge entsprechend den Schichtarten des aktuell im Formular angezeigten Mitarbeiters<\/span><\/b><\/p>\n Die Prozedur deklariert zunächst die benötigten Variablen und hebt dann alle Markierungen im Listenfeld auf. Dazu durchläuft sie eine For…Next<\/b>-Schleife von 0 <\/b>bis zur Anzahl der enthaltenen Listeneinträge minus 1<\/b>. Das Einstellen der Eigenschaft Selected <\/b>für den entsprechenden Indexwert auf den Wert False <\/b>hebt die Markierung, die eventuell durch den vorherigen Datensatz vorgenommen wurde, auf.<\/p>\n Dann prüft die Prozedur, ob der Primärschlüsselwert des im Formular angezeigten Datensatzes überhaupt einen Wert enthält. Dazu verwendet sie den Ausdruck IsNull(m_Form(m_mField))<\/b>, was den Wert des in m_mField <\/b>angegebenen Feldes des mit m_Form <\/b>referenzierten Formulars mit der Funktion IsNull <\/b>prüft.<\/p>\n Danach beginnt die Markierung der dem aktuellen Datensatz des Formulars zugeordneten Einträge des Listenfeldes. Dazu stellt die Prozedur zunächst eine SQL-Abfrage zusammen, welche die zu dem Datensatz des Formulars passenden Einträge im Listenfeld ermittelt – sprich: alle Datensätze der in m_mnTable <\/b>gespeicherten Tabelle, deren Wert im Feld m_mField <\/b>dem Wert des Feldes m_mField <\/b>im Formular m_Form <\/b>entsprechen. Und zu den gefundenen Datensätzen soll die Abfrage die Werte der mit m_mField <\/b>und m_nField <\/b>angegebenen Felder ermitteln:<\/p>\n Die Prozedur erstellt dann ein Recordset auf Basis dieser SQL-Abfrage.<\/p>\n Nun kann es vorkommen, dass für den aktuellen Datensatz des Formulars noch gar kein Datensatz in der m:n-Verknüpfungstabelle angelegt wurde. Dies prüft die Prozedur mit der folgenden Bedingung:<\/p>\n Liefert dies den Wert True<\/b>, kann es losgehen: Die Prozedur durchläuft in einer For…Next<\/b>-Schleife wiederum alle Einträge des Listenfeldes.<\/p>\n Für jeden Eintrag durchläuft sie wiede-rum alle Datensätze des mit rst <\/b>referenzierten Recordset<\/b>-Objekts. Stimmen die Werte des mit m_nField <\/b>angegebenen Feldes des Recordsets und der gebundenen Spalte des aktuellen Listenfeldeintrags überein, markiert die Prozedur diesen Listenfeldeintrag.<\/p>\n Dies erledigt sie, indem sie die Selected<\/b>-Eigenschaft für den Eintrag mit dem aktuell durchlaufenen und in der Variablen i <\/b>gespeicherten Indexwert auf den Wert True <\/b>einstellt. An dieser Stelle verlässt die Prozedur die Do While<\/b>-Schleife, da der aktuelle Listenfeldeintrag ja bereits markiert wurde.<\/p>\n Passt der aktuelle Datensatz aus rst <\/b>nicht zum aktuellen Listenfeldeintrag, setzt die Prozedur die Suche mit dem nächsten Durchlauf der Do While<\/b>-Schleife fort. Nach dem Beenden der Schleife muss die Prozedur den Datensatzzeiger für das Recordset mit MoveFirst <\/b>zurücksetzen, damit dieses für den folgenden Listenfeldeintrag erneut von vorn durchlaufen werden kann.<\/p>\n Auswahl speichern<\/b><\/p>\n Fehlt noch die zweite Ereignisprozedur, die durch einen Mausklick auf einen der Einträge des Listenfeldes ausgelöst werden soll. Die Prozedur sieht im überblick wie in Listing 3 aus.<\/p>\n Listing 3: Speichern des Markiert-Zustands nach dem Anklicken eines der Einträge des Listenfeldes<\/span><\/b><\/p>\n Nach der Deklaration prüft die Ereignisprozedur zunächst, ob das mit m_mField <\/b>bezeichnete Feld im Formular m_Form <\/b>nicht möglicherweise den Wert Null <\/b>enthält.<\/p>\n Dies kann nur geschehen, wenn der Benutzer im Formular gerade einen neuen Datensatz angelegt hat. In diesem Fall zeigt das Formular eine entsprechende Meldung an und setzt die Markierung im Listenfeld zurück.<\/p>\n Der Index des zurückzusetzenden Feldes wird dabei über die Eigenschaft ListIndex <\/b>des Listenfeldes gewonnen und die Prozedur mit Exit Sub <\/b>verlassen.<\/p>\n Die Prozedur speichert den Datensatz des Formulars sicherheitshalber und ermittelt mit der Eigenschaft ItemData <\/b>des Eintrags mit dem in ListIndex <\/b>enthaltenen Indexwert den Wert der gebundenen Spalte des Listenfeldes. Dieser Wert, der dem Wert der n-Seite der Beziehung zwischen den verknüpften Tabellen entspricht, landet in der Variablen lngID<\/b>.<\/p>\n Dann prüft die Prozedur, ob der Benutzer den angeklickten Eintrag soeben aktiviert oder deaktiviert hat. Dies ermittelt sie wiederum über die Selected<\/b>-Eigenschaft für den Eintrag mit dem entsprechenden Index.<\/p>\n Liefert Selected <\/b>den Wert True<\/b>, wurde der Eintrag soeben ausgewählt und es muss ein entsprechender Datensatz in der Verknüpfungstabelle angelegt werden. Dies erledigt die Prozedur mit einer INSERT INTO<\/b>-Abfrage, die wiederum fast komplett dynamisch zusammengesetzt wird:<\/p>\n Die Aktionsabfrage fügt der in m_mnTable <\/b>angegebenen Tabelle für die beiden Felder aus m_mField <\/b>und m_nField <\/b>den aktuellen Wert des Primärschlüsselfeldes des Formulars und den Wert der gebundenen Spalte des Listenfeldes für den aktuellen Eintrag hinzu.<\/p>\n Die Execute<\/b>-Methode des Database<\/b>-Objekts führt die Abfrage schließlich aus.<\/p>\n\n
![\"Aufbau](\"..\/fileadmin\/_temp_\/2013_05\/pic_902_002.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2013_05\/pic_902_003.png\")
<\/p>\nDim <\/span>objPMSchichtarten As <\/span> clsPersistenteMehrfachauswahl\r\nDim <\/span>objPMWochentage As <\/span> clsPersistenteMehrfachauswahl<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objPMSchichtarten = New<\/span> clsPersistenteMehrfachauswahl\r\n With<\/span> objPMSchichtarten\r\n Set<\/span> .Form = Me\r\n Set<\/span> .Listbox = Me!lstSchichtarten\r\n .mField = \"MitarbeiterID\"\r\n .nField = \"SchichtartID\"\r\n .mnTable = \"tblMitarbeiterSchichtarten\"\r\n End With<\/span>\r\n Set<\/span> objPMWochentage = New<\/span> clsPersistenteMehrfachauswahl\r\n With<\/span> objPMWochentage\r\n Set<\/span> .Form = Me\r\n Set<\/span> .Listbox = Me!lstWochentage\r\n .mField = \"MitarbeiterID\"\r\n .nField = \"WochentagID\"\r\n .mnTable = \"tblMitarbeiterWochentage\"\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
Private <\/span>m_mnTable As String<\/span><\/pre>\nPublic Property Let <\/span>mnTable(str As String<\/span>)\r\n m_mnTable = str\r\nEnd Property<\/span><\/pre>\nobjPMSchichtarten.mnTable = \"tblMitarbeiterSchichtarten\"<\/pre>\n
Private <\/span>m_mField As String<\/span>\r\nPrivate <\/span>m_nField As String<\/span><\/pre>\nPublic Property Let <\/span>mField(str As String<\/span>)\r\n m_mField = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>nField(str As String<\/span>)\r\n m_nField = str\r\nEnd Property<\/span><\/pre>\nPrivate <\/span>WithEvents m_Form As <\/span>Form\r\nPrivate <\/span>WithEvents m_Listbox As <\/span>Listbox<\/pre>\nPublic Property Set<\/span> <\/span>Form(frm As <\/span>Form)\r\n Set<\/span> m_Form = frm\r\n m_Form.OnCurrent = \"[Event Procedure]\"\r\nEnd Property<\/span><\/pre>\nPublic Property Set<\/span> <\/span>Listbox(lst As <\/span>Listbox)\r\n Set<\/span> m_Listbox = lst\r\n m_Listbox.OnClick = \"[Event Procedure]\"\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>m_Form_Current()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n For i = 0 To m_Listbox.ListCount - 1\r\n m_Listbox.Selected(i) = False<\/span>\r\n Next<\/span> i\r\n If <\/span>IsNull(m_Form(m_mField)) Then<\/span>\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Set<\/span> db = CurrentDb\r\n strSQL = \"SELECT \" & m_mField & \", \" & m_nField & \" FROM \" & m_mnTable _\r\n & \" WHERE \" & m_mField & \" = \" & m_Form(m_mField)\r\n Set<\/span> rst = db.OpenRecordset(strSQL, dbOpenDynaset)\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n For i = 0 To m_Listbox.ListCount - 1\r\n Do While<\/span> Not<\/span> rst.EOF\r\n If <\/span>CLng(rst(m_nField)) = CLng(m_Listbox.ItemData(i)) Then<\/span>\r\n m_Listbox.Selected(i) = True<\/span>\r\n Exit Do<\/span>\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n rst.MoveFirst\r\n Next<\/span> i\r\n End If<\/span>\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n\"SELECT \" & m_mField & \", \" & m_nField & \" FROM \" & m_mnTable & \" WHERE \" & m_mField & \" = \" & m_Form(m_mField)<\/pre>\n
If <\/span>Not<\/span> rst.EOF Then<\/span><\/pre>\nPrivate Sub <\/span>m_Listbox_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngID As Long<\/span>\r\n Dim <\/span>strSQL As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n If <\/span>IsNull(m_Form(m_mField)) Then<\/span>\r\n MsgBox<\/span> \"Bitte bearbeiten Sie zunächst den Hauptdatensatz.\"\r\n m_Listbox.Selected(m_Listbox.ListIndex) = False<\/span>\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n DoCmd.RunCommand acCmdSaveRecord\r\n lngID = m_Listbox.ItemData(m_Listbox.ListIndex)\r\n If <\/span>m_Listbox.Selected(m_Listbox.ListIndex) = True<\/span> Then<\/span>\r\n strSQL = \"INSERT INTO \" & m_mnTable & \"(\" & m_mField & \", \" & m_nField & \") VALUES(\" & m_Form(m_mField) & \", \" _\r\n & lngID & \")\"\r\n db.Execute strSQL, dbFailOnError\r\n Else<\/span>\r\n strSQL = \"DELETE FROM \" & m_mnTable & \" WHERE \" & m_mField & \" = \" & m_Form(m_mField) & \" AND \" & m_nField & \" = \" _\r\n & lngID\r\n db.Execute strSQL, dbFailOnError\r\n End If<\/span>\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n\"INSERT INTO \" & m_mnTable & \"(\" & m_mField & \", \" & m_nField & \") VALUES(\" & m_Form(m_mField) & \", \" & lngID & \")\"<\/pre>\n