Gültigkeitsprüfung der Benutzereingabe in ASP+

Veröffentlicht: 07. Sep 2000 | Aktualisiert: 17. Jun 2004

Von Anthony Moore

Dieser Artikel gibt einen kurzen Überblick über das ASP+-Framework zur Gültigkeitsprüfung. Anhand eines Beispiels wird erläutert, wie einer Seite eine Gültigkeitsprüfung hinzugefügt wird.

Auf dieser Seite

 Einführung
 Das Problem
 Die Ziele
 Die Lösung - Überblick
 Clientfeatures
 Was ist ein Validator?
 Verwendung von Validatoren
 Erforderliche Eingabe
 Reguläre Ausdrücke
 Sicherstellen von übereinstimmenden Eingaben
 Benutzerdefinierte Überprüfung
 Das Finale

Einführung

In Webanwendungen gehört das Prüfen der Benutzereingabe auf Gültigkeit zu den allgemeinen Szenarios. Beim Erstellen von Anwendungen wenden die Entwickler für diesen Task mehr Zeit und Programmierarbeit auf, als uns lieb ist. Daher war es bei der Entwicklung des ASP+-Seitenframeworks wichtig zu versuchen, die Benutzereingabeprüfung erheblich einfacher zu gestalten.

Das Problem

In HTML 3.2 ist das Überprüfen von Daten ein schwieriger Prozess. Für jede erhaltene Anforderung müssen Codeanweisungen geschrieben werden, um die Eingabe zu überprüfen und um mögliche Fehler, die bei der Benutzereingabe auftreten, zurück an die Seite zu übertragen. Dies soll dem Benutzer dabei helfen, das Formular zur Gültigkeitsprüfung korrekt auszufüllen. Dieser Prozess ist sowohl für die Endbenutzer als auch die Entwickler und Server gleichermaßen aufwendig.

DTHML und die Skriptsprachen haben dazu beigetragen, diesen Prozess etwas zu vereinfachen. Es ist möglich, den Benutzern bei einer falschen Eingabe sofort ein Feedback zu geben und zu vermeiden, dass sie die Seite übertragen, bevor der Fehler behoben wurde. Es kann jedoch nicht hundertprozentig garantiert werden, dass jeder Benutzer, der auf Ihre Site zugreift, über die erforderliche Skriptumgebung verfügt. Wenn Sie die Benutzeroberfläche der Seiten durch Verwenden von Skript verbessern möchten, müssen Sie normalerweise dieselbe Überprüfungslogik sowohl für den Client als auch den Server schreiben, falls der Clientcode nicht ausgeführt werden kann.

Die Ziele

Unsere Ziele im Hinblick auf die Gültigkeitprüfung lauten wie folgt:

• Bereitstellen von Komponenten, die mindestens 90 % der normalen Eingabeüberprüfungstasks für Dateneingabeseiten durchführen

• Entwickeln von Komponenten, die eine komplexe skriptbasierte Gültigkeitsprüfung auf modernen Browsern durchführen, die bei Bedarf auch auf die reine serverbasierte HTML 3.2-Überprüfung zurückgreifen können

• Bereitstellen einer flexiblen API, damit die Überprüfungstasks, die nicht von den Komponenten übernommen werden, einfach durchgeführt werden können

Wir haben eine große Anzahl von realen Seiten besucht, um die Art von Szenarios zu bestimmen, die diese Komponenten behandeln müssen. Unser Ziel war es, den Umfang der Codeanweisungen für die Gültigkeitsprüfung in zukünftigen Anwendungen zu reduzieren.

Die Lösung - Überblick

Die Validatorsteuerelemente sind die wichtigsten Bestandteile der Lösung. Ein Validator ist ein visuelles ASP+-Steuerelement, das eine bestimmte Gültigkeitsbedingung eines anderen Steuerelements überprüft. Für den Benutzer ist dieser Validator normalerweise als Text sichtbar, der je nachdem, ob das überprüfte Steuerelement eine Fehlerbedingung aufweist, angezeigt oder ausgeblendet wird. Der Validator kann aber auch als Bild angezeigt werden oder sogar unsichtbar sein und dennoch seine Funktion wahrnehmen. Es gibt fünf Arten von Validatorsteuerelementen, die jeweils unterschiedliche Überprüfungen durchführen.

