{"id":55000678,"date":"2009-08-01T00:00:00","date_gmt":"2020-05-22T22:16:59","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=678"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Validieren_mit_Klasse","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/","title":{"rendered":"Validieren mit Klasse"},"content":{"rendered":"<p><img loading=\"lazy\" decoding=\"async\" src=\"http:\/\/vg02.met.vgwort.de\/na\/e4a82811fa48419d886ca0b06b6746b8\" width=\"1\" height=\"1\" alt=\"\"><\/p>\n<p><b>Das Validieren von Daten in Formularen ist normalerweise eine langweilige Arbeit, die man gew&ouml;hnlich an das Ende der Formularentwicklung packt. Die Anzahl der m&ouml;glichen F&auml;lle, die durch eine Validierung abgefangen werden sollen, ist &uuml;berschaubar und die n&ouml;tigen Codezeilen sehen sich meist sehr &auml;hnlich: Pr&uuml;fen, Fokus auf das Feld setzen, Aktualisierung abbrechen, Meldung ausgeben. Mit ein paar einfachen Klassen l&auml;sst sich diese Arbeit ein wenig spannender gestalten und am Ende sparen Sie sogar noch Code und somit Zeit.<\/b><\/p>\n<p>Welche F&auml;lle treten bei der Validierung der Steuerelemente von Formularen auf Der einfachste ist wohl der, bei dem ein Feld unabh&auml;ngig von allen anderen nur bestimmte Werte annehmen kann.<\/p>\n<p>Teilweise werden die dazu notwendigen Regeln m&ouml;glicherweise schon im Tabellenentwurf festgelegt, teilweise m&uuml;ssen Sie sich selbst darum k&uuml;mmern.<\/p>\n<p>Gleiches gilt f&uuml;r Felder, deren Wertebereich durch ein oder mehrere weitere Felder eingeschr&auml;nkt wird &#8211; zum Beispiel sollte ein Feld namens <b>Startdatum <\/b>keinen Wert aufnehmen, der im Kalender hinter dem Wert des Feldes <b>Enddatum <\/b>liegt.<\/p>\n<p>Hier f&auml;llt die Pr&uuml;fung schon ein wenig umfangreicher aus: Es reicht ja nicht, einfach nur den Inhalt der beiden Felder zu vergleichen; gleichzeitig ist auch noch zu pr&uuml;fen, ob das jeweils andere Feld &uuml;berhaupt einen Wert aufweist.<\/p>\n<p>&Uuml;berhaupt stellt sich die Frage, wann der richtige Zeitpunkt f&uuml;r die Validierung ist: Direkt nach der Eingabe eines Wertes in ein Feld oder doch erst beim Klicken auf die <b>OK<\/b>&#8211; oder <b>Speichern<\/b>-Schaltfl&auml;che<\/p>\n<p>Ersteres w&uuml;rde die Pr&uuml;fung in das <b>Vor Aktualisierung<\/b>-Ereignis des Steuerelements verlegen, Letzteres betrifft die Ereignisprozedur gleichen Namens des Formulars selbst.<\/p>\n<p>Ein Beispiel f&uuml;r die Validierung eines Textfelds, das nicht Null sein darf, sieht etwa wie folgt aus:<\/p>\n<pre>Private Sub txt_BeforeUpdate(Cancel As Integer)\r\n    If IsNull(Me!txt) Then\r\n        MsgBox &quot;Bitte geben Sie einen Wert ein.&quot;\r\n        Cancel = True\r\n    End If\r\n    End Sub<\/pre>\n<p>Dieses Ereignis wird gleich beim Verlassen des ge&auml;nderten Feldes ausgel&ouml;st. Die Alternative zum Validieren des Feldes vor dem Speichern des kompletten Datensatzes sieht fast genau so aus &#8211; mit dem feinen Unterschied, dass das Ereignis nicht zu einem Steuerelement geh&ouml;rt, sondern durch das Formular selbst ausgel&ouml;st wird:<\/p>\n<pre>Private Sub Form_BeforeUpdate(Cancel As Integer)\r\n    If IsNull(Me!txt) Then\r\n        MsgBox &quot;Bitte geben Sie einen Wert ein.&quot;\r\n        Me!txt.SetFocus\r\n        Cancel = True\r\n    End If\r\n    End Sub<\/pre>\n<p>Deshalb ist hier auch noch eine zus&auml;tzliche Zeile n&ouml;tig, die den Fokus beim Fehlschlagen der Validierung auf das Feld mit den ung&uuml;ltigen Daten setzt.<\/p>\n<p><b>Validierungsregeln auf Tabellenebene<\/b><\/p>\n<p>Neben den manuell hinzugef&uuml;gten Validierungsmechanismen wie aus dem obigen Beispiel gibt es einige Validierungen, die Access automatisch durchf&uuml;hrt.<\/p>\n<p>Diese h&auml;ngen meist vom Datentyp ab: So k&ouml;nnen Sie f&uuml;r ein Datumsfeld nur g&uuml;ltige Datumsangaben speichern und ein Zahlenfeld kann nur Zahlen, aber keine Buchstaben aufnehmen. Diese und &auml;hnliche Verfehlungen w&uuml;rden einen Fehler auf Formularebene ausl&ouml;sen.<\/p>\n<p>Beim Einf&uuml;gen einer Zeichenkette in ein Zahlenfeld w&uuml;rde beispielsweise die Fehlermeldung <b>Sie haben einen Wert eingegeben, der f&uuml;r dieses Feld nicht g&uuml;ltig ist<\/b> auftreten.<\/p>\n<p>Mit der <b>BeforeUpdate<\/b>-Ereignisprozedur kommen Sie dieser Meldung nicht bei: Das Ereignis feuert erst nach dem Erscheinen der Fehlermeldung. Die einzige M&ouml;glichkeit, diese Meldung zu verhindern, ist das Formularereignis <b>Bei Fehler<\/b>, f&uuml;r das Sie beispielsweise die folgende Routine anlegen k&ouml;nnen:<\/p>\n<pre>Private Sub Form_Error(DataErr As Integer, _\r\n    Response As Integer)\r\n    MsgBox &quot;Formularfehler &quot; &amp; DataErr\r\n    Response = acDataErrContinue\r\n    End Sub<\/pre>\n<p><b>DataErr <\/b>liefert die gleiche Fehlernummer, wie <b>Err.Number <\/b>bei einer herk&ouml;mmlichen Fehlerbehandlung. Der R&uuml;ckgabewert <b>acDataErrContinue <\/b>f&uuml;r den Parameter <b>Response <\/b>sorgt daf&uuml;r, dass Access seine Meldung nicht mehr anzeigt.<\/p>\n<p>Prinzipiell entspricht die Wirkung unserer weiter oben vorgestellten Routine, die durch das Ereignis <b>Vor Aktualisierung <\/b>ausgel&ouml;st wird: Es erscheint eine Meldung, der Inhalt bleibt stehen und das Feld kann nicht verlassen werden.<\/p>\n<p class=\"zwischen-berschrift-oberer-spaltenrand\">Welche Steuerelemente werden validiert<\/p>\n<p>Die wichtigsten Kandidaten f&uuml;r eine Validierung sind Textfelder. Hier finden Sie sicher Kandidaten, f&uuml;r die Sie eine Validierung festlegen m&uuml;ssen, allein weil ihr Datentyp wie <b>Datum\/Zeit <\/b>oder <b>Zahl <\/b>eine Validierung n&ouml;tig macht.<\/p>\n<p>Daneben gibt es nat&uuml;rlich noch einige Validierungen, die f&uuml;r die Einhaltung der Gesch&auml;ftsregeln n&ouml;tig sind: Ist Datum A kleiner als Datum B Hat Zeichenkette XYZ die richtige Anzahl Zeichen Hier dreht es sich meist um Daten, die &uuml;ber Textfelder eingegeben werden. Daneben sind noch Kombinationsfelder, Listenfelder, Kontrollk&auml;stchen, Optionsgruppen und Umschaltfl&auml;chen interessant &#8211; andere Steuerelemente bleiben im Kontext dieses Beitrags au&szlig;en vor.<\/p>\n<p><b>Validierung ganz einfach<\/b><\/p>\n<p>Die L&ouml;sung dieses Beitrags liefert ein paar Objekte, die Sie einfach in eine Datenbank einlesen m&uuml;ssen, die Sie mit einer Validierungsfunktion versehen m&ouml;chten. Das geht ganz schnell:<\/p>\n<ul>\n<li class=\"aufz-hlung\">&Ouml;ffnen Sie die Zieldatenbank.<\/li>\n<li class=\"aufz-hlung\">Bet&auml;tigen Sie den Men&uuml;befehl <b>Datei|Externe Daten|Importieren <\/b>und w&auml;hlen Sie im folgenden Dialog die Beispieldatenbank dieses Beitrags aus.<\/li>\n<li class=\"aufz-hlung\">Es erscheint der Dialog <b>Objekte importieren<\/b>, &uuml;ber den Sie die ben&ouml;tigten Objekte markieren und den Import mit einem Klick auf <b>OK <\/b>starten.<\/li>\n<\/ul>\n<p>Sie brauchen die folgenden Objekte:<\/p>\n<ul>\n<li class=\"aufz-hlung\">Standardmodule <b>mdlGlobal <\/b>und <b>mdlValidation<\/b><\/li>\n<li class=\"aufz-hlung\">Klassenmodule <b>clsControlValidation<\/b>, <b>clsFormValidation <\/b>und <b>clsValidation<\/b><\/li>\n<\/ul>\n<p>Legen Sie dann ein Beispielformular an, weisen Sie diesem eine Tabelle mit Feldern unterschiedlicher Datentypen zu (zum Beispiel die Tabelle <b>tblPersonal <\/b>aus der S&uuml;dwind-Datenbank, einer modifizierten Version der Nordwind-Datenbank) und ziehen Sie die Felder in die Entwurfsansicht eines neuen Formulars, das in diesem Beispiel den Namen <b>frmBeispielValidierung <\/b>tr&auml;gt.<\/p>\n<p>Erstellen Sie dann ein Klassenmodul f&uuml;r dieses Formular, indem Sie die Formulareigenschaft <b>Enth&auml;lt Modul <\/b>auf <b>Ja <\/b>einstellen. Wechseln Sie dann mit der Tastenkombination <b>Alt + F11 <\/b>zum VBA-Editor und klicken Sie dort im Projektexplorer (falls nicht sichtbar, mit <b>Strg + R <\/b>einblenden) doppelt auf den neuen Eintrag <b>Form_frmBeispielValidierung<\/b>.<\/p>\n<p>Es erscheint ein neues, leeres Codefenster. F&uuml;gen Sie dort die folgende Deklaration ein (siehe (auch Bild 1)):<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2009_04\/ValidierenMitKlasse-web-images\/pic001_opt.jpeg\" alt=\"pic001.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 2: Das Beispielformular in der Entwurfsansicht<\/span><\/b><\/p>\n<pre>Dim objValidation As clsValidation<\/pre>\n<p>Schauen wir uns das Formular an, das nach dem Anlegen einer <b>OK<\/b>-Schaltfl&auml;che wie in Bild 2 aussieht. Wir verwenden das Feld <b>Nachname<\/b> f&uuml;r ein erstes Experiment. Damit die Validierung funktioniert, muss das oben deklarierte Objekt <b>objValidation <\/b>des Typs <b>clsValidation <\/b>instanziert werden. Der richtige Zeitpunkt hierf&uuml;r ist das Laden des Formulars und somit das Ereignis <b>Beim Laden<\/b>. Dieses legen Sie direkt im VBA-Editor an, indem Sie aus dem linken Kombinationsfeld des Codefensters f&uuml;r das Klassenformular <b>Form_frmValidierungBeispiel <\/b>den Eintrag <b>Form <\/b>ausw&auml;hlen. Es erscheint automatisch eine Ereignisprozedur namens <b>Form_Load<\/b> (siehe Bild 3).<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2009_04\/ValidierenMitKlasse-web-images\/pic002_opt.jpeg\" alt=\"pic002.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 1: Der VBA-Editor mit der Deklaration der Validierungsklasse im Klassenmodul des Zielformulars<\/span><\/b><\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2009_04\/ValidierenMitKlasse-web-images\/pic003_opt.jpeg\" alt=\"pic003.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 3: Die automatisch angelegte Ereignisprozedur Form_Load<\/span><\/b><\/p>\n<p>Diese erg&auml;nzen Sie zun&auml;chst um folgende Anweisung, um das Objekt <b>objValidation <\/b>zu instanzieren:<\/p>\n<pre>Set objValidation = New clsValidation<\/pre>\n<p>Die Klasse <b>objValidation <\/b>bietet vor allem zwei Methoden, aber auch noch einige Eigenschaften, auf die Sie leicht &uuml;ber IntelliSense zugreifen k&ouml;nnen (siehe Bild 4). Die erste hei&szlig;t <b>AddControlValidation <\/b>und erlaubt das Anlegen von Validierungen, die direkt nach dem &auml;ndern des Steuerelementinhalts ausgel&ouml;st werden.<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2009_04\/ValidierenMitKlasse-web-images\/pic005_opt.jpeg\" alt=\"pic005.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 4: Hinzuf&uuml;gen einer Methode zum Anlegen einer Validierung per IntelliSense<\/span><\/b><\/p>\n<p>Die zweite hei&szlig;t <b>AddFormValidation <\/b>und bezieht sich ebenfalls auf ein Steuerelement, wird aber erst kurz vor dem Speichern des Datensatzes ausgel&ouml;st. Beide Methoden haben die gleiche Syntax und erwarten die folgenden Parameter (siehe (auch Bild 5)):<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2009_04\/ValidierenMitKlasse-web-images\/pic004_opt.jpeg\" alt=\"pic004.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 5: Die Parameter der Anweisung zum Anlegen einer Validierung<\/span><\/b><\/p>\n<ul>\n<li class=\"aufz-hlung\"><b>ctl<\/b>: Verweis auf das Steuerelement, das die Validierung ausl&ouml;st<\/li>\n<li class=\"aufz-hlung\"><b>eType<\/b>: Typ der Validierung, festgelegt in der Enumeration <b>eValidationType<\/b>. M&ouml;gliche Werte siehe weiter unten.<\/li>\n<li class=\"aufz-hlung\"><b>strTitle<\/b>: Zeichenkette, die beim Fehlschlagen der Validierung als Titel des Meldungsfensters angezeigt werden soll.<\/li>\n<li class=\"aufz-hlung\"><b>strMessage<\/b>: Zeichenkette, die beim Fehlschlagen der Validierung als Text des Meldungsfensters angezeigt werden soll.<\/li>\n<li class=\"aufz-hlung\"><b>strExpression<\/b>: Optionale Zeichenkette, die einen auswertbaren Ausdruck enth&auml;lt. Liefert dieser Ausdruck den Wert <b>False<\/b>, ist die Validierung fehlgeschlagen.<\/li>\n<\/ul>\n<p>F&uuml;r den mit dem Parameter <b>eType <\/b>&uuml;bergebenen Validierungstyp stehen diese Werte parat:<\/p>\n<ul>\n<li class=\"aufz-hlung\"><b>eIsNumeric<\/b>: Pr&uuml;ft, ob der neue Wert ein numerischer Wert ist.<\/li>\n<li class=\"aufz-hlung\"><b>eIsNull<\/b>: Pr&uuml;ft, ob der neue Wert Null ist.<\/li>\n<li class=\"aufz-hlung\"><b>eIsDate<\/b>: Pr&uuml;ft, ob der neue Wert ein g&uuml;ltiges Datum enth&auml;lt.<\/li>\n<li class=\"aufz-hlung\"><b>eIsNullstring<\/b>: Pr&uuml;ft, ob der neue Wert eine leere Zeichenkette ist.<\/li>\n<li class=\"aufz-hlung\"><b>eIsTrue<\/b>: Pr&uuml;ft, ob der neue Wert wahr ist.<\/li>\n<li class=\"aufz-hlung\"><b>eIsFalse<\/b>: Pr&uuml;ft, ob der neue Wert falsch ist.<\/li>\n<li class=\"aufz-hlung\"><b>eExpression<\/b>: Legt fest, dass der im Parameter strExpression angegebene Ausdruck das Ergebnis der Validierung liefert.<\/li>\n<\/ul>\n<p><!--30percent--><\/p>\n<p>Nehmen wir an, das Feld <b>PLZ <\/b>darf nur numerische Wert enthalten.<\/p>\n<p>Dann brauchen Sie die folgende Anweisung in der Ereignisprozedur <b>Form_Load<\/b>, um eine entsprechende Validierung hinzuzuf&uuml;gen:<\/p>\n<pre>objValidation.AddControlValidation Me!PLZ,\r\neIsNumeric, &quot;Ung&uuml;ltige PLZ&quot;, &quot;Bitte geben\r\nSie eine aus vier oder f&uuml;nf Ziffern\r\nbestehende PLZ ein.&quot;<\/pre>\n<p>&Ouml;ffnen Sie das Formular in der Entwurfsansicht und probieren Sie es aus: Geben Sie beispielsweise einige Buchstaben oder eine Postleitzahl in der Form <b>D-47137 <\/b>in das Feld <b>PLZ <\/b>ein. Bild 6 zeigt, wie das Ergebnis ausfallen wird.<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2009_04\/ValidierenMitKlasse-web-images\/pic006_opt.jpeg\" alt=\"pic006.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 6: Eine erste Beispielvalidierung &#8211; erstellt mit nur einer Codezeile!<\/span><\/b><\/p>\n<p>Klicken Sie auf <b>OK<\/b>, verbleibt die Einf&uuml;gemarke im soeben bearbeiteten Feld und wird sich nicht in ein anderes Feld bewegen lassen, bis der Benutzer einen g&uuml;ltigen Wert eingegeben oder die &auml;nderung mit der <b>Escape<\/b>-Taste r&uuml;ckg&auml;ngig gemacht hat. Letzteres ist wichtig f&uuml;r das Handling: Die Validierung auf Steuerelementbasis (erstellt mit <b>AddControlValidation<\/b>) arbeitet nur mit gebundenen Feldern und auch nur dann, wenn der Benutzer das jeweilige Feld seit dem &Ouml;ffnen des Datensatzes ge&auml;ndert hat. In allen anderen F&auml;llen bleibt die Validierung aus.<\/p>\n<p><b>Validierung auf Formularebene<\/b><\/p>\n<p>Bevor wir uns den &uuml;brigen Varianten zuwenden, schauen wir uns die Validierung auf Formularebene an &#8211; und zwar am gleichen Beispiel, damit Sie die Unterschiede erkennen k&ouml;nnen. Wir verwenden also nun die folgende Anweisung, um die gew&uuml;nschte Validierung zu implementieren:<\/p>\n<pre>objValidation.AddFormValidation Me!PLZ,\r\neIsNumeric, &quot;Ung&uuml;ltige PLZ&quot;, &quot;Bitte geben Sie eine aus vier oder f&uuml;nf Ziffern bestehende PLZ ein.&quot;<\/pre>\n<p>Vorab der Hinweis f&uuml;r schreibfaule Programmierer: Wenn Sie ein Steuerelement auf Steuerelement- und auf Formularebene validieren m&ouml;chten, brauchen Sie einfach nur eine der beiden Methoden <b>AddControlValidation <\/b>oder <b>AddFormValidation <\/b>auszuformulieren, diese zu kopieren und den Methodennamen auszutauschen.<\/p>\n<p>Wie wirkt diese Validierung nun Es gilt das Gleiche wie bei der Validierung auf Feldebene: Ohne eine &auml;nderung der Daten tut sich gar nichts. Hier braucht der Benutzer jedoch nur irgendeinen Feldinhalt zu &auml;ndern, damit sich die Validierung vor dem Speichern des Datensatzes einschaltet.<\/p>\n<p>Wer beide Validierungen definiert hat und nun das Verhalten der Variante auf Formularebene testen m&ouml;chte, wird feststellen, dass dies nicht funktioniert: Die &auml;nderung der PLZ, die wir auf Formularebene validieren lassen m&ouml;chten, kann gar nicht erfolgen, weil die Validierung auf Feldebene vorher zuschl&auml;gt und Werte wie <b>D-47137 <\/b>erfolgreich unterbindet. Also kommentieren wir die <b>AddControlValidation<\/b>-Zeile einfach aus und testen dann erneut die Validierung auf Formularebene.<\/p>\n<p><b>Validierung und Arten der Datenspeicherung<\/b><\/p>\n<p>An dieser Stelle ist ein kleiner Exkurs n&ouml;tig. Dieser f&uuml;hrt uns zu einer etwas merkw&uuml;rdigen Verhaltensweise von Access-Formularen. Es gibt verschiedene Arten, um das Speichern eines ge&auml;nderten Datensatzes zu forcieren:<\/p>\n<ul>\n<li class=\"aufz-hlung\">Schlie&szlig;en des Formulars durch einen Mausklick auf die <b>Schlie&szlig;en<\/b>-Schaltfl&auml;che oben rechts im Formular oder Ausw&auml;hlen des Eintrags <b>Schlie&szlig;en <\/b>des Fenstermen&uuml;s (siehe Bild 7).<\/li>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2009_04\/ValidierenMitKlasse-web-images\/pic007_opt.jpeg\" alt=\"pic007.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 7: Das Schlie&szlig;en des Formulars f&uuml;hrt zum Speichern des Datensatzes.<\/span><\/b><\/p>\n<li class=\"aufz-hlung\">Ausl&ouml;sen des Schlie&szlig;en-Vorgangs durch eine VBA-Anweisung wie <b>DoCmd.Close acForm, &lt;Formularname&gt;<\/b>.<\/li>\n<li class=\"aufz-hlung\">Schlie&szlig;en von Access.<\/li>\n<li class=\"aufz-hlung\">Durch einen Datensatzwechsel &#8211; entweder durch Ansteuern eines neuen Datensatzes &uuml;ber die Navigationsschaltfl&auml;chen oder durch das Springen vom letzten Steuerelement des aktuellen Datensatzes zum n&auml;chsten Datensatz per Tab- oder Eingabetaste &#8211; dies geht auch andersherum (vorausgesetzt, Sie haben die Eigenschaft <b>Zyklus <\/b>des Formulars auf <b>Alle Datens&auml;tze <\/b>eingestellt).<\/li>\n<\/ul>\n<p>Bis auf die letzte Variante haben alle einen entscheidenden Nachteil: Sie l&ouml;sen das Ereignis <b>Form_Close <\/b>aus, was sich nicht r&uuml;ckg&auml;ngig machen l&auml;sst. In unserer (Validierungs-)Praxis bedeutet dies, dass zwar eine Validierung erfolgt &#8211; immerhin wird das <b>BeforeUpdate<\/b>-Ereignis des Formulars vor dem Schlie&szlig;en des Formulars auf jeden Fall noch ausgel&ouml;st -, aber der Benutzer kann nicht in der gew&uuml;nschten Art darauf reagieren. Stattdessen wird er mit der Meldung aus Bild 8 konfrontiert, die ihn darauf hinweist, dass der Datensatz nicht gespeichert werden kann &#8211; und das wei&szlig; er ja zu diesem Zeitpunkt schon. Erst nach dem Unterbrechen des Schlie&szlig;en-Vorgangs kann der Benutzer sich wieder dem ung&uuml;ltigen Feldinhalt zuwenden.<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2009_04\/ValidierenMitKlasse-web-images\/pic008_opt.jpeg\" alt=\"pic008.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 8: Access schlie&szlig;t kein Formular, dessen Daten nicht den Vorgaben entsprechen.<\/span><\/b><\/p>\n<p>Eine sinnvolle M&ouml;glichkeit ist, die Schlie&szlig;en-Schaltfl&auml;che und das Formularmen&uuml; auszublenden, indem Sie die Eigenschaften <b>Mit Systemmen&uuml;feld <\/b>und <b>Schlie&szlig;en-Schaltfl&auml;che <\/b>auf den Wert <b>Nein <\/b>einstellen und stattdessen eine eigene <b>Schlie&szlig;en<\/b>-Schaltfl&auml;che, beispielsweise mit der Beschriftung <b>OK<\/b>, im Formular unterbringen. Dummerweise m&uuml;ssen Sie aber auch hier einen Befehl wie <b>DoCmd.Close acForm, &lt;Formularname&gt; <\/b>absetzen, um das Formular zu schlie&szlig;en &#8211; aber gl&uuml;cklicherweise k&ouml;nnen Sie hier selbst steuern, wann dies geschehen soll. Und damit kommen wir zum dritten Element der Klasse <b>clsValidation<\/b>: der Eigenschaft <b>Validated<\/b>. Diese bauen Sie wie folgt in die Ereignisprozedur ein, die durch einen Mausklick auf Ihre <b>OK<\/b>-Schaltfl&auml;che ausgel&ouml;st wird:<\/p>\n<pre>Private Sub cmdOK_Click()\r\n    If objValidation.Validated = True Then\r\n        DoCmd.Close acForm, Me.Name\r\n    End If\r\n    End Sub<\/pre>\n<p><b>Validated <\/b>liefert den Wert <b>True <\/b>zur&uuml;ck, wenn die Validierung ohne Beanstandungen durchlief, sonst den Wert <b>False<\/b>. Falls die Validierung Ungereimtheiten findet, schl&auml;gt sie beim ersten Fund mit einer entsprechenden Meldung Alarm, bricht die Validierung ab und liefert den Wert <b>False <\/b>zur&uuml;ck, auf dass die <b>cmdOK_Click<\/b>-Methode sich das Schlie&szlig;en des Formulars verkneifen m&ouml;ge.<\/p>\n<p><b>Weitere Validierungsm&ouml;glichkeiten<\/b><\/p>\n<p>Nachdem Sie wissen, wo Sie Validierungen unterbringen k&ouml;nnen, schauen wir uns weitere Optionen an. Beginnen wir mit einem Spezialfall: Das Feld <b>Nachname <\/b>der Tabelle <b>tblPersonal <\/b>soll f&uuml;r die Eigenschaft <b>Eingabe erforderlich <\/b>den Wert <b>Ja <\/b>und f&uuml;r <b>Leere Zeichenkette <\/b>den Wert <b>Nein <\/b>erhalten (siehe Bild 9).<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2009_04\/ValidierenMitKlasse-web-images\/pic009_opt.jpeg\" alt=\"pic009.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 10: Eine durch eine Restriktion im Tabellenentwurf von Access hervorgerufene Validierungsmeldung<\/span><\/b><\/p>\n<p>Das bedeutet per Definitionem, dass Access meckern soll, wenn der Benutzer einen Datensatz in dieser Tabelle anlegt und das Feld <b>Nachname <\/b>nicht ausf&uuml;llt. Schauen wir also, was geschieht: Wir legen einen neuen Datensatz an, w&auml;hlen aus dem Kombinationsfeld <b>Anrede<\/b> einen Wert aus, um den Datensatz als bearbeitet zu kennzeichnen, und wechseln dann zu einem anderen Datensatz. Als Erstes erscheint &#8211; &Uuml;berraschung! &#8211; die benutzerdefinierte Validierungsmeldung f&uuml;r die Postleitzahl.<\/p>\n<p>Erst im Anschluss folgt die accesseigene Meldung aus Bild 10 (die &uuml;brigens auch nach dem F&uuml;llen, Leeren und Verlassen des Textfelds erscheint, sich also auch auf das Steuerelement bezieht).<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2009_04\/ValidierenMitKlasse-web-images\/pic010_opt.jpeg\" alt=\"pic010.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 9: Tabellenfeld mit Restriktionen im Tabellenentwurf<\/span><\/b><\/p>\n<p>Diese ist allerdings unsch&ouml;n: Der Meldung enth&auml;lt keinen aussagekr&auml;ftigen Titel und auch den Text m&ouml;chten Sie vielleicht anders gestalten. Normalerweise m&uuml;ssten Sie nun eine Ereignisprozedur implementieren, die durch das Ereignis <b>Bei Fehler <\/b>des Formulars ausgel&ouml;st wird, dort pr&uuml;fen, welche Fehlernummer mit dieser Meldung einhergeht und entsprechend darauf reagieren.<\/p>\n<p>Dazu geh&ouml;rt eine eingehende Pr&uuml;fung des Steuerelements, das die Meldung hervorgerufen hat, und der Fehlernummer selbst.<\/p>\n<p>Die gute Nachricht ist, dass Sie sich das alles sparen k&ouml;nnen: Sie brauchen nur eine oder mehrere Validierungen anzulegen, welche die fehlenden oder fehlerhaften Werte mit einer benutzerdefinierten Meldung bem&auml;ngeln.<\/p>\n<p>Diese Meldungen tauchen so lange auf, bis der Benutzer den gew&uuml;nschten Wert eingetragen oder die &auml;nderungen am gesamten Datensatz beispielsweise per <b>Escape<\/b>-Schaltfl&auml;che verworfen hat.<\/p>\n<p>Die Codezeile f&uuml;r diesen Fall sieht so aus:<\/p>\n<pre>objValidation.AddControlValidation Me.Nachname, eIsNullstring, &quot;Fehlende Eingabe&quot;, &quot;Bitte geben Sie einen Nachnamen ein.&quot;<\/pre>\n<p>Bei dieser Gelegenheit sei erw&auml;hnt, dass Sie das Formular nach jeder &auml;nderung des Codes &#8211; und insbesondere an dem Code, der die Validierung definiert &#8211; schlie&szlig;en und erneut &ouml;ffnen m&uuml;ssen.<\/p>\n<p>Wechseln Sie nun zu einem neuen, leeren Datensatz, tragen einen Nachnamen ein und leeren das Feld wieder, meldet sich die benutzerdefinierte Validierung beim Verlassen des Feldes. In diesem Fall haben wir den Parameter <b>eIsNullstring <\/b>verwendet, was deshalb notwendig ist, weil ein Textfeld nach dem erstmaligen Eingeben und anschlie&szlig;enden L&ouml;schen nicht mehr den Wert <b>Null <\/b>enth&auml;lt, sondern eine leere Zeichenkette. Anders sieht es beim Speichern des Datensatzes aus, wenn Sie noch keinen Wert f&uuml;r das Feld <b>Nachname <\/b>eingegeben haben: Hier erscheint immer noch die h&auml;ssliche Access-Meldung. F&uuml;gen wir also eine Validierung hinzu, die formularbasiert ist und somit beim Speichern des Datensatzes wirkt &#8211; und au&szlig;erdem auf den Wert <b>Null <\/b>statt auf eine leere Zeichenkette pr&uuml;ft:<\/p>\n<pre>objValidation.AddFormValidation Me.Nachname,\r\neIsNull, &quot;Fehlende Eingabe&quot;, &quot;Bitte geben Sie einen Nachnamen ein.&quot;<\/pre>\n<p><b>Reihenfolge und Vereinfachungen<\/b><\/p>\n<p>Wenn Sie die Beispiele flei&szlig;ig nachvollzogen haben, stehen jetzt mindestens zwei Validierungen zu Buche, die beim Speichern des Datensatzes ausgel&ouml;st werden. F&uuml;r die ersten paar Anweisungen und f&uuml;r alle folgenden erhalten Sie nun zwei Hinweise, von denen einer Ihnen einfach nur Tipparbeit abnimmt und der andere wichtig f&uuml;r die Ergonomie Ihrer Anwendung ist:<\/p>\n<ul>\n<li class=\"aufz-hlung\">Vereinfachung: Verwenden Sie die <b>With &#8230;<\/b>-Anweisung, um sich das Voranstellen des Objekts <b>objValidation <\/b>vor jedem Aufruf zu ersparen (siehe Bild 11).<\/li>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2009_04\/ValidierenMitKlasse-web-images\/pic011_opt.jpeg\" alt=\"pic011.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 11: Einige Anweisungen zum Erstellen von Validierungen<\/span><\/b><\/p>\n<li class=\"aufz-hlung\">Ergonomisches Muss: Die Validierungsklassen arbeiten die Validierungen genau in der Reihenfolge ab, in der diese im Code erstellt wurden. Wenn Sie den Benutzer beim Auftreten mehrerer Validierungsmeldungen nicht quer &uuml;ber das Formular jagen m&ouml;chten, sollten Sie die Reihenfolge etwa entsprechend der Tabulator-Reihenfolge der Steuerelemente im Formular einstellen.<\/li>\n<\/ul>\n<p><b>Mit Ausdruck<\/b><\/p>\n<p>Die &uuml;brigen Werte f&uuml;r den Parameter <b>eType <\/b>der Validierung sollten ohne weitere Erl&auml;uterungen eingesetzt werden k&ouml;nnen. Wir gehen lediglich noch auf die letzte Variante ein, die das Validieren komplexer Ausdr&uuml;cke erm&ouml;glicht. Das Besondere hierbei ist, dass Sie damit solche Validierungen abdecken k&ouml;nnen, an denen mehrere Felder beteiligt sind &#8211; also beispielsweise, um zu pr&uuml;fen, ob der Wert eines Datumsfelds kleiner als der eines anderen ist.<\/p>\n<p>F&uuml;r das folgende Beispiel ziehen wir die beiden Felder <b>Geburtsdatum <\/b>und <b>Einstellung <\/b>der Tabelle <b>tblPersonal <\/b>der Beispieldatenbank heran. Die wenig sinnvolle, aber f&uuml;r Beispielzwecke ausreichende Anforderung soll zun&auml;chst sicherstellen, dass niemand in der Firma arbeitet, der erst nach seiner Einstellung geboren wurde (lachen Sie nicht: die T&ouml;chter des Autors waren schon Mitglied im Sportverein, bevor sie das Licht der Welt erblickten &#8230; &#8211; eine ordentliche Validierung h&auml;tte dies verhindert!)<\/p>\n<p>Wie auch immer &#8211; der Ausdruck f&uuml;r den Vergleich der beiden Datumsangaben und das Anlegen der Validierung sieht wie folgt aus:<\/p>\n<pre>objValidation.AddFormValidation _\r\nMe.Einstellung, _\r\neExpression, _\r\n&quot;Ung&uuml;ltiges Einstellungsdatum&quot;, _\r\n&quot;Das Einstellungsdatum muss hinter dem\r\nGeburtsdatum liegen1.&quot;, _\r\n&quot;Forms!frmBeispielValidierung!Einstellung\r\n&lt; Forms!frmBeispielValidierung!Geburtsdatum&quot;<\/pre>\n<p>Sie erkennen hier, dass der Ausdruck nicht einfach nur die Namen der zu vergleichenden Steuerelemente, sondern gleich die komplette Referenz mit <b>Forms!frmBeispielValidierung <\/b>verwendet &#8211; dies ist unbedingt n&ouml;tig. Au&szlig;erdem muss dieser Ausdruck um jeden Preis als String, also in Anf&uuml;hrungszeichen eingefasst, &uuml;bergeben werden. Wer keine Lust hat, so viel zu tippen, kann eine kleine Hilfsfunktion verwenden, die als Parameter einen Verweis auf das aktuelle Formular und den Namen des Steuerelements erwartet. Der Aufruf zum Anlegen der Validierung sieht dann so aus:<\/p>\n<pre>objValidation.AddFormValidation _\r\nMe.Einstellung, _\r\neExpression, _\r\n&quot;Ung&uuml;ltiges Einstellungsdatum&quot;, _\r\n&quot;Das Einstellungsdatum muss hinter\r\ndem Geburtsdatum liegen.&quot;, _\r\nReplaceMe(Me, &quot;Me!Einstellung&quot;) _\r\n&amp; &quot;&lt;&quot; &amp; ReplaceMe(Me, &quot;Me!Geburtsdatum&quot;)<\/pre>\n<p>Sie k&ouml;nnen f&uuml;r den Parameter <b>strExpression <\/b>beliebige Ausdr&uuml;cke &uuml;bergeben. Wenn Sie beispielsweise nicht die <b>IsNumeric<\/b>-Variante der Validierung verwenden m&ouml;chten, k&ouml;nnen Sie auch eine eigene Validierung des Typs <b>eExpression <\/b>erstellen. Diese k&ouml;nnte beispielsweise so aussehen:<\/p>\n<pre>objValidation.AddFormValidation _\r\nMe.PLZ, _\r\neExpression, _\r\n&quot;Ung&uuml;ltige PLZ&quot;, _\r\n&quot;Bitte geben Sie eine aus vier oder\r\nf&uuml;nf Ziffern bestehende PLZ ein.&quot;, _\r\n&quot;Not IsNumeric(Forms!&quot; &amp; Me.Name &amp; &quot;!PLZ)&quot;<\/pre>\n<p>Der Formularname als Teil des absoluten Steuerelementbezugs wird hier auf alternative Art zusammengesetzt und die auch im Hintergrund der Validierungsfunktion verwendete <b>IsNumeric<\/b>-Funktion kommt hier gleich im auszuwertenden Ausdruck zum Einsatz.<\/p>\n<p>Beachten Sie an dieser Stelle, dass die Validierungsmeldung genau dann erscheint, wenn der Ausdruck den Wert <b>True <\/b>annimmt.<\/p>\n<p><b>Hinter den Kulissen<\/b><\/p>\n<p>Die Vereinfachung beim Erstellen einer Validierung f&uuml;r Formulare hat ihren Preis &#8211; der in den notwendigen Klassen befindliche Code ist nicht unbedingt f&uuml;r Einsteiger geeignet. Wer sich selbst auf den Weg machen m&ouml;chte, um die Validierungsfunktion unter der Haube anzupassen, sollte zumindest solide VBA-Grundkenntnisse besitzen und die eine oder andere Klasse programmiert haben. F&uuml;r Interessierte hier in wenigen Abschnitten ein &Uuml;berblick &uuml;ber die n&ouml;tigen Aktionen. Im Prinzip l&auml;uft die Validierung in zwei Schritten ab:<\/p>\n<ul>\n<li class=\"aufz-hlung\">Anlegen der Definition einer Validierung, also der Vorschrift, die sp&auml;ter beim eigentlichen Validieren ausgef&uuml;hrt werden soll<\/li>\n<li class=\"aufz-hlung\">Durchf&uuml;hren der Validierung vor dem Aktualisieren eines Steuerelements beziehungsweise des kompletten Datensatzes<\/li>\n<\/ul>\n<p>Vor dem Anlegen der Validierung muss notwendigerweise eine Instanz der Klasse <b>clsValidation <\/b>erzeugt werden, die alles Weitere steuert.<\/p>\n<p>Wenn mit der Methode <b>AddControlValidation <\/b>eine neue Validierung auf Steuerelementebene angelegt wird, geschieht Folgendes:<\/p>\n<ul>\n<li class=\"aufz-hlung\">Es wird ein Objekt namens <b>objControlValidation <\/b>auf Basis der Klasse <b>clsControlValidation <\/b>erstellt.<\/li>\n<li class=\"aufz-hlung\">Dieses Objekt stellt einige Eigenschaften bereit, welche die bei der Erstellung der Validierung mit <b>AddControlValidation <\/b>&uuml;bergebenen Parameter speichert.<\/li>\n<li class=\"aufz-hlung\">Au&szlig;erdem f&uuml;hrt das Objekt <b>objControlValidation <\/b>beim Zuweisen einige wichtige Aktionen aus: Es tr&auml;gt f&uuml;r die <b>BeforeUpdate<\/b>-Ereigniseigenschaft des Steuerelements, f&uuml;r das die Validierung erstellt werden soll, den Wert <b>[Event Procedure] <\/b>ein. Da die Klasse <b>clsControlValidation<\/b>, auf der <b>objControlValidation <\/b>basiert, selbst einen mit dem Schl&uuml;sselwort <b>WithEvents <\/b>deklarierten Objektverweis auf das Steuerelement h&auml;lt, kann sie selbst Implementierungen von Ereignisprozeduren des Steuerelements enthalten und so darauf reagieren, wenn das Ereignis <b>Vor Aktualisierung <\/b>des Steuerelements ausgel&ouml;st wird.<\/li>\n<li class=\"aufz-hlung\">Dies ist der eigentliche Schl&uuml;ssel dazu, dass der Programmierer nicht selbst die <b>Vor Aktualisierung<\/b>-Ereignisprozedur jedes mit einer Validierung zu versehenden Steuerelements mit Code f&uuml;llen muss &#8211; all dies wird durch den Aufruf der Methode <b>AddControlValidation <\/b>erledigt.<\/li>\n<li class=\"aufz-hlung\">Das <b>objControlValidation<\/b>-Objekt wird schlie&szlig;lich zu einer Collection hinzugef&uuml;gt und dort aufbewahrt &#8211; irgendwo m&uuml;ssen die Objekte, welche die Logik f&uuml;r die Durchf&uuml;hrung der Validierung enthalten und die mit den speziellen Parametern f&uuml;r die einzelnen Steuerelemente ausgestattet sind, schlie&szlig;lich untergebracht werden, damit sie nicht im Daten-Nirvana verschwinden.<\/li>\n<\/ul>\n<p>Ganz &auml;hnlich sieht es bei der Methode <b>AddFormValidation <\/b>aus &#8211; nur etwas einfacher. Schlie&szlig;lich muss nicht jedes Steuerelement, das mit einem entsprechenden Verweis in der Liste der bei einer Validierung zu ber&uuml;cksichtigenden Steuerelemente gelandet ist, mit Ereignisprozeduren ausgestattet werden.<\/p>\n<p>Bei der Formularvalidierung geht es ja ausschlie&szlig;lich darum, auf das <b>Vor Aktualisierung<\/b>-Ereignis des Formulars zu reagieren. Wozu dann &uuml;berhaupt die Informationen zu allen betroffenen Steuerelementen speichern Nun: Immerhin sollen ja Steuerelemente validiert werden und nicht das Formular und dies erfordert eine Referenz auf die entsprechenden Steuerelemente.<\/p>\n<p>Richtig kompliziert wird es an der Stelle, an der die von Access selbst ausgel&ouml;sten Validierungen auf den Plan treten: Die wollen wir ja, wie weiter oben beschrieben, m&ouml;glichst mit eigenen Validierungen aushebeln. Das ist aber nicht so einfach: Man kann sich &uuml;berhaupt nur in den Ablauf einer solchen Validierung einklinken, wenn man das <b>Bei Fehler<\/b>-Ereignis des Formulars anzapft und dort auf entsprechende Fehlernummern lauert.<\/p>\n<p>Dummerweise feuert das <b>Bei Fehler<\/b>-Ereignis vor dem <b>Vor Aktualisierung<\/b>-Ereignis, was bedeutet, dass wir &uuml;berhaupt keine M&ouml;glichkeit haben, die m&uuml;hsam vorbereiteten Validierungsfunktionen &uuml;ber das <b>Vor Aktualisierungs<\/b>-Ereignis zu starten.<\/p>\n<p>Also greifen wir das Steuerelement auf, das zum Ausl&ouml;sen von <b>Form_Error <\/b>f&uuml;hrte, und schauen in der Sammlung der durch unsere Funktionen zu validierenden Steuerelemente nach, ob es dazu schon Validierungen gibt. Falls ja, werden diese durchgef&uuml;hrt und, falls eine Validierung anschl&auml;gt und den Benutzer auf fehlerhafte oder fehlende Eingaben hinweist, die Access-interne Validierungsmeldung unterbunden.<\/p>\n<p>Das ist ohne Kopfschmerzen m&ouml;glich, denn in diesem Fall verhindert ja die benutzerdefinierte Validierung, dass der Fokus das betroffene Feld verl&auml;sst. Bestenfalls decken die benutzerdefinierten Validierungen alle Fehler ab, die durch das eingebaute Pendant gefunden werden k&ouml;nnen.<\/p>\n<p>Wer mehr wissen m&ouml;chte, sollte sich einfach einmal die Klassen ansehen und den enthaltenen Code w&auml;hrend der Validierung debuggen. Viel Spa&szlig;!<\/p>\n<p><b>Zusammenfassung und Ausblick<\/b><\/p>\n<p>Wer viele Steuerelemente validieren muss, findet in dieser L&ouml;sung sicher eine gro&szlig;e Hilfe. Wenn Sie m&ouml;chten, k&ouml;nnen Sie uns gern Ihre Erfahrungen mit der L&ouml;sung dieses Beitrags mitteilen &#8211; wir werden diese dann pr&uuml;fen und gegebenenfalls in einem zuk&uuml;nftigen Beitrag ber&uuml;cksichtigen. Schreiben Sie uns einfach eine E-Mail an <b>info@access-im-unternehmen.de<\/b>!<\/p>\n<h3>Downloads zu diesem Beitrag<\/h3>\n<p>Enthaltene Beispieldateien:<\/p>\n<p>ValidierenMitKlasse.mdb<\/p>\n<p><a href=\"..\/fileadmin\/beispiele\/{B74217B0-B6E2-4B78-95F1-B9589C6C8E08}\/aiu_678.zip\">Download<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Das Validieren von Daten in Formularen ist normalerweise eine langweilige Arbeit, die man meist an das Ende der Formularentwicklung packt. Die Anzahl der m&ouml;glichen F&auml;lle, die durch eine Validierung abgefangen werden sollen, ist &uuml;berschaubar, und die n&ouml;tigen Codezeilen sehen sich meist sehr &auml;hnlich: Pr&uuml;fen, Fokus auf das Feld setzen, Aktualisierung abbrechen, Meldung ausgeben. Mit ein paar einfachen Klassen l&auml;sst sich diese Arbeit ein wenig spannender gestalten, und am Ende sparen Sie sogar noch Code und somit Zeit.<\/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":[662009,66042009,44000021,44000025],"tags":[],"class_list":["post-55000678","post","type-post","status-publish","format-standard","hentry","category-662009","category-66042009","category-Tabellen_und_Datenmodellierung","category-VBA_und_Programmiertechniken"],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v20.9 (Yoast SEO v27.3) - https:\/\/yoast.com\/product\/yoast-seo-premium-wordpress\/ -->\n<title>Validieren mit Klasse - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Validieren mit Klasse\" \/>\n<meta property=\"og:description\" content=\"Das Validieren von Daten in Formularen ist normalerweise eine langweilige Arbeit, die man meist an das Ende der Formularentwicklung packt. Die Anzahl der m&ouml;glichen F&auml;lle, die durch eine Validierung abgefangen werden sollen, ist &uuml;berschaubar, und die n&ouml;tigen Codezeilen sehen sich meist sehr &auml;hnlich: Pr&uuml;fen, Fokus auf das Feld setzen, Aktualisierung abbrechen, Meldung ausgeben. Mit ein paar einfachen Klassen l&auml;sst sich diese Arbeit ein wenig spannender gestalten, und am Ende sparen Sie sogar noch Code und somit Zeit.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2020-05-22T22:16:59+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg02.met.vgwort.de\/na\/e4a82811fa48419d886ca0b06b6746b8\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"22\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"Validieren mit Klasse\",\"datePublished\":\"2020-05-22T22:16:59+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/\"},\"wordCount\":4061,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg02.met.vgwort.de\\\/na\\\/e4a82811fa48419d886ca0b06b6746b8\",\"articleSection\":[\"2009\",\"4\\\/2009\",\"Tabellen und Datenmodellierung\",\"VBA und Programmiertechniken\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/\",\"name\":\"Validieren mit Klasse - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg02.met.vgwort.de\\\/na\\\/e4a82811fa48419d886ca0b06b6746b8\",\"datePublished\":\"2020-05-22T22:16:59+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg02.met.vgwort.de\\\/na\\\/e4a82811fa48419d886ca0b06b6746b8\",\"contentUrl\":\"http:\\\/\\\/vg02.met.vgwort.de\\\/na\\\/e4a82811fa48419d886ca0b06b6746b8\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Validieren_mit_Klasse\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Validieren mit Klasse\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Validieren mit Klasse - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/","og_locale":"de_DE","og_type":"article","og_title":"Validieren mit Klasse","og_description":"Das Validieren von Daten in Formularen ist normalerweise eine langweilige Arbeit, die man meist an das Ende der Formularentwicklung packt. Die Anzahl der m&ouml;glichen F&auml;lle, die durch eine Validierung abgefangen werden sollen, ist &uuml;berschaubar, und die n&ouml;tigen Codezeilen sehen sich meist sehr &auml;hnlich: Pr&uuml;fen, Fokus auf das Feld setzen, Aktualisierung abbrechen, Meldung ausgeben. Mit ein paar einfachen Klassen l&auml;sst sich diese Arbeit ein wenig spannender gestalten, und am Ende sparen Sie sogar noch Code und somit Zeit.","og_url":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/","og_site_name":"Access im Unternehmen","article_published_time":"2020-05-22T22:16:59+00:00","og_image":[{"url":"http:\/\/vg02.met.vgwort.de\/na\/e4a82811fa48419d886ca0b06b6746b8","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"22\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"Validieren mit Klasse","datePublished":"2020-05-22T22:16:59+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/"},"wordCount":4061,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/#primaryimage"},"thumbnailUrl":"http:\/\/vg02.met.vgwort.de\/na\/e4a82811fa48419d886ca0b06b6746b8","articleSection":["2009","4\/2009","Tabellen und Datenmodellierung","VBA und Programmiertechniken"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/","url":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/","name":"Validieren mit Klasse - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/#primaryimage"},"thumbnailUrl":"http:\/\/vg02.met.vgwort.de\/na\/e4a82811fa48419d886ca0b06b6746b8","datePublished":"2020-05-22T22:16:59+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/#primaryimage","url":"http:\/\/vg02.met.vgwort.de\/na\/e4a82811fa48419d886ca0b06b6746b8","contentUrl":"http:\/\/vg02.met.vgwort.de\/na\/e4a82811fa48419d886ca0b06b6746b8"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/Validieren_mit_Klasse\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"Validieren mit Klasse"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000678","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55000678"}],"version-history":[{"count":0,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000678\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55000678"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55000678"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55000678"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}