Unter den Elementen, die den Programm-Code unter VBA strukturierter erscheinen lassen, findet die With-Anweisung oft wenig Berücksichtigung. Dabei spart man mit ihr nicht nur Programmtext ein, sondern erleichtert sich über IntelliSense zusätzlich das Schreiben von Objektmethoden. <\/p>\n
Die Beispiele dieses Artikels finden Sie in der Datenbank 1501_WithAnweisung.mdb<\/b>.<\/p>\nGrundlegende Syntax<\/h2>\n
Die With<\/b>-Anweisung stellt einen Bezug zu einer Variablen her, der entweder ein benutzerdefinierter Datentyp (UDT<\/b>) zugrunde liegt, oder ein Objekt. Ob diese in ihren eigenen Modulen deklariert sind, oder in einer Verweisbibliothek, spielt dabei keine Rolle. Die Blockanweisung besteht aus zwei Elementen, dem Blockstart und dem Blockende:<\/p>\n Nach dem reservierten Wort With<\/b> folgt der Name einer Variablen, auf die sich die Methoden, Eigenschaften oder Typelemente im Folgenden beziehen sollen.<\/p>\n Wird in einer Prozedur die Variable nicht mehr weiter benötigt, so schließt man den Bezug mit der Anweisung End With<\/b>. <\/p>\n Einen Code aus dem wahren Datenbankprogrammiererleben finden Sie im Listing 1 der Beispieldatenbank, wo auf eine Tabelle tblTest<\/b> eine Datensatzgruppe (Recordset<\/b>) geöffnet wird, um sie mit Datensätzen zu füllen und jene anschließend im VBA-Direktfenster auszugeben. In der ersten Zeile der Routine wird die Tabelle zunächst mit einer SQL-Anweisung per Database.Execute<\/b> geleert. Dann erfolgt das Setzen des Recordsets rsTest<\/b> auf die Tabelle. Die Recordset-Variable rsTest<\/b> wurde übrigens bereits im Modulkopf deklariert, ebenso die Zählervariable i<\/b>:<\/p>\n Listing 1: Durchlaufen der Datensätze einer Tabelle<\/p>\n Im weiteren Verlauf werden in einer Schleife auf den Zähler i<\/b> der Tabelle hundert Datensätze hinzugefügt, wobei für das Feld Code<\/b> jeweils ein dreistelliger zufälliger Buchstabencode generiert wird. Zum Schluss werden alle Datensatzinhalte wieder in einer Schleife über Debug.Print <\/b>in das VBA-Direktfenster ausgegeben. Das Ergebnis wäre etwa dieses:<\/p>\n Auffallend ist, dass der Variablenname rsTest<\/b> sehr häufig in der Routine auftaucht. Genau dies lässt sich mit der With<\/b>-Anweisung umgehen, indem zum Blockstart der Verweis auf rsTest<\/b> gesetzt wird und im Folgenden darauf nur noch indirekt Bezug genommen wird. Der abgewandelte Code steht in Listing 2.<\/p>\n Listing 2: Der gleiche Code unter Einsatz der With-Anweisung<\/p>\n Statt rsTest.AddNew<\/b> zum Anlegen eines neuen Datensatzes wird nun nur noch der Ausdruck .AddNew<\/b> benötigt – VBA denkt sich vor den Punkt den oben definierten Objektbezug.<\/p>\n Statt des Punktes ist auch der VBA-Ausrufezeichen-Operator für Auflistungen erlaubt. Deshalb lässt sich nun ein Feld des Recordsets statt über rsTest!Code<\/b> einfach mit !Code<\/b> ansprechen.<\/p>\n Kürzer wird die Routine damit nicht. Sie ist im Gegenteil wegen der With<\/b>-Anweisungen sogar um zwei Zeilen länger. Der Zeichenumfang ist jedoch geringer. Das spielt allerdings weniger eine Rolle als die nun erhöhte übersichtlichkeit des Codes. Die Methoden, Eigenschaften und Feldbezeichnungen des Recordsets treten nun optisch deutlicher zutage, weil sie isolierter dastehen. <\/p>\n Aber nicht nur die Gestalt des Programmcodes ändert sich damit, sondern auch die Art, wie VBA das Modul kompiliert. Denn bei jedem Ansprechen der Variablen rsTest <\/b>in der ersten Variante sucht es sich gesondert einen Zeiger auf die Objektvariable, um dann deren Methoden auszuführen. Bei With<\/b>-Blöcken wird intern nur ein Zeiger auf die Objektvariable angelegt und dann für die Methodenaufrufe mehrfach verwendet. Das führt zu einer geringfügig besseren Ausführungsgeschwindigkeit der Routine. Ehemals wurde die With<\/b>-Anweisung deshalb auch in Sammlungen zu Performance-Tipps aufgenommen, spielt aber in dieser Hinsicht heute keine nennenswerte Rolle mehr – ein paar Nanosekunden mehr oder weniger sind unerheblich.<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>Dim <\/span>Variable As <\/span>...\r\nWith<\/span> [Variable] 'Blockstart\r\n.[Methode oder]\r\n.[Eigenschaft] = ...\r\nEnd With<\/span> 'Blockende<\/pre>\nWith im Einsatz<\/h2>\n
Sub <\/span>OhneWITH()\r\n CurrentDb.Execute \"DELETE * FROM tblTest\"\r\n Set<\/span> rsTest = CurrentDb.OpenRecordset(\"SELECT * FROM tblTest\", dbOpenDynaset)\r\n For i = 1 To 100\r\n rsTest.AddNew<\/span>\r\n rsTest!ID = i\r\n rsTest!Code = Chr$(65 + 28 * Rnd) & Chr$(65 + 28 * Rnd) & Chr$(65 + 28 * Rnd)\r\n rsTest.Update\r\n Next<\/span> i\r\n \r\n rsTest.MoveFirst\r\n Do While<\/span> Not<\/span> rsTest.EOF\r\n Debug.Print<\/span> rsTest!ID, rsTest!Code\r\n rsTest.MoveNext<\/span>\r\n Loop<\/span>\r\n rsTest.Close\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>rsTest As <\/span>DAO.Recordset\r\nPrivate <\/span>i As Long<\/span><\/pre>\n 1 J\\Q\r\n 2 PEZ\r\n 3 BWU\r\n 4 H[N\r\n 5 ULG\r\n...<\/pre>\n
Sub <\/span>MitWITH()\r\n CurrentDb.Execute \"DELETE * FROM tblTest\"\r\n Set<\/span> rsTest = CurrentDb.OpenRecordset(\"SELECT * FROM tblTest\", dbOpenDynaset)\r\n With<\/span> rsTest\r\n For i = 1 To 100\r\n .AddNew<\/span>\r\n !ID = i\r\n !Code = Chr$(65 + 28 * Rnd) & Chr$(65 + 28 * Rnd) & Chr$(65 + 28 * Rnd)\r\n .Update\r\n Next<\/span> i\r\n .MoveFirst\r\n Do While<\/span> Not<\/span> .EOF\r\n Debug.Print<\/span> !ID, !Code\r\n .MoveNext<\/span>\r\n Loop<\/span>\r\n .Close\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nObjektvariablen überflüssig machen<\/h2>\n
\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