Ein weiterer Bestandteil unserer Lösung ist das ValidationSummary-Steuerelement. Auf großen Dateneingabeseiten werden die Fehler normalerweise in einem separaten Bereich angezeigt. Das ValidationSummary erzeugt diesen Inhalt automatisch, indem der Inhalt von den Validatorsteuerelementen auf der Seite abgerufen wird.

Der letzte Bestandteil der Lösung ist das Page-Objekt selbst. Es legt die wichtige IsValid-Eigenschaft offen, die im Servercode überprüft wird, um zu bestimmen, ob die Benutzereingabe fehlerfrei ist.

Clientfeatures

Bei den meisten Websites erfolgt die Gültigkeitsprüfung auf dem Server. Da Sie die Codeanweisungen für die serverbasierten Überprüfungen ohnehin für die Clients ohne Skriptumgebung schreiben müssen, ist nur schwer einzusehen, dass die gesamten Codeanweisungen erneut für die Clients geschrieben werden müssen, die über die erforderliche Skriptumgebung verfügen.

Die Steuerelemente zur Gültigkeitsprüfung lösen dieses Problem, da fast die gesamte duplizierte Logik in den Steuerelementen gekapselt ist. Wenn ein Client mit Internet Explorer 4.0 oder höher auf Ihre Seite zugreift, kann der Client dieselbe Eingabeüberprüfung vornehmen, die auf dem Server durchgeführt wird, ohne dass Sie ein besonderes Clientskript schreiben müssen.

Die clientseitige Gültigkeitsprüfung zeichnet sich durch eine Vielzahl von Features aus:

• Fehler können angezeigt und unmittelbar nach der falschen Eingabe bzw. nach dem Korrigieren der Eingabe ausgeblendet werden. Das sofortige Feedback erleichtert das Korrigieren einer fehlerhaften Eingabe.

• Falls auf dem Client Fehler erkannt werden, wird das Zurückübertragen der Seite unterbunden. Dies stellt für den Benutzer eine Zeitersparnis dar und verringert die Anzahl von Serverzugriffen.

• Das ValidationSummary-Steuerelement aktualisiert sich selbst. Beim Auftreten von Fehlern findet keine Zurückübertragung statt.

• Das ValidationSummary-Steuerelement kann bei Fehlern optional ein Meldungsfeld für die Benutzer anzeigen.

• Die Clientlogik befindet sich in einer JScript-Bibliothek, d.h., es werden keine ActiveX-Komponenten oder Java-Applets verwendet.

• Bei Bedarf kann VBScript verwendet werden, um Überprüfungen durchzuführen, die auch das eingegebene Datum und einen Zahlenvergleich umfassen.

• Auf dem Client wird ein Objektmodell offen gelegt, um die clientseitige Gültigkeitsprüfung und das Verhalten zu verbessern.

Was ist ein Validator?

Zum effizienteren Verwenden von Validatoren kann es hilfreich sein, eine genauere Definition des Begriffs zu erstellen. Daher werden wir die vorherige Definition ein wenig erweitern:

"Ein Validator ist ein Steuerelement, das ein Eingabesteuerelement auf einen bestimmten Fehlerbedingungstyp überprüft und eine Beschreibung des Problems anzeigt."

Diese Definition ist wichtig, da sie besagt, dass häufig mehrere Validatorsteuerelemente für ein Eingabesteuerelement verwendet werden müssen.

Wenn Sie z.B. prüfen möchten, ob der Benutzer (a) eine Eingabe in einem Textfeld vorgenommen hat, (b) ein gültiges Datum innerhalb eines bestimmten Datumbereichs eingeben hat und (c) dieses Datum vor dem Datum in einem anderen Texteingabesteuerelement liegt, müssen Sie drei Validatoren verwenden. Auch wenn dies ein wenig umständlich ist, sollten Sie bedenken, dass die Benutzereingabe vereinfacht wird, wenn für diese drei Fälle verschiedene Beschreibungen angezeigt werden.

Im Folgenden werden die verschiedenen Typen von Validatoren aufgelistet:

Verwendung von Validatoren

Zur Veranschaulichung der Gültigkeitsprüfung fügen wir einer vorhandenen Seite eine Gültigkeitsprüfung hinzu. Im Folgenden werden die Anforderungen aufgeführt, die bei unserem Beispiel erfüllt werden müssen:

