{"id":55001576,"date":"2025-12-01T00:00:00","date_gmt":"2025-12-02T21:35:16","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1576"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"mnBeziehung_mit_Drag_and_Drop_per_ListView","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/mnBeziehung_mit_Drag_and_Drop_per_ListView\/","title":{"rendered":"m:n-Beziehung mit Drag and Drop per ListView"},"content":{"rendered":"

Wir haben uns bereits in einigen Beiträgen angesehen, wie man die Daten einer m:n-Beziehung mit zwei nebeneinander liegenden Listenfeldern verwalten kann. Das Hinzufügen oder Entfernen erfolgte dabei per Doppelklick auf den jeweiligen Eintrag oder über entsprechende Schaltflächen. Im Gegensatz zu Listenfeldern können wir im ListView-Steuerelement jedoch auch Drag and Drop einsetzen. Wie das grundlegend funktioniert, haben wir uns bereits im hinteren Teil des Beitrags „ListView-Steuerelement mit VBA programmieren“ (www.access-im-unternehmen.de\/1573) angesehen. Im vorliegenden Beitrag schauen wir uns an, wie wir die Daten aus zwei ListView-Steuerelementen per Drag and Drop hin- und herschieben können. <\/b><\/p>\n

Datenmodell des Beispiels<\/h2>\n

Als Beispiel wollen wir einen Verteiler für Newsletter verwenden. Wir benötigen also eine Tabelle mit den Empfängern des Newsletters, eine Tabelle für die einzelnen Newsletter und eine weitere, um die Empfänger den verschiedenen Newslettern zuordnen zu können.<\/p>\n

Die erste Tabelle namens tblEmpfaenger <\/b>enthält die Felder EmpfaengerID<\/b>, Empfaenger <\/b>und EMail <\/b>(siehe Bild 1). Hier speichern wir die Empfänger für die Newsletter.<\/p>\n

\"Die<\/p>\n

Bild 1: Die Tabelle tblEmpfaenger<\/span><\/b><\/p>\n

Die Newsletter wiederum speichern wir in der Tabelle tblNewsletter<\/b>, die wir in Bild 2 sehen. Hier haben wir nur die wichtigsten Felder eingefügt, man könnte noch weitere Felder wie Versanddatum et cetera hinzufügen, wenn man die Anwendung in der Praxis nutzen möchte.<\/p>\n

\"Die<\/p>\n

Bild 2: Die Tabelle tblNewsletter<\/span><\/b><\/p>\n

Zusätzlich zu den dazu notwendigen Tabellen tblNewsletter<\/b> und tblEmpfaenger <\/b>brauchen wir eine Tabelle zum Verknüpfen der Datensätze der beiden Tabellen namens tblVerteiler<\/b> über eine m:n-Beziehung. Diese enthält neben dem Primärschlüsselfeld VerteilerID<\/b> zwei weitere Felder, über die wir die Datensätze der Tabellen tblEmpfaenger <\/b>und tblNewsletter <\/b>miteinander verknüpfen. Dies realisieren wir über die beiden Felder EmpfaengerID <\/b>und NewsletterID<\/b>. In diesem Fall wollen wir keine Nachschlagefelder einrichten, da wir diese im zu erstellenden Formular nicht benötigen.<\/p>\n

Damit jeder Empfänger nur einmal jedem Newsletter zugewiesen werden kann, haben wir außerdem einen eindeutigen Schlüssel über die beiden Felder EmpfaengerID <\/b>und NewsletterID <\/b>hinzugefügt (siehe Bild 3).<\/p>\n

\"Die<\/p>\n

Bild 3: Die m:n-Verknüpfungstabelle tblVerteiler<\/span><\/b><\/p>\n

Stattdessen legen wir die Beziehungen direkt im Beziehungen-Fenster von Access an. Hier ziehen wir alle drei Tabellen der Anwendung hinein und verknüpfen diese wie in Bild 4. Für beide Beziehungen definieren wir referenzielle Integrität mit Löschweitergabe. Damit erreichen wir, dass beim Löschen eines Empfängers oder eines Newsletters auch die damit verknüpften Einträge der Tabelle tblVerteiler <\/b>gelöscht werden.<\/p>\n

\"Beziehungen<\/p>\n

Bild 4: Beziehungen zum Herstellen der m:n-Beziehung<\/span><\/b><\/p>\n

Formular zum Zuordnen von Empfängern zu den Newslettern<\/h2>\n

Das Formular soll in zwei ListView<\/b>-Steuerelementen die Empfänger und die Nicht-Empfänger der Newsletter anzeigen. Als Datensatzquelle des Formulars dient die Tabelle tblNewsletter<\/b>. Das Formular zeigt beide Felder der Tabelle untereinander im Detailbereich an (siehe Bild 5).<\/p>\n

\"Hinzufügen<\/p>\n

Bild 5: Hinzufügen der Felder der Tabelle tblNewsletter<\/span><\/b><\/p>\n

Außerdem fügen wir zwei ListView<\/b>-Steuerelemente namens lvwEmpfaenger <\/b>und lvwKeinEmpfaenger <\/b>hinzu.<\/p>\n

Dazu betätigen wir den Befehl Formularentwurf|Steuerelemente|ActiveX-Steuerelemente<\/b>. Dies öffnet den Dialog ActiveX-Steuerelemente <\/b>einfügen, wo wie den Eintrag Microsoft ListView Control <\/b>finden (siehe Bild 6).<\/p>\n

\"Auswählen<\/p>\n

Bild 6: Auswählen des ListView-Steuerelements<\/span><\/b><\/p>\n

Die beiden ListView<\/b>-Steuerelemente fügen wir unterhalb der bereits vorhandenen Steuerelemente ein und passen ihre Bezeichnungen an (siehe Bild 7).<\/p>\n

\"Hinzufügen<\/p>\n

Bild 7: Hinzufügen der ListView-Steuerelemente<\/span><\/b><\/p>\n

Einstellungen für die ListView-Steuerelemente<\/h2>\n

In der Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>ausgelöst wird, wollen wir die Einstellungen für die beiden ListView<\/b>-Steuerelemente vornehmen.<\/p>\n

Den Großteil der Arbeit wollen wir jedoch in eine weitere Prozedur auslagern, weil die Befehle für beide ListView<\/b>-Steuerelemente fast identisch sind. Zunächst jedoch deklarieren wir Objektvariablen für die beiden ListView<\/b>-Steuerelemente im Kopf des Klassenmoduls des Formulars:<\/p>\n

Dim <\/span>objEmpfaenger As <\/span>MSComctlLib.ListView\r\nDim <\/span>objKeinEmpfaenger As <\/span>MSComctlLib.ListView<\/pre>\n
Die Form_Load<\/b>-Ereignisprozedur füllt diese mit Verweisen auf die Object<\/b>-Eigenschaften der entsprechenden Steuerelemente und ruft für jedes die Prozedur ListViewEinstellen <\/b>auf.<\/p>\n
Dabei übergibt sie den Verweis auf das jeweilige ListView<\/b>-Steuerelement und den Text, der im Spaltenkopf erscheinen soll:<\/p>\n
Private Sub <\/span>Form_Load()\r\n     Set<\/span> objKeinEmpfaenger = Me.lvwKeinEmpfaenger.Object\r\n     Set<\/span> objEmpfaenger = Me.lvwEmpfaenger.Object\r\n     Call<\/span> ListViewEinstellen(objKeinEmpfaenger, _\r\n         \"Nicht in Empfängerliste\")\r\n     Call<\/span> ListViewEinstellen(objEmpfaenger, _\r\n         \"In Empfängerliste\")\r\nEnd Sub<\/span><\/pre>\n
Die Prozedur ListViewEinstellen<\/b> nimmt diese Parameter entgegen und stellt einige Eigenschaften ein (siehe Listing 1).<\/p>\n
Private Sub <\/span>ListViewEinstellen(objListView As <\/span>_\r\n         MSComctlLib.ListView, strHeader As String<\/span>)\r\n     With<\/span> objListView\r\n         .View = lvwReport\r\n         .BorderStyle = ccNone\r\n         .Appearance = ccFlat\r\n         .FullRowSelect = True<\/span>\r\n         .HideSelection = False<\/span>\r\n         .MultiSelect = True<\/span>\r\n         .Font.Name = \"Calibri\"\r\n         .Font.Size = 11\r\n         .OLEDragMode = ccOLEDragAutomatic\r\n         .OLEDropMode = ccOLEDropManual\r\n         .ColumnHeaders.Clear\r\n         .ColumnHeaders.Add , \"c1\", strHeader\r\n         .ColumnHeaders(1).Width = Me.lvwEmpfaenger.Width\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Einstellen der Eigenschaften für die ListView-Steuerelemente<\/span><\/b><\/p>\n
Dazu gehören die Ansicht als lvwReport<\/b>, das Ausblenden des Randes, das Umstellen von 3-D zum flachen Erscheinungsbild, das vollständige Markieren der markierten Zeile, das Sichtbarmachen der Markierung, auch wenn das ListView<\/b>-Steuerelement nicht den Fokus hat, Einstellungen für die Schriftart und den Drag and Drop-Modus sowie das Einfügen einer Spaltenüberschrift.<\/p>\n
Füllen der ListView-Steuerelemente beim Anzeigen<\/h2>\n
Die beiden ListView<\/b>-Steuerelemente sollen im Ereignis Beim Anzeigen <\/b>gefüllt werden. Zuvor legen wir jedoch noch zwei Abfragen an, die wir als Basis für das Füllen der ListView<\/b>-Steuerelemente nutzen.<\/p>\n
Abfrage für die Empfänger<\/h2>\n
Die erste Abfrage heißt qryEmpfaenger <\/b>und enthält die beiden Tabellen tblEmpfaenger <\/b>und tblVerteiler<\/b>. Aus der Tabelle tblEmpfaenger <\/b>fügen wir die beiden Felder EmpfaengerID <\/b>und Empfaenger <\/b>hinzu, aus der Tabelle tblNewsletter <\/b>das Feld NewsletterID<\/b>. Das Feld NewsletterID <\/b>dient lediglich als Kriteriumsfeld. Hier legen wir als Vergleichswert einen Parameter namens prmNewsletterID <\/b>fest (siehe Bild 8). Auf diese Weise liefert die Abfrage alle Empfänger, die dem mit dem Parameter prmNewsletterID <\/b>zugewiesenen Newsletter zugeordnet sind.<\/p>\n
\"Datenherkunft<\/p>\n
Bild 8: Datenherkunft für das ListView-Steuerelement lvwEmpfaenger<\/span><\/b><\/p>\n
Abfrage für die noch nicht zugeordneten Empfänger<\/h2>\n
Die zweite Abfrage ist etwas aufwendiger (siehe Bild 9). Sie enthält nur die Tabelle tblEmpfaenger<\/b> und liefert die Werte der Felder EmpfaengerID <\/b>und Empfaenger <\/b>der Tabelle. Sie filtert die Empfänger, indem sie alle in einer Unterabfrage enthaltenen Empfänger ausschließt. Das Kriterium mit der Unterabfrage lautet:<\/p>\n
\"Datenherkunft<\/p>\n
Bild 9: Datenherkunft für das ListView-Steuerelement lvwKeinEmpfaenger<\/span><\/b><\/p>\n
Nicht In (\r\n   SELECT tblEmpfaenger.EmpfaengerID   FROM tblEmpfaenger   INNER JOIN tblVerteiler   ON tblEmpfaenger.EmpfaengerID =    tblVerteiler.EmpfaengerID   WHERE tblVerteiler.NewsletterID = [prmNewsletterID])<\/pre>\n
Die Unterabfrage enthält also alle Empfänger, die bereits dem Newsletter aus dem Parameter prmNewsletterID <\/b>zugeordnet sind.<\/p>\n
Eintragen der Empfänger und Nicht-Empfänger in die ListView-Steuerelemente<\/h2>\n
Die Prozedur Form_Current <\/b>aus Listing 2 deklariert verschiedene Variablen, um Recordsets auf Basis der beiden zuvor beschriebenen Abfragen zu erzeugen.<\/p>\n
Sub <\/span>Form_Current()\r\n     Dim <\/span>db As <\/span>dao.Database\r\n     Dim <\/span>qdfKeinEmpfaenger As <\/span>dao.QueryDef\r\n     Dim <\/span>qdfEmpfaenger As <\/span>dao.QueryDef\r\n     Dim <\/span>rstKeinEmpfaenger As <\/span>dao.Recordset\r\n     Dim <\/span>rstEmpfaenger As <\/span>dao.Recordset\r\n     Dim <\/span>prm As <\/span>dao.Parameter\r\n     Set<\/span> db = CurrentDb\r\n     Set<\/span> qdfKeinEmpfaenger = db.QueryDefs(\"qryKeinEmpfaenger\")\r\n     Set<\/span> prm = qdfKeinEmpfaenger.Parameters(\"prmNewsletterID\")\r\n     prm.Value = Me.NewsletterID\r\n     Set<\/span> rstKeinEmpfaenger = qdfKeinEmpfaenger.OpenRecordset\r\n     ListeAktualisieren rstKeinEmpfaenger, objKeinEmpfaenger\r\n         \r\n     Set<\/span> qdfEmpfaenger = db.QueryDefs(\"qryEmpfaenger\")\r\n     Set<\/span> prm = qdfEmpfaenger.Parameters(\"prmNewsletterID\")\r\n     prm.Value = Me.NewsletterID\r\n     Set<\/span> rstEmpfaenger = qdfEmpfaenger.OpenRecordset\r\n     ListeAktualisieren rstEmpfaenger, objEmpfaenger\r\nEnd Sub<\/span><\/pre>\n
Listing 2: Füllen der ListView-Steuerelemente<\/span><\/b><\/p>\n
Dabei holt sie zunächst einen Verweis auf das aktuelle Database<\/b>-Objekt und referenziert dann die Abfrage qryKeinEmpfaenger <\/b>mit der QueryDef<\/b>-Variablen qdfKeinEmpfaenger<\/b>. Dann stellt sie den Parameter prmNewsletterID<\/b> auf den Wert des Feldes NewsletterID <\/b>des aktuellen Datensatzes des Formulars ein.<\/p>\n
Schließlich öffnet sie ein Recordset auf Basis dieses QueryDef<\/b>-Objekts und referenziert dieses mit der Variablen rst<\/b> und übergibt dieses samt einem Verweis auf das zu füllende ListView<\/b>-Steuerelement an eine weitere Prozedur namens ListeAktualisieren<\/b>, die wir im Anschluss beschreiben.<\/p>\n
Für das ListView<\/b>-Steuerelement lvwEmpfaenger <\/b>und die Abfrage qryEmpfaenger <\/b>geht die Prozedur analog vor.<\/p>\n
Die Prozedur ListeAktualisieren <\/b>nimmt die Verweise auf das Recordset und das zu füllende ListView<\/b>-Steuerelement entgegen und leert zunächst mit der Clear<\/b>-Methode der ListItems<\/b>-Auflistung das ListView<\/b>-Steuerelement (siehe Listing 3).<\/p>\n
Private Sub <\/span>ListeAktualisieren(rst As <\/span>DAO.Recordset, objListView As <\/span>MSComctlLib.ListView)\r\n     objListView.ListItems.Clear\r\n     Do While<\/span> Not<\/span> rst.EOF\r\n         objListView.ListItems.Add , \"a\" & rst!EmpfaengerID, rst!Empfaenger\r\n         rst.MoveNext<\/span>\r\n     Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 3: Füllen der ListView-Steuerelemente per Recordset<\/span><\/b><\/p>\n
Dann durchläuft sie in einer Do While<\/b>-Schleife alle Einträge des Recordsets und fügt für jeden Datensatz einen neuen Eintrag zum ListView<\/b>-Steuerelement hinzu. Dabei übergibt sie als Key <\/b>den Buchstaben a <\/b>und die ID des Datensatzes und als Text <\/b>den Namen des Empfängers.<\/p>\n
Damit sind die Listenfelder nun beispielsweise wie in Bild 10 gefüllt.<\/p>\n
\"Die<\/p>\n
Bild 10: Die gefüllten ListView-Steuerelemente<\/span><\/b><\/p>\n
Daten zwischen den ListView-Steuerelementen verschieben<\/h2>\n
Da ListView<\/b>-Steuerelemente ungebunden sind, ist wie auch beim TreeView<\/b>-Steuerelement vor allem eines zu beachten: Neben dem Verschieben des Eintrags zwischen den Listen müssen auch die dahinter liegenden Datenbanktabellen aktualisiert werden.<\/p>\n
Für das Ziehen eines Eintrags von einem zum anderen ListView<\/b>-Steuerelement benötigen wir zwei Ereignisprozeduren je Liste. Diese fügen wir nun über die beiden Auswahlfelder oben im Codefenster hinzu. Dazu wählen wir zuerst den Eintrag lvwEmpfaenger <\/b>im linken Auswahlfeld aus und dann nacheinander die drei Einträge OLEStartDrag<\/b> und OLEDragDrop<\/b>.<\/p>\n
Die gleiche Prozedur wiederholen wir für das ListView<\/b>-Steuerelement lvwKeinEmpfaenger<\/b>.<\/p>\n
Einträge in die Empfängerliste verschieben<\/h2>\n
Wenn wir einen der Einträge oder auch mehrere markierte Einträge mit der Maus fassen und den Drag and Drop-Vorgang initiieren, wird das Ereignis OLEStartDrag <\/b>des Steuerelements lvwEmpfaenger <\/b>ausgelöst (siehe Listing 4).<\/p>\n
Private Sub <\/span>lvwKeinEmpfaenger_OLEStartDrag(Data As Object<\/span>, AllowedEffects As Long<\/span>)\r\n     Dim <\/span>objListitem As <\/span>ListItem\r\n     Dim <\/span>strData As String<\/span>\r\n     Dim <\/span>strDataItems() As String<\/span>\r\n     For Each objListitem In lvwKeinEmpfaenger.ListItems\r\n         If <\/span>objListitem.Selected = True<\/span> Then<\/span>\r\n             strData = strData & objListitem.Key & \"¦\" & objListitem.Text & \";\"\r\n         End If<\/span>\r\n     Next<\/span>\r\n     strData = Left<\/span>(strData, Len<\/span>(strData) - 1)\r\n     Data.Clear\r\n     Data.SetData strData, ccCFText\r\nEnd Sub<\/span><\/pre>\n
Listing 4: Starten des Drag and Drop in der Liste der Nicht-Empfänger<\/span><\/b><\/p>\n
Diese Prozedur durchläuft alle Einträge des ListView<\/b>-Steuerelements und prüft für jedes Element mit der Selected<\/b>-Eigenschaft, ob dieses markiert ist. Ist das der Fall, fügt sie der String<\/b>-Variablen strData <\/b>ein Semikolon, den Key<\/b>, das Zeichen ¦ <\/b>und den Wert der Eigenschaft Text <\/b>hinzu, also zum Beispiel a1 ¦Minhorst, André<\/b>. Bei mehreren markierten Einträgen kommt so eine Zeichenkette wie die folgende zusammen:<\/p>\n
;a1 ¦Minhorst, André;a2 ¦Müller, Klaus<\/pre>\n
Im folgenden Schritt schneiden wir noch das führende Semikolon ab. Schließlich leeren wir den Parameter Data, um sicherzugehen, dass dieser leer ist, und weisen diesem mit der SetData<\/b>-Methode den Inhalt von strData <\/b>plus den Wert ccCFText <\/b>als Kennzeichnung des Inhalts als Zeichenkette hinzu.<\/p>\n
Fallenlassen der Einträge in der Liste der Empfänger<\/h2>\n
Lassen wir die Einträge über dem ListView<\/b>-Steuerelement lvwEmpfaenger <\/b>fallen, löst dies die Prozedur OLEDragDrop <\/b>dieses Steuerelements aus (siehe Listing 5). Diese erhält mit dem Parameter Data <\/b>die Daten, die wir in der Ereignisprozedur lvwKeinEmpfaenger_OLEStartDrag<\/b> des jeweils anderen ListView<\/b>-Steuerelements gefüllt haben. Den Inhalt lesen wir mit der Funktion GetData <\/b>aus und splitten die Zeichenkette mit der Split<\/b>-Funktion an den Stellen mit einem Semikolon in ein String<\/b>-Array namens strDataItems <\/b>auf.<\/p>\n
Private Sub <\/span>lvwEmpfaenger_OLEDragDrop(Data As Object<\/span>, Effect As Long<\/span>, Button As Integer<\/span>, Shift As Integer<\/span>, _\r\n         x As Single<\/span>, y As Single<\/span>)\r\n     Dim <\/span>strData As String<\/span>\r\n     Dim <\/span>strDataItems() As String<\/span>\r\n     Dim <\/span>strText As String<\/span>\r\n     Dim <\/span>strKey As String<\/span>\r\n     Dim <\/span>i As Integer<\/span>\r\n     strData = Data.GetData(ccCFText)\r\n     strDataItems = Split<\/span>(strData, \";\")\r\n     For i = LBound<\/span>(strDataItems) To UBound<\/span>(strDataItems)\r\n         strKey = Split<\/span>(strDataItems(i), \"¦\")(0)\r\n         strText = Split<\/span>(strDataItems(i), \"¦\")(1)\r\n         If IsNull(DLookup(\"EmpfaengerID\", \"tblVerteiler\", \"NewsletterID = \" & Me.NewsletterID _\r\n                 & \" AND EmpfaengerID = \" & Mid<\/span>(strKey, 2))) Then\r\n             lvwEmpfaenger.ListItems.Add , strKey, strText\r\n             lvwKeinEmpfaenger.ListItems.Remove strKey\r\n             CurrentDb.Execute \"INSERT INTO tblVerteiler(NewsletterID, EmpfaengerID) \" & \"VALUES(\" _\r\n                 & Me.NewsletterID & \", \" & Mid<\/span>(strKey, 2) & \")\"\r\n         End If<\/span>\r\n     Next<\/span> i\r\n     Call<\/span> Form_Current\r\n     For i = 1 To objEmpfaenger.ListItems.Count\r\n         objEmpfaenger.ListItems(i).Selected = False<\/span>\r\n     Next<\/span> i\r\n     For i = LBound<\/span>(strDataItems) To UBound<\/span>(strDataItems)\r\n         strKey = Split<\/span>(strDataItems(i), \"¦\")(0)\r\n         strText = Split<\/span>(strDataItems(i), \"¦\")(1)\r\n         objEmpfaenger.ListItems(strKey).Selected = True<\/span>\r\n     Next<\/span> i\r\n     Me.lvwEmpfaenger.SetFocus\r\nEnd Sub<\/span><\/pre>\n
Listing 5: Fallenlassen von Elementen in der Liste der Empfänger<\/span><\/b><\/p>\n
Anschließend durchläuft die Prozedur eine For…Next<\/b>-Schleife über alle Elemente dieses Arrays.<\/p>\n
Im ersten Schritt nutzen wir wieder die Split<\/b>-Funktion, um die einzelnen Array-Element wiederum an der Stelle mit dem Zeichen ¦ <\/b>aufzuteilen und in die Variablen strKey <\/b>und strText <\/b>zu schreiben.<\/p>\n
Wir prüfen sicherheitshalber mit der DLookup<\/b>-Funktion, ob noch kein Eintrag in der Zieltabelle tblVerteiler <\/b>enthalten ist. Ist dies der Fall, fügen wir zunächst dem ListView<\/b>-Steuerelement lvwEmpfaenger <\/b>einen neuen Eintrag mit dem entsprechenden Key und Text hinzu. Danach entfernen wir den gezogenen Eintrag mit der Remove<\/b>-Methode aus dem ListView<\/b>-Steuerelement lvwKeinEmpfaenger<\/b>.<\/p>\n
Schließlich tragen wir mit einer INSERT INTO<\/b>-Anweisung einen neuen Datensatz in die Tabelle tblVerteiler <\/b>ein, der den Wert des Feldes NewsletterID <\/b>des aktuellen Datensatzes aus dem Formular und den aus dem Key extrahierten Primärschlüsselfeld des zu verschiebenden Empfängers enthält.<\/p>\n
Damit wären wir fast fertig, allerdings wurde der neue Eintrag nicht alphabetisch zum ListView<\/b>-Steuerelement lvwEmpfaenger <\/b>hinzugefügt, sondern einfach hinten angehängt. Also rufen wir an dieser Stelle der Einfachheit halber nochmals die Prozedur Form_Current <\/b>auf, die sonst nur beim Datensatzwechsel im Formular ausgelöst wird, und sorgen so für ein erneutes Einlesen der Daten, diesmal in alphabetischer Reihenfolge. So wird der neu hinzugefügte Eintrag direkt an der richtigen Stelle angezeigt.<\/p>\n
Wir könnten dies durch zwei Alternativen ersetzen:<\/p>\n