{"id":55000341,"date":"2017-10-01T00:00:00","date_gmt":"2020-01-24T15:59:44","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=341"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Mehrere_Instanzen_eines_Formulars_","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/Mehrere_Instanzen_eines_Formulars_.html","title":{"rendered":"Mehrere Instanzen eines Formulars"},"content":{"rendered":"

Die meisten Anwendungen zeigen, wie Sie aus einer Liste von Datensätzen einen per Doppelklick öffnen und in einem Detailformular anzeigen. Nach dem Bearbeiten schließen Sie diesen und wenden sich dem nächsten Datensatz zu. Was aber, wenn Sie einmal mehrere Datensätze parallel anzeigen möchten, um diese beispielsweise zu vergleichen – oder weil Sie einfach den einen Datensatz später noch einmal weiterbearbeiten möchten. Dieser Artikel zeigt Ihnen, wie Sie dieses Verhalten mit Access-Formularen abbilden können.<\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispiele dieses Artikels finden Sie in der Datenbank 1611_Formularinstanzen.accdb<\/b>.<\/p>\n

Formulare öffnen auf herkömmliche Art<\/h2>\n

Wenn Sie auf die herkömmliche Art ein Formular öffnen möchten, verwenden Sie dazu beispielsweise den folgenden Befehl:<\/p>\n

DoCmd.OpenForm \"frmKunde\"<\/pre>\n
Damit erhalten Sie dann eine Instanz des gewünschten Formulars. Mit weiteren Parametern können Sie etwa noch angeben, dass Sie gleich beim öffnen einen bestimmten Kunden anzeigen wollen:<\/p>\n
DoCmd.OpenForm \"frmKunde\", WhereCondition:=\"KundeID = 1\"<\/pre>\n
Wenn Sie die gleiche Anweisung jedoch noch ein weiteres Mal ausführen, um damit beispielsweise einen anderen Kunden im gleichen Formular anzuzeigen, gelingt dies nicht wie gewünscht.<\/p>\n
Wir schauen uns dies am Beispiel des Formulars frmKunde <\/b>an, dass im Entwurf wie in Bild 1 aussieht und die Tabelle tblKunden <\/b>mit einigen Beispieldatensätzen als Datenherkunft verwendet.<\/p>\n
\"Formular-Entwurf<\/a><\/p>\n
Bild 1: Formular-Entwurf unseres Beispielformulars<\/p>\n
öffnen wir das Formular mit der obigen DoCmd.OpenForm<\/b>-Anweisung, die Sie der Einfachheit halber einfach im Direktbereich eingeben (zu öffnen mit Strg + G<\/b>) und mit der Eingabetaste ausführen, erhalten wir das Formular aus Bild 2. Führen Sie diesen Befehl jedoch direkt danach erneut aus, wobei Sie lediglich den WhereCondition<\/b>-Parameter wie folgt ändern, wird zwar der zweite Kunde im Formular angezeigt, der erste verschwindet allerdings:<\/p>\n
\"Erster<\/a><\/p>\n
Bild 2: Erster Datensatz im Beispielformular<\/p>\n
DoCmd.OpenForm \"frmKunde\", WhereCondition:=\"KundeID = 2\"<\/pre>\n
Das bedeutet, dass wir uns eine alternative Möglichkeit einfallen lassen müssen.<\/p>\n
Formular-Instanz öffnen<\/h2>\n
Zum Glück gibt es noch eine zweite Methode, um ein Formular zu öffnen. Im Grunde ist DoCmd.OpenForm <\/b>eine vereinfachte Variante, die Sie so etwa in anderen Sprachen wie Visual Basic oder C# nicht finden werden. Dort wird immer eine Objektvariable auf Basis der entsprechenden Klasse, hier eben das betroffene Formular, deklariert und dann initialisiert. Gegebenenfalls ist das initialisierte Objekt dann noch sichtbar zu machen, was bei Access-Formularen der Fall ist. Wie also sieht diese alternative Methode unter Access aus und können wir auch hier den gewünschten Datensatz an das Formular übermitteln<\/p>\n
Dazu wollen wir uns erst einmal ein Standardmodul anlegen, in dem wir eine Prozedur erstellen, um das Verhalten nachzuprogrammieren.<\/p>\n
Das Standardmodul heißt mdlFormularinstanzen <\/b>und wird im Visual Basic Editor (zu öffnen mit Alt + F11<\/b>) mit dem Menübefehl Einfügen|Modul <\/b>eingefügt.<\/p>\n
Keine Formularinstanz ohne Formularklasse<\/h2>\n
Ein Schritt ist noch nötig, bevor wir per VBA eine neue Instanz unseres Formulars frmKunde <\/b>erstellen können. Genau genommen erstellen wir nämlich keine Instanz des Formulars, sondern der Code behind-Klasse, also des Klassenmoduls, dass beispielsweise dann angelegt wird, wenn Sie ein Ereignis des Formulars implementieren oder die Eigenschaft Enthält Modul <\/b>des Formulars auf Ja <\/b>einstellen.<\/p>\n
Da das Formular eine Schaltfläche mit der Beschriftung OK <\/b>enthält, welche das Formular nach erfolgter Bearbeitung oder Ansicht der Daten schließen soll, legen wir gleich den Wert [Ereignisprozedur] <\/b>für die Ereigniseigenschaft Beim Klicken <\/b>dieses Steuerelements an und klicken auf die Schaltfläche mit den drei Punkten, um die entsprechende Ereignisprozedur anzulegen – und somit auch das benötigte Klassenmodul:<\/p>\n
Private Sub <\/span>cmdOK_Click()\r\n    DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\n
Danach wechseln wir wieder zum Modul mdlFormularinstanzen<\/b>, wo wir eine neue Prozedur namens Formularinstanz <\/b>hinzufügen und für diese eine Variable namens frm <\/b>deklarieren. Diese soll den Typ des Klassenmoduls des Formulars frmKunde <\/b>erhalten, der dann auch prompt per IntelliSense angeboten wird (siehe Bild 3). Also führen wir nun die geplanten Schritte durch, die wie folgt aussehen – deklarieren, initialisieren und sichtbar machen:<\/p>\n
\"Formularklasse<\/a><\/p>\n
Bild 3: Formularklasse per IntelliSense<\/p>\n
Public Sub <\/span>Formularinstanz()\r\n    Dim <\/span>frm As <\/span>Form_frmKunde\r\n    Set<\/span> frm = New<\/span> Form_frmKunde\r\n    frm.Visible = True<\/span>\r\nEnd Sub<\/span><\/pre>\n
Der Plan war nicht gut genug: Das Formular erscheint für Bruchteile einer Sekunde und verschwindet dann wieder. Der Grund ist eindeutig: Die Variable frm<\/b>, mit der wir es referenzieren, ist innerhalb der Prozedur Formularinstanz deklariert.<\/p>\n
Das heißt, dass ihre Lebensdauer mit dem Ablauf des Formulars endet. Die Folgerung: Die Variable muss außerhalb der Prozedur deklariert werden. Mit der folgenden Variante klappt es besser – das Formular erscheint wie gewünscht:<\/p>\n
Dim <\/span>frm As <\/span>Form_frmKunde\r\nPublic Sub <\/span>Formularinstanz()\r\n    Set<\/span> frm = New<\/span> Form_frmKunde\r\n    frm.Visible = True<\/span>\r\nEnd Sub<\/span><\/pre>\n
Mit der Schaltfläche cmdOK <\/b>lässt es sich auch problemlos wieder schließen.<\/p>\n
Gewünschten Datensatz anzeigen<\/h2>\n
Es fehlt allerdings noch die Möglichkeit, gleich beim Anzeigen einen bestimmten Datensatz anzuzeigen. Normalerweise haben wir diesen mit dem Parameter WhereCondition <\/b>übergeben, der uns hier aber nicht zur Verfügung steht.<\/p>\n
Allerdings haben wir ja nun eine Objektvariable, mit der wir auf die Instanz des Formulars verweisen. Warum also nicht gleich auch die Eigenschaften des Formulars nutzen – wie beispielsweise die Filter<\/b>-Eigenschaft Erweitern wir also unsere Prozedur und fügen einen Filterausdruck hinzu, der den Kunden mit dem Wert 2 <\/b>für das Feld KundeID <\/b>liefert:<\/p>\n
Public Sub <\/span>Formularinstanz()\r\n    Set<\/span> frm = New<\/span> Form_frmKunde\r\n    frm.Visible = True<\/span>\r\n    frm.Filter = \"KundeID = 2\"\r\n    frm.FilterOn = True<\/span>\r\nEnd Sub<\/span><\/pre>\n
Das erneute Ausführen der Prozedur zeigt nun den gewünschten Kunden an (siehe Bild 4). Nun ändern wir die Zeile mit dem Filter wie folgt:<\/p>\n
Bild 4: Formularinstanz mit Wunschkunde<\/p>\n
frm.Filter = \"KundeID = 3\"<\/pre>\n
Rufen wir die Prozedur nun erneut auf, zeigt das Formular zwar den gewünschten Kunden an, allerdings ist das Formular mit dem vorherigen Kunden nicht mehr vorhanden. Kein Wunder: Wir haben ja nur eine Instanzvariable namens frm<\/b>, deren Inhalt beim überschreiben gelöscht wird – und mit ihm das referenzierte Formular.<\/p>\n
Mehrere Instanzen öffnen<\/h2>\n
Wie öffnen wir nun mehrere Instanzen gleichzeitig Die einfachste Methode: Wir deklarieren einfach für jede Instanz eine eigene Variable. Dies dient zunächst nur Beispielzwecken, um zu veranschaulichen, wie es funktioniert. Jede der beiden Instanzen aus dem folgenden Beispiel wir durch die neue Prozedur Formularinstanzen initialisiert, eingeblendet und mit dem gewünschten Datensatz versehen. Das Ergebnis sieht wie in Bild 5 aus:<\/p>\n
\"Zwei<\/a><\/p>\n
Bild 5: Zwei Formularinstanzen<\/p>\n
Dim <\/span>frm1 As <\/span>Form_frmKunde\r\nDim <\/span>frm2 As <\/span>Form_frmKunde\r\nPublic Sub <\/span>Formularinstanzen()\r\n    Set<\/span> frm1 = New<\/span> Form_frmKunde\r\n    With<\/span> frm1\r\n        .Visible = True<\/span>\r\n        .Filter = \"KundeID = 1\"\r\n        .FilterOn = True<\/span>\r\n    End With<\/span>\r\n    Set<\/span> frm2 = New<\/span> Form_frmKunde\r\n    With<\/span> frm2\r\n        .Visible = True<\/span>\r\n        .Filter = \"KundeID = 2\"\r\n        .FilterOn = True<\/span>\r\n    End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Damit haben wir schon einmal gezeigt, wie es gelingen kann. Allerdings ist dies natürlich keine tragfähige Lösung, denn wir wollen ja nicht für jeden zu öffnenden Kunden eine eigene Objektvariable deklarieren und die Prozedur Formularinstanzen entsprechend erweitern – zudem wir ja nicht absehen können, wie viele Kunden der Benutzer anzeigen möchte.<\/p>\n
Und es gibt noch ein weiteres Problem: Die beiden Formular werden genau übereinander geöffnet, wodurch der Benutzer gar nicht erkennen kann, dass mehrere Formular existieren.<\/p>\n
Viele Objekte verwalten<\/h2>\n
Wir kümmern uns zunächst darum, mehrere Formularinstanzen zu öffnen, ohne dass wir für jede eine eigene Variable deklarieren müssen. Aber wie erledigen wir das Voraussetzung ist, dass wir irgendwie eine Referenz auf die Formularinstanz halten, ohne dafür jeweils eine eigene Variable bereitstellen zu müssen. Dafür gibt es eine einfache Möglichkeit: Wir verwenden nur eine Objektevariable, die wir diesmal wieder innerhalb der Prozedur deklarieren und füllen. Diesmal speichern wir diese allerdings vor dem Prozedurende in einer Collection! Diese deklarieren wir wie folgt im Kopf des Standardmoduls:<\/p>\n
Public <\/span>colForms As <\/span>Collection<\/pre>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Access [basics]<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 400 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t
\"Formularinstanz<\/a><\/p>\n