<\/p>\n
Unter VBA gibt es Gelegenheiten, wo man zwischen zwei Elemente entweder einen Punkt oder ein Aufrufezeichen setzen kann, zum Beispiel bei gebundenen Steuerelementen in der Form Me.Vorname oder rst!Vorname. Im Gegensatz dazu stehen beispielsweise die Elemente eines Recordsets – hier können wir nur rst!Vorname verwenden, rst.Vorname führt zu einem Fehler. Ganz kompliziert wird es, wenn wir gebundene Steuerelemente auch noch umbenennen. Dann können wir auf den Wert des Steuerelements sowohl über Me!Vorname, Me.Vorname, Me!txtVorname oder Me.txtVorname zugreifen. Und manchmal führt die Syntax mit dem Punkt zu ernsthaften Verwirrungen, weshalb man in manchen Fällen auf jeden Fall die Ausrufezeichen-Syntax nutzen sollte.<\/b><\/p>\n
Wir fangen mal vorn an: Von Punkten und Ausrufezeichen bleibt man solange verschont, wie man nicht per VBA auf den Inhalt von Steuerelementen oder Feldern zugreifen möchte. Das Problem daran ist: Ohne das ist man dabei recht eingeschränkt. Das Gute ist: Wenn man einmal an die Stelle gelangt ist, wo man Objektbezüge über Punkte und\/oder Ausrufezeichen herstellt, kann man nicht viel falsch machen – und wo es dabei Stolpersteine gibt, erläutern wir in diesem Beitrag.<\/p>\n
Wir beginnen dort, wo der Einsatz eindeutig geregelt ist. Wenn man beispielsweise eine Schleife programmieren möchte, mit der man die Datensätze eines Recordsets durchläuft, möchte man auf die Felder dieses Recordsets zugreifen. Das Recordset bietet einige Eigenschaften und Methoden an, die man wie bei allen Objekten mit der Punkt-Syntax adressieren kann, also indem man den Namen der Objektvariablen, meist rst<\/b>, eingibt und dann einen Punkt setzt, um per IntelliSense die möglichen Elemente zu sehen. Das Ergebnis ist eine Liste wie in Bild 1.<\/p>\n
![\"Nutzung](\"..\/fileadmin\/_temp_\/2023_01\/pic_1414_001.png\")
<\/p>\n
Bild 1: Nutzung des Punktes für die Anzeige von Elementen per IntelliSense<\/span><\/b><\/p>\n Darüber findet man beim Recordset alle möglichen Einträge, aber nicht die Felder des Recordsets. Diese können wir auch nicht über die Punkt-Syntax referenzieren. rst.KategorieID <\/b>funktioniert also nicht, sondern wirft den Fehler Methode oder Datenobjekt nicht gefunden<\/b>. Stattdessen nutzen wir an dieser Stelle in der kürzesten Form das Ausrufezeichen, also beispielsweise rst!KategorieID<\/b>. Wir haben hier keine IntelliSense-Unterstützung, aber immerhin liefert dies den Wert des Feldes für den jeweiligen Datensatz. Im Detail sieht das wie im folgenden Beispiel aus:<\/p>\n Wie wir hier sehen, werden die Eigenschaften und Methoden, also EOF <\/b>oder MoveNext<\/b>, mit der Punkt-Syntax verwendet. Wir haben in diesem Fall also eine eindeutige Aufteilung: Eigenschaften und Methoden erreichen wir mit einem Punkt, die Felder mit dem Ausrufezeichen.<\/p>\n Warum aber können wir die Felder überhaupt mit dem Ausrufezeichen adressieren? Weil es sich bei den Feldern um Elemente einer Auflistung handelt, genau genommen sogar um die einer Auflistung mit benutzerdefinierten Elementen, und weil das Ausrufezeichen in diesem Fall als Abkürzung für eine ausführlichere Schreibweise verwendet werden kann. rst!KategorieID <\/b>steht nämlich eigentlich für ein Element der Fields<\/b>-Auflistung des Recordset<\/b>-Objekts:<\/p>\n Und auch das ist noch nicht die ganze Wahrheit, denn rst.Fields(„Kategorie“) <\/b>können wir auch nur verwenden, weil man die Standardeigenschaft eines Elements immer weglassen kann. Eigentlich heißt der Ausdruck nämlich wie folgt, und dabei ist Value <\/b>die Standardeigenschaft des Field<\/b>-Objekts, das wir mit Fields(„KategorieID“) <\/b>referenzieren:<\/p>\n Das Beispiel finden Sie im Modul mdlPunktUndAusrufezeichenInRecordset<\/b>.<\/p>\n Eine andere Situation finden wir vor, wenn wir die Klassenmodule von Formularen oder Berichten betrachten, die an eine Datensatzquelle wie eine Tabelle oder Abfrage gebunden sind – und hier speziell bei den Steuerelementen und den Feldern der Datensatzquelle.<\/p>\n Binden wir ein Formular an eine Tabelle wie tblKategorien<\/b>, welche die beiden Felder KategorieID <\/b>und Kategorie <\/b>enthält, und fügen wir diese beiden Felder zum Detailbereich des Formularentwurfs hinzu, können wir beispielsweise in der VBA-Ereignisprozedur, die durch eine Schaltfläche ausgelöst wird, wie folgt auf die Werte der gebundenen Felder zugreifen:<\/p>\n Wir nutzen also einfach mit Me <\/b>den Verweis auf das Klassenmodul selbst und können dann nach Eingabe des Punktes nicht nur auf die Eigenschaften und Methoden des Formulars zugreifen, sondern auch auf die Feldnamen der Datensatzquelle des Formulars.<\/p>\n Noch besser: Obwohl es sich hier nicht um eingebaute Eigenschaften der Formularklasse handelt, können wir IntelliSense nutzen, um darauf zuzugreifen – siehe Bild 2! Warum ist das überhaupt möglich? Der Hintergrund ist, dass Access beim Hinzufügen einer Datensatzquelle zu einem Formular automatisch für jedes Feld eine eigene Eigenschaft zum Klassenmodul des Formulars hinzufügt. Deshalb werden diese auch per IntelliSense angezeigt. Wir können hier aber auch, genau wie beim Recordset<\/b>-Objekt, über die Ausrufezeichen-Syntax auf die Felder zugreifen. Das sieht so aus:<\/p>\n [<\/p>\n Bild 2: Zugriff per Punkt und IntelliSense auf die Felder der Datensatzherkunft<\/span><\/b><\/p>\n Auch hier haben wir es, genau wie beim Recordset, wieder mit einer Abkürzung zu tun, diesmal allerdings nicht für die Fields<\/b>-Auflistung, sondern für die Controls<\/b>-Auflistung. Weiter unten unter Was macht das Ausrufezeichen eigentlich genau?<\/b> erläutern wir, warum wir mit dem Ausrufezeichen einmal die Fields<\/b>– und einmal die Controls<\/b>-Auflistung abkürzen können.<\/p>\n Für das Feld KategorieID <\/b>würde ein etwas weniger verkürzter Ausdruck also wie folgt aussehen:<\/p>\n Und auch hier ist Value <\/b>die Standardeigenschaft, sodass wir schließlich bei der folgenden ausführlichen Variante landen:<\/p>\n Soweit, so gut: Wir können also sowohl mit der Punkt- als auch mit der Ausrufezeichen-Syntax auf die Steuerelemente eines Formulars zugreifen.<\/p>\n Schauen wir uns nun die Eigenschaften der gebundenen Felder an, die wir über die Feldliste zum Formular hinzugefügt haben, dann sehen wir, dass der Ausdruck KategorieID <\/b>sowohl als Steuerelementname als auch für die Eigenschaft Steuerelementinhalt <\/b>angegeben wird (siehe Bild 3). Worauf greifen wir also eigentlich genau zu, wenn wir Me.KategorieID <\/b>oder Me!KategorieID <\/b>referenzieren?<\/p>\n Bild 3: Name und Steuerelementinhalt sind identisch.<\/span><\/b><\/p>\n Wir fügen der Prozedur für die Schaltfläche zwei Zeilen hinzu, um den Typ der mit Punkt und Ausrufezeichen angesprochenen Elemente zu ermitteln:<\/p>\n Das Ergebnis sieht wie folgt aus:<\/p>\n Wir greifen also in beiden Fällen auf das Steuerelement zu, welches durch die implizit angegebene Standardeigenschaft wiederum über das für Steuerelementinhalt angegebene Feld den Wert für den aktuellen Datensatz ermittelt.<\/p>\n Den Beispielcode finden Sie im Klassenmodul des Formulars frmKategorien<\/b>.<\/p>\n Jetzt gestalten wir es etwas interessanter: Wir benennen die Steuerelemente KategorieID <\/b>und Kategorie <\/b>in txtKategorieID <\/b>und txtKategorie <\/b>um. In einer Ereignisprozedur lassen wir uns nun die Werte für KategorieID <\/b>in verschiedenen Konstellationen ausgeben:<\/p>\n Dies liefert für alle Ausdrücke den gleichen Wert, nämlich den Wert des Feldes KategorieID <\/b>der Datensatzquelle. Und nicht nur KategorieID<\/b>, sondern auch txtKategorieID <\/b>können über den Punkt per IntelliSense ausgewählt werden.<\/p>\n Nun setzen wir wieder die Typename<\/b>-Funktion ein, um herauszufinden, worauf wir zugreifen: <\/p>\n Das Ergebnis sieht nun wie folgt aus:<\/p>\n Nun greifen wir also mit txtKategorieID <\/b>nach wie vor auf die TextBox<\/b>-Elemente zu, aber mit KategorieID <\/b>direkt auf Elemente des Typs AccessField<\/b>. Das erklärt sich dadurch, dass es nun kein TextBox<\/b>-Element namens KategorieID <\/b>mehr gibt. Wenn ein gebundenes Steuerelement also genauso heißt wie das über die Eigenschaft Steuerelementinhalt <\/b>gebundene Feld, dann wird über den Feldnamen das entsprechende Steuerelement referenziert, anderenfalls das daran gebundene AccessField<\/b>-Element. Und immer noch können wir die Punkt- und die Ausrufezeichen-Syntax gleichermaßen verwenden.<\/p>\n Die Beispiele finden Sie im Klassenmodul des Formulars frmKategorienMitPraefix<\/b>.<\/p>\n Damit kommen wir zu den Fällen, wo die Punkt-Syntax nicht mehr zum Referenzieren von Steuerelementen oder Feldern verwendet werden kann beziehungsweise wo Probleme auftreten können. Das ist immer der Fall, wenn ein Feldname einer Tabelle oder Abfrage mit dem Namen einer Formulareigenschaft übereinstimmt.<\/p>\n Es gibt nicht sehr viele Formular-Eigenschaften, die öfter mal als Feldname verwendet werden, aber potenzielle Kandidaten sind Caption<\/b>, Filter<\/b>, Page<\/b>, Parent<\/b>, Picture<\/b>, Properties<\/b>, Tag<\/b>, Width <\/b>und andere. Die Bezeichnung Name <\/b>wird praktischerweise direkt beim Versuch, ein solches Feld anzulegen, als mögliche Feldbezeichnung ausgeschlossen. Andere lassen sich aber ohne Weiteres als Feldnamen verwenden (siehe Bild 4).<\/p>\n Bild 4: Feldnamen, die nach Formulareigenschaften benannt sind<\/span><\/b><\/p>\n Nun legen wir für die Eigenschaft Beschriftung <\/b>eines Formulars namens frmProbleme <\/b>den Wert Formulartitel <\/b>fest. Unter VBA heißt diese Eigenschaft Caption<\/b>, was gleich noch wichtig sein wird.<\/p>\n Diesem Formular fügen wir nun die oben beschriebene Tabelle tblCategories <\/b>hinzu, welche das Feld Caption <\/b>enthält, und ziehen dieses Feld in den Detailbereich des Formularentwurfs, was ein neues Feld namens Caption <\/b>anlegt – mit dem Wert Caption <\/b>für die Eigenschaft Steuerelementinhalt<\/b>. Für die Schaltfläche hinterlegen wir den folgenden Code und lassen uns somit wieder den Inhalt eines Feldes ausgeben – einmal mit dem Punkt- und einmal mit dem Ausrufezeichen-Operator:<\/p>\n Das Ergebnis sieht wie folgt aus (der Wert des Feldes Caption <\/b>heißt Caption 1<\/b>):<\/p>\n Wenn es ein Feld gibt, das genauso wie eine Eigenschaft des Formulars heißt, greifen wir also über die Punkt-Syntax auf die Eigenschaft und über die Ausrufezeichen-Syntax auf das Steuerelement zu! Und das ist auch der einzige Grund, warum man das Ausrufezeichen dem Punkt vorziehen sollte, wenn es um das Referenzieren von Steuerelementen oder Feldern der Datensatzquelle eines Formulars geht. Es könnte irgendwann mal Probleme geben, wenn eine Tabelle ein nach einer Formulareigenschaft benanntes Feld enthält.<\/p>\n Ich persönlich verwende immer zuerst den Punkt, um mit IntelliSense schnell die Steuerelemente oder Felder auszuwählen, und ersetze den Punkt dann durch das Ausrufezeichen. Wenn man Steuerelemente mit Präfixen wie txt<\/b>, cbo <\/b>oder cmd <\/b>ersetzt, sinkt die Wahrscheinlichkeit, dass ein solches den gleichen Namen hat wie eine Formulareigenschaft, allerdings quasi auf Null.<\/p>\n Bei Berichten finden wir (zumindest in älteren Versionen von Access) noch eine etwas andere Situation vor: Hier werden beim Festlegen der Datensatzquelle nicht automatisch alle Felder als Eigenschaften zur Report<\/b>-Klasse hinzufügt. Dies geschieht erst, wenn man die jeweiligen Felder zum Entwurf des Berichts hinzufügt. Um dort über die Punkt- oder Ausrufezeichen-Syntax auf ein Feld zugreifen zu können, muss dieses zum Bericht hinzugefügt werden. Allerdings konnte ich dieses Verhalten mit der aktuellen Version von Access (Microsoft Access für Microsoft 365 MSO (Version 2211 Build 16.0.15806.20000) nicht mehr nachvollziehen, hier waren die Feldnamen der Datensatzquelle direkt nach dem Hinzufügen der selbigen per VBA\/IntelliSense referenzierbar.<\/p>\n Wir haben weiter oben gesehen, das das Ausrufezeichen beim Recordset<\/b>-Objekt den Zugriff auf die Fields<\/b>-Auflistung abkürzen kann und beim Form<\/b>-Objekt offensichtlich den Zugriff auf die Controls<\/b>-Auflistung. Aber wo wird eigentlich festgelegt, in welchem Objekt das Ausrufezeichen welche Auflistung verkürzt referenzieren kann?<\/p>\n Dazu ist zunächst zu korrigieren, dass das Ausrufezeichen nicht ausschließlich die Referenzierung von Auflistungen verkürzen kann, sondern auch von anderen Eigenschaften – Voraussetzung ist lediglich, dass diese einen Wert des Typs String als Parameter entgegennimmt.<\/p>\n Außerdem verkürzt das Ausrufezeichen die Referenz genau auf die Eigenschaft einer Klasse, die als Standardeigenschaft festgelegt ist! Welche das ist, können wir beispielsweise im Objektkatalog nachsehen – es handelt sich dabei um das Objekt mit der Markierung aus Bild 5. Für diesen Eintrag ist außerdem im Beschreibungstext der Hinweis Standardelement von … <\/b>angegeben.<\/p>\nPublic Sub <\/span>PunktOderAusrufezeichen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"tblKategorien\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Debug.Print<\/span> rst!KategorieID, rst!Kategorie\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nDebug.Print<\/span> rst.Fields(\"KategorieID\")<\/pre>\nDebug.Print<\/span> rst.Fields(\"KategorieID\").Value<\/pre>\nEigenschaften und Felder in Formular- und Berichtsmodulen<\/h2>\n
Debug.Print<\/span> Me.KategorieID, Me.KategorieID<\/pre>\n![\"Zugriff](\"..\/fileadmin\/_temp_\/2023_01\/pic_1414_002.png\")
<\/p>\nDebug.Print<\/span> Me!KategorieID, Me!Kategorie<\/pre>\nDebug.Print<\/span> Me.Controls(\"KategorieID\")<\/pre>\nDebug.Print<\/span> Me.Controls(\"KategorieID\").Value<\/pre>\n![\"Name](\"..\/fileadmin\/_temp_\/2023_01\/pic_1414_003.png\")
<\/p>\nDebug.Print<\/span> \"Typename ''Me.KategorieID'': \" _\r\n & TypeName(Me.KategorieID)\r\nDebug.Print<\/span> \"Typename ''Me!KategorieID'': \" _\r\n & TypeName(Me!KategorieID)<\/pre>\nTypename ''Me.KategorieID'': TextBox\r\nTypename ''Me!KategorieID'': TextBox<\/pre>\n
Steuerelemente umbenennen<\/h2>\n
Debug.Print<\/span> Me.KategorieID\r\nDebug.Print<\/span> Me!KategorieID\r\nDebug.Print<\/span> Me.txtKategorieID\r\nDebug.Print<\/span> Me!txtKategorieID<\/pre>\nDebug.Print<\/span> \"Me.KategorieID: \" & TypeName(Me.KategorieID)\r\nDebug.Print<\/span> \"Me!KategorieID: \" & TypeName(Me!KategorieID)\r\nDebug.Print<\/span> \"Me.txtKategorieID: \" & TypeName(Me.txtKategorieID)\r\nDebug.Print<\/span> \"Me!txtKategorieID: \" & TypeName(Me!txtKategorieID)<\/pre>\nMe.KategorieID: AccessField\r\nMe!KategorieID: AccessField\r\nMe.txtKategorieID: TextBox\r\nMe!txtKategorieID: TextBox<\/pre>\n
Wann die Punkt-Syntax zum Problem wird<\/h2>\n
![\"Feldnamen,](\"..\/fileadmin\/_temp_\/2023_01\/pic_1414_004.png\")
<\/p>\nPrivate Sub <\/span>cmdOK_Click()\r\n Debug.Print<\/span> \"Me.Caption: \" & Me.Caption\r\n Debug.Print<\/span> \"Me!Caption: \" & Me!Caption\r\nEnd Sub<\/span><\/pre>\nMe.Caption: Formulartitel\r\nMe!Caption: Caption 1<\/pre>\n
Sonderfall Berichte<\/h2>\n
Was macht das Ausrufezeichen eigentlich genau?<\/h2>\n
![\"Markierung](\"..\/fileadmin\/_temp_\/2023_01\/pic_1414_005.png\")
<\/p>\n