Es muss eine Webseite erstellt werden, auf der eine neue Benutzer-ID und ein Kennwort eingegeben werden. Die Benutzer-ID muss 6-10 alphanumerische Zeichen enthalten und sollte noch verfügbar sein. Das Kennwort muss 4-12 Zeichen umfassen und mindestens eine Zahl sowie eins der folgenden Zeichen enthalten: @#$%^&*/. Der Benutzer muss das Kennwort zweimal eingeben, um sicherzustellen, dass die Eingabe korrekt ist.

Ich beginne mit einer HTML-Seite, die für das Arbeiten in einem ASP+-Seitenframework geringfügig konvertiert wird.

Die Konvertierung der Seite umfasst die folgenden Schritte:

1. Ändern Sie die Dateinamenerweiterung von ".html" oder ".asp" in ".aspx".

2. Ändern Sie das Formular und alle Eingabetags in "runat=server".

3. Verwenden Sie "ID" anstelle von "Name".

Startcode:

<html> 
<head> 
<title>Beispiel für eine Gültigkeitsüberprüfung</title> 
</head> 
<body> 
<p>Geben Sie eine neue Benutzer-ID und ein Kennwort ein:</p> 
<form runat=server> 
<table> 
  <tr> 
    <td>Benutzer-ID:</td> 
    <td><input type=text runat=server id=txtName></td> 
  </tr> 
  <tr> 
    <td>Kennwort:</td> 
    <td><input type=password runat=server id=txtPWord></td> 
  </tr> 
  <tr> 
    <td>Kennwort wiederholen:</td> 
    <td><input type=password runat=server id=txtRePWord></td> 
  </tr> 
<table><br> 
<input type=submit runat=server id=cmdSubmit value=Abschicken> 
</form> 
</body> 
</html>

Startseite:

Erforderliche Eingabe

Als Erstes müssen wir sicherstellen, dass in jedem Feld eine Eingabe vorgenommen wird.

Vor jedem Feld fügen wir den Validator RequiredFieldValidator ein. Wenn das Feld leer ist, soll vor dem Feld ein Sternchen (*) angezeigt und in einem Zusammenfassungsbereich eine Fehlermeldung angezeigt werden. Der folgende Beispielcode veranschaulicht, wie dem Feld Benutzer-ID der Validator RequiredFieldValidator hinzugefügt wird:

  <tr> 
    <td> 
        <asp:RequiredFieldValidator runat=server  
            ControlToValidate=txtName 
            ErrorMessage="Benutzer-ID ist erforderlich."> * 
        </asp:RequiredFieldValidator> 
    </td> 
    <td>Benutzer-ID:</td> 
    <td><input type=text runat=server id=txtName></td> 
  </tr>

Bei einem leeren Feld wird neben der Beschriftung ein Sternchen (*) angezeigt. Die Fehlermeldung wird in einer Zusammenfassung angezeigt. Die ControlToValidate-Eigenschaft gibt die ID des zu überprüfenden Steuerelements an. Als letzter Schritt muss oben auf der Seite eine Zusammenfassung der Gültigkeitsüberprüfung angezeigt werden, z.B.:

<asp:ValidationSummary runat=server  
headerText="Auf der Seite sind Fehler aufgetreten:" /> 

Diese Zusammenfassung sieht auf der Seite wie folgt aus:

Reguläre Ausdrücke

Als Nächstes müssen wir sicherstellen, dass bei der Eingabe von Daten in die Felder Benutzer-ID und Kennwort die Zeichenanforderungen erfüllt werden. Hierfür verwenden wir die RegularExpressionValidator-Steuerelemente. Die regulären Ausdrücke sind ein leistungsstarkes Tool, um für diese Art von Informationen Überprüfungen präzise zu definieren. Dies gilt auch für Postleitzahlen, Telefonnummern und E-Mail-Adressen.

Der folgende Beispielcode veranschaulicht, wie die Einschränkungen bei der Eingabe der Benutzer-ID festgelegt werden:

    <td> 
      <input type=text runat=server id=txtName> 
      <asp:RegularExpressionValidator runat=server  
            ControlToValidate="txtName"  
            ErrorMesage="ID muss 6-10 Zeichen enthalten."  
            ValidationExpression="[a-zA-Z]{6,10}" /> 
    </td>

Beachten Sie, dass wir in diesem Fall innerhalb der Tags keinen Inhalt festgelegt haben. Der innere Text entspricht der Text-Eigenschaft des Steuerelements. Wenn diese Eigenschaft nicht festgelegt wird, wird an der Position, an der das Steuerelement angezeigt wird, und in der Zusammenfassung eine Fehlermeldung angezeigt.

