<\/p>\n
André Minhorst, Duisburg<\/b><\/p>\n
In den meisten Fällen reicht eine Instanz eines Formulars zum Darstellen der gewünschten Daten aus. Selbst wenn man einmal zwei oder mehr Datensätze vergleichen möchte, kann man diese in Listenform untereinander anzeigen. Wenn die betreffenden Datensätze allerdings einmal mehr Felder enthalten, als nebeneinander angezeigt werden können, kommt schnell der Wunsch nach der Verwendung mehrerer Instanzen eines Formulars mit unterschiedlichen Datensätzen auf. Wie Sie das realisieren, erfahren Sie im vorliegenden Beitrag.<\/b><\/p>\n
Die Anzeige mehrerer gleicher Formulare mit verschiedenen Datensätzen ist vor allem sinnvoll, wenn Sie beispielsweise Daten von Artikeln, Kunden, Lieferanten oder Mitarbeitern ansehen und vergleichen möchten.<\/p>\n
Wenn Sie die Formulare aus Bild 1 beispielsweise noch nebeneinander positionieren, können Sie die Eigenschaften der Artikel gut miteinander vergleichen.<\/p>\n
![](\"..\/fileadmin\/_temp_\/{13313950-9FD7-4ECE-8CB0-D3671F55936E}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Bild 1: Mehrere Formularinstanzen mit verschiedenen Artikeln<\/span><\/b><\/p>\n Wer nicht zu VBA greifen möchte, um mehrere Datensätze gleichzeitig in je einem einzigen Formular anzuzeigen, kann theoretisch das gewünschte Formular mehrmals kopieren und mit unterschiedlichen Namen versehen. Ganz davon abgesehen, dass auch hier ein wenig VBA-Code nötig ist, um beispielsweise zu prüfen, welche Kopie des Formulars schon geöffnet ist und welche man als Nächstes verwendet, hat diese Variante zwei große Nachteile: Erstens müssen Sie änderungen entweder direkt an allen Exemplaren durchführen oder bei jeder änderung alle Kopien löschen und durch neue Kopien des geänderten Originalformulars ersetzen. Zweitens ist diese Variante nicht besonders flexibel: Die Anzahl der verfügbaren Formulare ist in jedem Fall begrenzt.<\/p>\n Die alternative Variante besteht in der Verwendung eines einzigen Formulars, das Sie mehrfach öffnen können – und zwar mit verschiedenen Inhalten. Dazu ist zwar ein wenig VBA-Code erforderlich, aber es handelt sich nur um wenige Zeilen, wie Sie nachfolgend sehen werden.<\/p>\n Das nachfolgend beschriebene Beispiel bezieht sich auf die Anzeige von Daten verschiedener Artikel aus der Nordwind-Datenbank. Um den Aufwand beim Nachvollziehen des Beispiels gering zu halten, können Sie einige bereits bestehende Objekte aus der Nordwind-Datenbank verwenden.<\/p>\n Wenn Sie das Beispiel nachvollziehen möchten, legen Sie eine neue, leere Datenbank an und importieren zunächst einige Objekte aus der Nordwind-Datenbank:<\/p>\n Die Anweisung DoCmd.OpenForm öffnet jeweils die Standardinstanz eines Formulars. Auch das wiederholte Aufrufen bringt keine weiteren Instanzen hervor.<\/p>\n Ein Formular ist aber ein Objekt und diese lassen sich in der Regel auch mehrfach erzeugen. Dazu deklarieren Sie einfach eine Variable mit einem der gewünschten Formularklasse entsprechenden Datentyp. Diesen Datentyp können Sie ganz leicht ermitteln: Es handelt sich dabei um den Formularnamen mit vorangestelltem „Form_“. Um eine Objektvariable zu deklarieren, deren Datentyp der Klasse des zu erzeugenden Formulars entspricht, verwenden Sie im Fall des Formulars Artikel also folgende Zeile:<\/p>\n Wenn Sie eine entsprechende Objektvariable für einen Bericht erzeugen möchten, gehen Sie genauso vor – lediglich das Suffix des Ausdrucks für den Datentyp lautet dann „Report_“. <\/p>\n Nun füllen Sie die Objektvariable mit dem Objekt:<\/p>\n Damit haben Sie eine neue Instanz des Formulars erzeugt, die aber noch nicht sichtbar ist. Die nächste Anweisung lautet folglich:<\/p>\n Wenn Sie diese drei Anweisungen in eine Prozedur in einem Standardmodul packen und über das Testfenster aufrufen, sollten Sie doch eigentlich die gewünschten Formulare erstellen können.<\/p>\n Oder doch nicht Wenn Sie es ausprobieren, sehen Sie zwar ein kurzes Aufflackern, aber das Formular verschwindet sofort wieder. Kein Wunder: Die innerhalb einer Prozedur deklarierten und erzeugten Objekte leben nicht länger als die Prozedur selbst. Klammern Sie also die Deklaration aus der Prozedur aus und ändern Sie ihren Gültigkeitsbereich auf Public:<\/p>\n Ein erneuter Aufruf der Prozedur FormularinstanzErstellen führt zum Erfolg: Das Artikel-Formular erscheint. Aktivieren Sie einen anderen als den zuerst angezeigten Artikel-Datensatz. Führen Sie die Prozedur zum Erzeugen einer Formularinstanz erneut aus und schauen Sie, was passiert: Das erste Formular verschwindet und ein neues erscheint – das erkennen Sie daran, dass wieder der erste Datensatz der Datenherkunft angezeigt wird. Das war eigentlich zu erwarten, denn der Inhalt der Objektvariablen wird mit dem neuen Objekt überschrieben.<\/p>\n Wie es aussieht, benötigen Sie also mehrere Objektvariablen, um mehr als eine Instanz des Formulars anzuzeigen. Damit wären Sie wieder an einer ähnlichen Stelle wie am Anfang. Dort gab es ja alternativ zu diesem Weg die Möglichkeit, einfach mehrere gleiche Formulare zu erstellen – und nun soll das statische Deklarieren mehrerer Objektvariablen das Ende vom Lied sein Nein, das ist es natürlich nicht. Objektvariablen können Sie zur Laufzeit deklarieren und erzeugen, so viele Sie möchten – und Sie können auch unterschiedliche Instanzen des gewünschten Objekts damit kontrollieren.<\/p>\n Das Zauberwort heißt Collection-Objekt. Das ist das Pendant zu Arrays, nur dass Sie darin Objekte aufbewahren und wieder entfernen und natürlich auch auf die enthaltenen Objekte zugreifen können.<\/p>\n <\/p>\n Für ein solches Objekt gelten genau die gleichen Regeln wie für die übrigen Variablen: Sie haben den gleichen Gültigkeitsbereich – also global, objektweit oder prozedurweit – und werden gleichzeitig mit dem Objekt, in dem sie enthalten sind, zerstört.<\/p>\n Ein Collection-Objekt hat zwei Methoden und zwei Eigenschaften:<\/p>\n Im folgenden Beispiel fügen Sie die Kenntnis um die Tatsache, dass man Formular-Objekte beliebig oft erzeugen und diese Objekte in Collections sammeln kann, zu einer kleinen Beispielanwendung zusammen.<\/p>\n Sie haben bereits erfahren, dass Objekte wie auch Collections wieder zerstört werden, wenn auch das Objekt, in dessen Gültigkeitsbereich Sie diese deklariert haben, zerstört wird.<\/p>\n Im Beispiel soll dieses Objekt ein Formular sein, das die Artikelbezeichnungen aus der Artikeltabelle in einem Listenfeld anzeigt und einige Schaltflächen zum Anzeigen und Entfernen eines Detailformulars zu dem jeweiligen Artikel enthält. Die damit erzeugten Formularobjekte können manuell wieder geschlossen werden, aber spätestens mit dem Schließen des aufrufenden Formulars ist ihre Zeit vorbei.<\/p>\n Das Formular ist recht einfach aufgebaut, wie Bild 2 zeigt. Das Listenfeld hat den Namen lstArtikel und als Datensatzherkunft die Tabelle Artikel.<\/p>\n <\/b><\/p>\n Bild 2: Formular zum öffnen der Detailansicht von Artikeln<\/span><\/b><\/p>\n Sowohl die Prozedur, die durch das Beim Doppelklicken-Ereignis des Listenfeldes, als auch die, die durch das Beim Klicken-Ereignis der Schaltfläche cmdAnzeigen ausgelöst wird, enthält lediglich die folgende Anweisung:<\/p>\n Die aufgerufene Prozedur ArtikelAnzeigen enthält die eigentliche Funktion. Sie finden diese Prozedur in Quellcode 2.<\/p>\n Quellcode 2<\/b><\/p>\n Die allein stehende Deklaration der Collection colFrmArtikel sorgt dafür, dass die Collection formularweit verfügbar ist und erst zerstört wird, wenn Sie das Formular schließen.<\/p>\n Damit werden dann auch alle in der Collection enthaltenen Formulare – also die Detailansichten der Artikel – geschlossen.<\/p>\n Die Prozedur ArtikelAnzeigen prüft zunächst, ob das zu instanzierende Formular bereits vorhanden ist. Vergessen Sie diesen Teil vorerst – Sie benötigen noch einige Details, um ihn zu verstehen. Schauen Sie sich zunächst an, was die Prozedur macht, wenn der betreffende Artikel noch nicht in einem Formular angezeigt wird.<\/p>\n In dem Fall deklariert die Prozedur zunächst eine Objektvariable des Datentyps Form_Artikel. Mit der Set-Anweisung erzeugt sie eine neue Instanz des Form_Artikel-Objekts.<\/p>\n Mit dieser Instanz des Artikel-Formulars passieren dann folgende Dinge:<\/p>\n Nun muss die Instanz noch im Collection-Objekt untergebracht werden. Dazu verwendet die Prozedur dessen Add-Methode. Die Methode hat zwei Parameter: Den Parameter namens Item füllen Sie mit der das Formular repräsentierenden Objektvariablen und dem Parameter Key weisen Sie den gleichen Wert zu, den bereits die Tag-Eigenschaft der neuen Formularinstanz erhalten hat. So können Sie beispielsweise mit dem folgenden Ausdruck das Formular referenzieren, das den Artikel mit der Artikelnummer 4 anzeigt:<\/p>\n Quellcode 3<\/b><\/p>\n Quellcode 4<\/b><\/p>\n Zuletzt sorgen Sie noch dafür, dass jedes neue Formular versetzt zum vorherigen angezeigt wird. Dazu ermitteln Sie die Anzahl der bisherigen Instanzen des Formulars und verschieben die neue Instanz um einen entsprechenden Wert nach rechts unten.<\/p>\n Jetzt, da Sie wissen, dass Sie über den in der Tag-Eigenschaft enthaltenen Wert auf den entsprechenden Eintrag des Formulars in der Collection colFrmArtikel zugreifen können, macht eine Betrachtung des ersten Teils der Prozedur ArtikelAnzeigen Sinn: Hier zählt die Prozedur zunächst die Elemente der Collection und speichert das Ergebnis in der Integer-Variablen intFormCount. Wenn eines oder mehr Elemente enthalten sind, durchläuft eine For Next-Schleife alle Elemente der Collection und überprüft, ob die Tag-Eigenschaft eines der in der Collection enthaltenen Formulare mit dem Wert übereinstimmt, der für die neue Instanz verwendet würde. Ist das der Fall und damit schon ein Formular für diesen Artikel vorhanden, erhält dieses den Fokus und die Prozedur wird verlassen. Anderenfalls folgt das weiter oben bereits beschriebene Anlegen der neuen Instanz.<\/p>\n Die Beispielanwendung soll die Möglichkeit bieten, eine Formularinstanz eines im Listenfeld ausgewählten Artikels wieder zu schließen. Dazu dient die Schaltfläche cmdSchliessen. Die Prozedur, die durch die Ereigniseigenschaft Beim Klicken ausgelöst wird, sieht wie in Quellcode 3 aus.<\/p>\n Die Prozedur ruft eine Routine namens ArtikelAusblenden auf und übergibt einen aus der Zeichenkette „Artikel“ und der Artikelnummer des im Listenfeld ausgewählten Artikel als Parameter – das ist der Wert, der weiter oben bereits als Inhalt der Tag-Eigenschaft der Formularinstanzen und als Key-Wert der Collection-Elemente verwendet wurde.<\/p>\n Die Prozedur ArtikelAusblenden setzt den Wert der Tag-Eigenschaft des gesuchten Formulars auf eine leere Zeichenfolge. Den Hintergrund für diesen Schritt erfahren Sie weiter unten. Außerdem verwendet die Prozedur die Remove-Methode der Collection, um den Eintrag mit dem als Parameter übergebenen Key-Wert aus der Collection zu entfernen und die Formularinstanz damit zu zerstören (s. Quellcode 5).<\/p>\n Und dann wäre da noch die Fehlerbehandlung: Diese sorgt dafür, dass Fehler, die durch den Versuch, ein nicht vorhandenes Formular zu löschen, entstehen, sich nicht bemerkbar machen.<\/p>\n Wer auf Details achtet, hat bemerkt, dass die Prozedur ArtikelAusblenden als „Public“ deklariert ist. Im nächsten Kapitel folgt die Erläuterung dieser ungewöhnlichen Maßnahme. <\/p>\n Das Schließen aller Formularinstanzen erledigen Sie mit der Schaltfläche cmdAlleSchliessen. Der Vorgang ist einfacher als erwartet, wie auch die Länge der entsprechenden Ereignisprozedur aus Quellcode 5 andeutet. Man muss lediglich die Collection zerstören, um auch die darin enthaltenen Formularinstanzen zu schließen.<\/p>\n Quellcode 5<\/b><\/p>\n Der oben genannte Weg, die Formularinstanzen für die verschiedenen Artikel auch von dem Formular aus wieder zu schließen, von dem diese aufgerufen wurden, ist wirklich sehr unergonomisch. Die Schaltfläche zum Schließen aller geöffneten Instanzen des Artikel-Formulars ist sicher hilfreich, wenn der Benutzer keine weiteren Detailinformationen mehr zu den Artikeln benötigt, aber ansonsten wird dieser die Formulare wohl auf herkömmlichem Wege wieder schließen wollen.<\/p>\n Daraus ergibt sich aber ein kleines Problem: Wenn der Benutzer das Formular über die Schließen-Schaltfläche schließt, wird der zugehörige Eintrag aus der Collection nicht entfernt. Das bedeutet, dass bereits die nächste Aktion, egal ob es sich um das Anlegen oder das Entfernen einer Formularinstanz handelt, zu einem Fehler führen kann. Deshalb müssen Sie dafür sorgen, dass die betroffene Formularinstanz beim Schließen eine Prozedur auslöst, die auch den entsprechenden Eintrag aus der Collection entfernt. Dazu wählen Sie am besten das Ereignis Beim Schließen und legen dafür die Prozedur aus Quellcode 6 an.<\/p>\n Die Prozedur überprüft zunächst, ob die Tag-Eigenschaft dieser Formularinstanz einen Wert hat. Wenn nicht, löscht sie den Eintrag, indem sie die Prozedur ArtikelAusblenden des Formulars frmArtikelUebersicht aufruft und den Inhalt der Tag-Eigenschaft als Parameter übergibt – damit wissen Sie nun auch, warum diese Prozedur als öffentlich deklariert wurde.<\/p>\n Quellcode 6<\/b><\/p>\n Möglicherweise beklagen Sie nun, dass man ja alle Prozeduren des Klassenmoduls des Formulars frmArtikeluebersicht als öffentliche Prozeduren in einem Standardmodul hätte speichern können. Da die Prozeduren aber so sehr mit dem Formular zusammenhängen, hat der Autor sich für die hier gewählte Variante entschieden. <\/p>\n Und an dieser Stelle erfahren Sie auch, warum die Prozedur ArtikelAusblenden den Wert der Tag-Eigenschaft der zu entfernenden Instanz auf eine leere Zeichenkette setzt: Wenn Sie eine Formularinstanz vom Formular frmArtikelUebersicht aus löschen, indem Sie einfach die Instanz aus der Collection entfernen, lösen Sie ja ebenfalls die Ereigniseigenschaft Beim Schließen der Formularinstanz aus. Und da diese wiederum erneut die Prozedur ArtikelAusblenden aufruft, würde diese im zweiten Anlauf einen Fehler auslösen.<\/p>\n Mit der hier vorgestellten Vorgehensweise können Sie für herkömmliche Zwecke ausreichend Formularinstanzen öffnen.<\/p>\n Dabei spielt das Collection-Objekt eine herausragende Rolle, weil es als Container für die einzelnen Formularinstanzen dient.<\/p>\n In den meisten Fällen reicht eine Instanz eines Formulars zum Darstellen der gewünschten Daten aus. Selbst wenn man einmal zwei oder mehr Datensätze vergleichen möchte, kann man diese in Listenform untereinander anzeigen. Wenn die betreffenden Datensätze allerdings einmal mehr Felder enthalten, als nebeneinander angezeigt werden können, kommt schnell der Wunsch nach der Verwendung mehrerer Instanzen eines Formulars mit unterschiedlichen Datensätzen auf. Wie Sie das realisieren, erfahren Sie im vorliegenden 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":[66022005,662005,44000023],"tags":[],"class_list":["post-55000270","post","type-post","status-publish","format-standard","hentry","category-66022005","category-662005","category-Mit_Formularen_arbeiten"],"yoast_head":"\nMehrere physikalisch vorhandeneFormulare<\/h2>\n
Mehrere Instanzen eines Formulars<\/h2>\n
Dim frm As Form_Artikel<\/pre>\n
Hinweis<\/h3>\n
Set frm = New Form_Artikel<\/pre>\n
frm.Visible = True<\/pre>\n
Public Sub FormularinstanzErstellen()\r\n Dim frm As Form_Artikel\r\n Set frm = New Form_Artikel\r\n frm.Visible = True\r\nEnd Sub<\/pre>\n
Public frm As Form_Artikel<\/pre>\n
Formulare im Collection-Objekt<\/h3>\n
![](\"..\/fileadmin\/_temp_\/{13313950-9FD7-4ECE-8CB0-D3671F55936E}\/pic002.png\")
<\/p>\nArtikelAnzeigen Me.lstArtikel, _ Me.lstArtikel.Column(1)<\/pre>\n
Private colFrmArtikel As New Collection\r\nPrivate Private Sub ArtikelAnzeigen(lngArtikelID As _ Long, strArtikel As String)\r\n ''Kontrollieren, ob Artikel schon angezeigt wird...\r\n Dim i As Integer\r\n Dim intFormCount As Integer\r\n intFormCount = colFrmArtikel.Count\r\n If intFormCount > 0 Then\r\n For i = 1 To intFormCount\r\n If colFrmArtikel.Item(i).Form.Tag = _ \"Artikel\" & lngArtikelID Then\r\n colFrmArtikel.Item(\"Artikel\" & _ lngArtikelID).Form.SetFocus\r\n Exit Sub\r\n End If\r\n Next i\r\n End If\r\n ''... und falls nicht, eine neue Formularinstanz ''mit dem Artikel öffnen.\r\n Dim frm As Form_Artikel\r\n Set frm = New Form_Artikel\r\n With frm\r\n .Filter = \"[Artikel-Nr] = \" & lngArtikelID\r\n .FilterOn = True\r\n .Tag = \"Artikel\" & lngArtikelID\r\n .Caption = \"Artikel: \" & strArtikel\r\n .Visible = True\r\n End With\r\n colFrmArtikel.Add frm, \"Artikel\" & lngArtikelID\r\n intFormCount = colFrmArtikel.Count\r\n DoCmd.MoveSize (intFormCount * 500) + 1000, _ (intFormCount * 500) + 1000\r\nEnd Sub<\/pre>\n
colFrmArtikel.Item(\"Artikel\" _ & lngArtikelID).Form\r\nPrivate Sub cmdSchliessen_Click()\r\n ArtikelAusblenden \"Artikel\" & Me.lstArtikel\r\nEnd Sub<\/pre>\n
Public Sub ArtikelAusblenden(strTag As String)\r\n On Error GoTo ArtikelAusblenden_Err\r\n colFrmArtikel.Item(strTag).Tag = \"\"\r\n colFrmArtikel.Remove strTag\r\nArtikelAusblenden_Exit:\r\n Exit Sub\r\nArtikelAusblenden_Err:\r\n If Err.Number = 5 Or Err.Number = 9 Then\r\n GoTo ArtikelAusblenden_Exit\r\n Else\r\n MsgBox Err.Number & \" \" & Err.Description\r\n GoTo ArtikelAusblenden_Exit\r\n End If\r\nEnd Sub<\/pre>\n
Hinweis<\/h3>\n
Private Sub cmdAlleSchliessen_Click()\r\n Set colFrmArtikel = Nothing\r\nEnd Sub<\/pre>\n
Private Sub Form_Close()\r\n If Not Nz(Me.Tag, \"\") = \"\" Then\r\n Forms!frmArtikeluebersicht. _ ArtikelAusblenden (Me.Tag)\r\n End If\r\nEnd Sub<\/pre>\n
Hinweis<\/h3>\n