{"id":55001413,"date":"2023-02-01T00:00:00","date_gmt":"2023-06-17T09:32:24","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1413"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Ressourcenprobleme_mit_Recordsets","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Ressourcenprobleme_mit_Recordsets\/","title":{"rendered":"Ressourcenprobleme mit Recordsets"},"content":{"rendered":"

\"\"<\/p>\n

In letzter Zeit werde ich wieder häufiger von Entwicklerkollegen angesprochen, die Fehler wie „Nicht genügend Systemressourcen“ oder „Nicht genügend Speicherplatz zum Ausführen der Operation“ erhalten, wenn sie mehrere Formulare mit Daten öffnen oder Code ausführen, der mit Recordsets arbeitet. Wenn sie dann über den Taskmanager die Ressourcen des Systems betrachten, stellen sie fest, dass es hier keinerlei Engpässe gibt. Wir schauen uns in diesem Beitrag an, wie dieser Fehler entstehen kann und welche Möglichkeiten es gibt, diesen zu beheben.<\/b><\/p>\n

Fehlermeldungen zu erhalten, die nicht unmittelbar mit dem geschriebenen Code und eventuellen Syntax- oder Kompilierfehlern zusammenhängen, ist selten schön – erst recht nicht, wenn diese Fehler auf dem einen Rechner auftreten, auf dem anderen aber nicht oder zu anderen Zeitpunkten.<\/p>\n

Wir schauen uns in diesem Beitrag einmal an, wie wir die beiden eingangs genannten Fehler reproduzieren können. Anschließend kümmern wir uns um mögliche Lösungen für diese Fehler.<\/p>\n

Fehler „Nicht genügend Systemressourcen“ reproduzieren<\/h2>\n

Um diesen Fehler zu reproduzieren, erzeugen wir eine ausreichend große Menge von Recordset-Objekten. Um diese ohne viel Aufwand im Speicher zu halten, definieren wir ein Klassenmodul, das lediglich den Verweis auf das geöffnete Recordset-Objekt aufnehmen soll. Der Code dieses Klassenmoduls, das wir clsRecordsetWrapper <\/b>nennen wollen, sieht wie folgt aus:<\/p>\n

Private <\/span>m_Recordset As <\/span>Recordset\r\nPublic Property Set<\/span> <\/span>Recordset(rst As <\/span>DAO.Recordset)\r\n     Set<\/span> m_Recordset = rst\r\nEnd Property<\/span><\/pre>\n
Es enthält also lediglich eine private Variable, die den Verweis auf ein Recordset<\/b>-Objekt speichern soll. Um dieses an die Klasse zu übermitteln, haben wir dieser außerdem die Property Set<\/b>-Prozedur Recordset <\/b>zugewiesen, der wir als Parameter das zu speichernde Recordset übergeben.<\/p>\n
Diese Prozedur (siehe Listing 1) deklariert eine Collection<\/b>-Variable zum Speichern der Instanzen der Wrapper-Klasse, Variablen zum Speichern eines Verweises auf das Database<\/b>-Objekt der aktuellen Datenbank und des zu öffnenden Recordsets sowie für eine Instanz der Klasse clsRecordsetwrapper<\/b>. Außerdem instanziiert die Prozedur ein neues Collection<\/b>-Objekt und referenziert es mit der Variablen col<\/b>.<\/p>\n
Public Sub <\/span>Recordsets()\r\n     Dim <\/span>col As <\/span>Collection\r\n     Dim <\/span>i As Long<\/span>\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>rst As <\/span>DAO.Recordset\r\n     Dim <\/span>objRecordsetWrapper As <\/span>clsRecordsetwrapper\r\n     Set<\/span> db = CurrentDb\r\n     Set<\/span> col = New<\/span> Collection\r\n     For i = 1 To 10000\r\n         Set<\/span> objRecordsetWrapper = New<\/span> clsRecordsetwrapper\r\n         With<\/span> objRecordsetWrapper\r\n             On Error Resume Next<\/span>\r\n             Set<\/span> .Recordset = db.OpenRecordset(\"tblVieleKunden\", dbOpenDynaset)\r\n             If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n                 MsgBox<\/span> \"Fehler: \" & Err.Number & vbCrLf<\/span> & vbCrLf<\/span> & \"Beschreibung: \" & Err.Description _\r\n                     & vbCrLf<\/span> & vbCrLf<\/span> & \"Anzahl Recordsets: \" & i\r\n                 Exit Sub<\/span>\r\n             End If<\/span>\r\n             On Error GoTo<\/span> 0\r\n         End With<\/span>\r\n         col.Add objRecordsetWrapper\r\n         Debug.Print<\/span> i\r\n     Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Prozedur zum Erstellen einiger Recordsets und zum Speichern dieser in einer Wrapper-Klasse inklusive Fehlerbehandlung<\/span><\/b><\/p>\n
Die folgende For…Next<\/b>-Schleife wird maximal 10.000 Mal durchlaufen. Es ist allerdings davon auszugehen, dass unter der Standardkonfiguration normale Rechner nach ein paar hundert Iterationen aufgeben. Innerhalb der For…Next<\/b>-Schleife erstellen wir ein neues Objekt auf Basis der Klasse clsRecordsetwrapper <\/b>und weisen es der Variablen objRecordsetWrapper <\/b>zu.<\/p>\n
Dann weisen wir bei deaktivierter Fehlerbehandlung der Eigenschaft Recordsets <\/b>dieser Klasse ein mit OpenRecordset <\/b>neu geöffnetes Recordset auf Basis einer Beispieltabelle zu. Dies löst ab einer bestimmten Menge erstellter Recordsets den oben genannten Fehler aus. Ist das der Fall (oder tritt ein anderer Fehler auf), wollen wir diesen in einer Meldung ausgeben. Neben der Fehlernummer und der Fehlermeldung gibt die Meldung noch die Anzahl der geöffneten Recordsets aus. Nach der Anzeige der Fehlermeldung wird die Prozedur mit Exit Sub <\/b>beendet.<\/p>\n
Damit die Recordsets in der Wrapper-Klasse im Speicher verweilen und so erst dafür sorgen, dass der Fehler ausgelöst wird, fügen wir diese mit der Add<\/b>-Methode zu der Collection <\/b>namens col <\/b>hinzu.<\/p>\n
Rufen wir diese Prozedur nun auf, erscheint nach einigen bis etlichen Durchläufen der Schleife die Fehlermeldung aus Bild 1 (hier haben wir die Prozedur von einer Schaltfläche aus aufgerufen). Mit einem Klick auf OK <\/b>wird die Prozedur beendet und die durch die Recordset<\/b>-Variablen gebundenen Ressourcen werden wieder freigegeben. Der Fehler ist reproduzierbar und zeigt, dass in Abhängigkeit von der aktuellen Konfiguration des Systems und vermutlich auch abhängig von der aktuellen Auslastung mehr oder weniger Recordset<\/b>-Objekte erstellt werden können.<\/p>\n
\"Anzeige<\/p>\n
Bild 1: Anzeige der Fehlermeldung nach dem Öffnen von 305 Recordsets<\/span><\/b><\/p>\n
Fehler „Nicht genügend Speicherplatz zum Ausführen der Operation“ reproduzieren<\/h2>\n
Diesen Fehler konnten wir reproduzieren, indem wir einige Formularinstanzen aufgerufen haben. Da wir keine Lust hatten, viele verschiedene Formulare zu erstellen und diese zu öffnen, haben wir zu Beispielzwecken von einer Technik Gebrauch gemacht, die sonst zur Anzeige mehrerer Instanzen von Formularen mit verschiedenen Datensätzen verwendet wird.<\/p>\n
Das Formular ist ein einfaches Formular, das wir über die Eigenschaft Datensatzquelle <\/b>an die Tabelle tblVieleKunden <\/b>gebunden haben (siehe Bild 2). Außerdem haben wir die Eigenschaft Enthält Modul <\/b>im Bereich Andere <\/b>des Eigenschaftenblatts auf Ja <\/b>eingestellt. Das ist nötig, damit wir mehrere Instanzen des Formulars erstellen können.<\/p>\n
\"Das<\/p>\n
Bild 2: Das an eine Tabelle gebundene Formular<\/span><\/b><\/p>\n
Die Prozedur finden Sie in Listing 2. Hier deklarieren wir eine Variable für ein Collection<\/b>-Objekt und eines zum Erfassen des aktuellen Formulars. Dabei verwenden wir gleich den Typ des Klassenmoduls dieses Formulars, in diesem Fall Form_frmRecordset<\/b>.<\/p>\n
Public Sub <\/span>VieleFormulareMitRecordsetOeffnen()\r\n     Dim <\/span>col As <\/span>Collection\r\n     Dim <\/span>i As Long<\/span>\r\n     Dim <\/span>frm As <\/span>Form_frmRecordset\r\n     Set<\/span> col = New<\/span> Collection\r\n     For i = 1 To 10000\r\n         On Error Resume Next<\/span>\r\n         Set<\/span> frm = New<\/span> Form_frmRecordset\r\n         If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n             MsgBox<\/span> \"Fehler: \" & Err.Number & vbCrLf<\/span> & vbCrLf<\/span> & \"Beschreibung: \" & Err.Description _\r\n                 & vbCrLf<\/span> & vbCrLf<\/span> & \"Anzahl Formulare: \" & i\r\n             Exit Sub<\/span>\r\n         End If<\/span>\r\n         On Error GoTo<\/span> 0\r\n         col.Add frm\r\n         Debug.Print<\/span> i\r\n     Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n
[<\/p>\n
Listing 2: Prozedur zum Erstellen mehrerer Formularinstanzen mit Bindung an eine Tabelle<\/span><\/b><\/p>\n
Danach instanziieren wir die Collection und starten in eine For…Next<\/b>-Schleife, wie wir wieder bis zu 10.000 Mal durchlaufen. Das sollte reichen, um auch die beste Konfiguration in die Knie zu zwingen. Innerhalb der Schleife deaktivieren wir direkt die eingebaute Fehlerbehandlung. In der folgenden Anweisung weisen wir der Variablen frm <\/b>eine neue Instanz der Formularklasse Form_frmRecordset <\/b>zu.<\/p>\n
Ist dabei ein Fehler aufgetreten, wird dieser innerhalb der folgenden If…Then<\/b>-Bedingung mithilfe eines Meldungsfensters ausgegeben. Auch hier geben wir wieder die Fehlernummer, die Fehlerbeschreibung und die Anzahl der bisher geöffneten Formulare aus (siehe Bild 3).<\/p>\n
\"Fehlermeldung<\/p>\n
Bild 3: Fehlermeldung bei zu vielen per Formular geöffneten Recordsets<\/span><\/b><\/p>\n
Sollte beim Erstellen der aktuellen Formularinstanz kein Fehler aufgetreten sein, fügen wir die Variable frm <\/b>mit dem Verweis auf diese Instanz der Collection col <\/b>hinzu und laufen mit der For…Next<\/b>-Schleife in den nächsten Durchgang.<\/p>\n
Wir könnten die geöffneten Formulare auch noch anzeigen, aber das sorgt lediglich dafür, dass der Vorgang mehr Zeit in Anspruch nimmt.<\/p>\n
Den gleichen Vorgang haben wir noch mit einem weiteren Formular reproduziert, das diesmal nicht selbst an die Tabelle tblVieleKunden <\/b>gebunden war, sondern ein Kombinationsfeld mit dieser Tabelle als Datensatzquelle enthielt. Hier haben wir den gleichen Fehler erhalten wie beim gebundenen Formular.<\/p>\n
Behandlung des Fehlers in Formularen<\/h2>\n
In den beiden vorherigen Beispielen haben wir den Fehler jeweils per VBA ausgelöst, sodass wir eine Idee bekommen konnten, woran das Problem ungefähr gelegen hat. Das ist ganz anders, wenn der Benutzer nur wenige Formulare öffnet, die aber sehr viele Recordsets nutzen – für die eigene Datensatzquelle, als Datensatzquelle für Unterformulare oder als Datensatzherkunft für Kombinationsfelder und Listenfelder.<\/p>\n
Öffnet er eines dieser Formulare zu viel, erhält er gegebenenfalls noch nicht einmal einen VBA-Fehler, sondern die Meldung aus Bild 4.<\/p>\n
\"Fehlermeldung<\/p>\n
Bild 4: Fehlermeldung beim Auslösen durch das Öffnen eines Formulars ohne VBA-Beteiligung<\/span><\/b><\/p>\n
Mit dieser können unerfahrene Benutzer und Entwickler nur wenig anfangen, zumal dieser Fehler je nach Auslastung des Systems mal auftritt und mal nicht.<\/p>\n
Wenn Sie diesen Fehler reproduzieren wollen, empfehle ich den Aufruf der Prozeduren aus dem Modul mdlRecordset_InSpeichern<\/b>. Hier haben wir aus der Prozedur VieleFormulareMitRecordsetOeffnen<\/b>, die wir weiter oben bereits vorgestellt haben, die Deklaration der Collection-Variablen col <\/b>und das Instanziieren der Collection ausgegliedert. Die Variable haben wir als öffentliche Variable deklariert, damit diese nach dem Durchlaufen der Prozedur nicht gelöscht wird. Das Instanziieren haben wir in die Prozedur SetCollection <\/b>ausgelagert, damit wir dies separat erledigen können. Zum Reproduzieren rufen Sie nacheinander die Prozeduren SetCollection <\/b>und VieleFormulareMitRecordsetOeffnen <\/b>auf.<\/p>\n
Letztere führt irgendwann zum Auftreten des obligatorischen Fehlers und damit dürfte der verfügbare Speicher annähernd ausgereizt sein. Wenn Sie nun manuell nochmals das Formular frmRecordset <\/b>per Doppelklick auf den entsprechenden Eintrag im Navigationsbereich öffnen, könnte der Fehler bereits erneut ausgelöst werden.<\/p>\n
Vielleicht wurde aber auch zwischenzeitlich wieder Speicher freigegeben, sodass Sie erst noch einmal die Prozedur VieleFormulareMitRecordsetOeffnen <\/b>aufrufen müssen, bevor das erneute Öffnen des Formulars frmRecordset <\/b>den Fehler auslöst. <\/p>\n
Optimieren der Systemkonfiguration zur Vermeidung des Fehlers<\/h2>\n
Wir haben nun zunächst ein paar Mal die Prozedur Recordsets aufgerufen, um einen ungefähren Wert für die Anzahl der möglichen Recordsets ohne Auftreten eines Fehlers zu ermitteln. Auf unserem System erhielten wir auf diese Weise Werte zwischen 280 und 300.<\/p>\n
Wir haben anschließend verschiedene Möglichkeiten ausprobiert, den Fehler hinauszuzögern. Diese haben jedoch alle keinen nachhaltigen Erfolg geliefert, daher teilen wir die entsprechenden Links erst gar nicht.<\/p>\n
Optimieren von Access zum Vermeiden des Fehlers<\/h2>\n
Eine gut funktionierende Lösung ist die von Philipp Stiefel. Wer alle Hintergrundinformationen lesen möchte, findet diese auf der folgenden Webseite. Hier ist auch das VBA-Modul zu finden, das wir im Folgenden als zumindest temporäre Lösung beschreiben:<\/p>\n
https:\/\/codekabinett.com\/rdumps.php?Lang=2&targetDoc=largeaddressaware-msaccess-exe<\/pre>\n
Wir erklären an dieser Stelle einfach nur die notwendigen Schritte, um die Lösung umzusetzen. Diese beinhaltet das Manipulieren der Access.exe<\/b>-Datei. Das heißt, man legt besser vorher eine Sicherungskopie dieser Datei an.<\/p>\n
Da wir die Access-Anwendung selbst manipulieren wollen, können wir dies logischerweise nicht im laufenden Betrieb erledigen. Also schließen wir alle Access-Instanzen und öffnen eine andere Anwendung, in der wir VBA-Code ausführen können – also beispielsweise Word, Excel oder Outlook.<\/p>\n
Wichtig: Die jeweilige Anwendung müssen wir als Administrator aufrufen. Klicken Sie also mit der rechten Maustaste auf die jeweilige Anwendung und wählen Sie aus dem Kontextmenü den Eintrag Als Administrator ausführen <\/b>aus.<\/p>\n
Danach öffnen wir mit der Tastenkombination Alt + F11 <\/b>den VBA-Editor. Nun benötigen wir das VBA-Modul, das Philipp Stiefel in dem oben genannten Artikel zur Verfügung stellt. Der notwendige Downloadlink befindet sich dort in einem grau hinterlegten Kasten.<\/p>\n
Nachdem wir das VBA-Modul heruntergeladen haben, entpacken wir es und ziehen die .bas<\/b>-Datei aus dem Windows Explorer direkt in den Projekt-Explorer im VBA-Editor.<\/p>\n
Auf diese Weise wird der Inhalt der Datei als neues Modul zum VBA-Projekt hinzugefügt.<\/p>\n
Das Modul enthält neben einigen Konstanten die Hauptprozedur SetLaaFlag<\/b>. Diese hat zwei Parameter:<\/p>\n