Das Kennwort kann mit Hilfe der beiden folgenden Validatoren überprüft werden. Wenn Sie mehrere verwenden, ist die Eingabe erst dann gültig, wenn alle übereinstimmen.

      <asp:RegularExpressionValidator runat=server display=dynamic 
            ControlToValidate="txtPWord"  
            ErrorMessage="Kennwort muss eins der folgenden Zeichen enthalten: @#$%^&*/." 
            ValidationExpression=".*[@#$%^&*/].*" /> 
      <asp:RegularExpressionValidator runat=server display=dynamic 
            ControlToValidate="txtPWord"  
            ErrorMessage="Kennwort muss 4-12 Zeichen enthalten (kein Leerzeichen)."  
            ValidationExpression="[\S{4,12}" />

Die folgende Abbildung zeigt das Benutzerformular einschließlich der verwendeten Ausdrücke:

Sicherstellen von übereinstimmenden Eingaben

Wir müssen sicherstellen, dass die Eingabe im Feld Kennwort wiederholen der Eingabe im Feld Kennwort entspricht. Hierfür verwenden wir CompareValidator, da dieser Validatortyp gleichzeitig mit zwei Eingabesteuerelementen arbeiten kann:

      <asp:CompareValidator runat=server 
            ControlToValidate=txtRePWord 
            ControlToCompare=txtPWord  
            ErrorMessage="Kennwörter stimmen nicht überein." />

Standardmäßig führt CompareValidator einen einfachen Zeichenfolgenvergleich durch. Bei Bedarf können mit diesem Validatortyp auch komplexere Vergleiche mit Datumsangaben und Zahlen durchgeführt werden.

Benutzerdefinierte Überprüfung

Zum Schluss müssen wir prüfen, ob der Name an unserem Beispielstandort noch verfügbar ist. Hierzu müssen die Daten auf dem Server analysiert werden. Um diesen Vorgang zu simulieren, erstelle ich in den serverseitigen Codeanweisungen eine Dummy-Funktion, die sicherstellt, dass das erste Zeichen kein "a" ist. Auf der Seite wird die folgende Visual Basic-Funktion definiert:

public function CheckID(source as Object, value as String) as Boolean 
    return value.substring(0, 1).tolower() <> "a" 
end function

Zum Aufrufen dieser Funktion füge ich einen CustomValidator hinzu. Dieser Validatortyp wurde entwickelt, um den Entwicklercode aufzurufen, der die Überprüfung durchführt. Die entsprechende Deklaration lautet wie folgt:

      <asp:CustomValidator runat=server 
            controltovalidate="txtName"  
            errormessage="ID wird bereits verwendet."  
            OnServerValidationFunction="CheckID" />

Hiermit können auch benutzerdefinierte Funktionen im Clientskript aufgerufen werden, obwohl dies nicht sinnvoll ist, wenn diese Funktion tatsächlich einen Wert aus der Datenbank abruft. Bei einem Client, der eine Skriptumgebung verwendet, führen zunächst alle anderen Validatoren ihre Überprüfungen auf der Clientseite durch, bevor das Abschicken der Eingabe zugelassen wird. Wenn Fehler auftreten, die bei Überprüfungen erkannt werden, die (wie diese Überprüfung) nur auf Server durchgeführt werden, wird die Seite einschließlich Fehlerinformationen an den Benutzer zurückgesendet.

Das Finale

Nun müssen wir uns nur noch mit dem Auswerten der überprüften Daten beschäftigen. Hierzu müssen Sie lediglich die IsValid-Eigenschaft der Page-Klasse überprüfen, um festzustellen, ob Sie mit dem Aktualisieren der Datenbank fortfahren können. Der Handler zum Übertragen der Seite kann wie folgt aussehen:

public sub OnSubmit(source as Object, e as EventArgs) 
    if Page.IsValid then 
        ' Jetzt kann die Transaktion durchgeführt werden. 
    end if 
end sub

Wie Sie sehen, ermöglicht es uns dieser Handler, dass die Dateneingabeseiten nur anwendungsspezifische Codeanweisungen enthalten. Es sind keine umfangreichen Codeanweisungen erforderlich, die sich mit der Überprüfung der Benutzereingabe befassen.

Hier sehen Sie, wie die fertige Seite aussieht: