Hinzufügen der Validierung regulärer Ausdrücke

 

Duncan Mackenzie
Microsoft Developer Network

Mai 2002

Zusammenfassung: Behandelt die Grundlagen des Erbens von einem anderen Steuerelement und hinzufügen eigener Eigenschaften, Methoden und Ereignisse sowie des Hinzufügens ihres eigenen Codes. eines von einer Reihe von Microsoft Windows Forms Entwicklungsbeispielen, die zusammen mit dem zugehörigen Übersichtsartikel gelesen werden sollen. (12 gedruckte Seiten)

Laden Sie WinFormControls.exeherunter.

Dieser Artikel ist der zweite in einer Fünf-Artikel-Reihe zum Entwickeln von Steuerelementen in Microsoft® .NET:

• Entwickeln benutzerdefinierter Windows-Steuerelemente mit Visual Basic .NET (Übersicht)
• Hinzufügen der Validierung regulärer Ausdrücke
• Kombinieren mehrerer Steuerelemente zu einem Steuerelement
• Erweitern des TreeView-Steuerelements
• Zeichnen eigener Steuerelemente mit GDI+

Inhalte

Einführung
Beispiel 1a: Hinzufügen der Validierung regulärer Ausdrücke zum TextBox-Steuerelement
Eine kurze Diskussion zu regulären Ausdrücken
Was muss ich erstellen?
Beispiel 1b: Hinzufügen der Validierung regulärer Ausdrücke als alternative Methode
Zusammenfassung

Einführung

In diesem Artikel werden zwei Beispiele behandelt: das Erstellen eines benutzerdefinierten TextBox-Steuerelements , das die Validierung regulärer Ausdrücke ausführt, und das Erstellen eines Extenderanbieters, der eine andere Methode verwendet, um dieselbe Validierung regulärer Ausdrücke durchzuführen.

Beispiel 1a: Hinzufügen der Validierung regulärer Ausdrücke zum TextBox-Steuerelement

Im Übersichtsartikel habe ich Ihnen gezeigt, wie Sie das TextBox-Steuerelement schnell verbessern, um nur numerische Daten zu akzeptieren, wodurch ein neues Steuerelement mit einem minimalen Arbeitsaufwand erstellt wird. Dieses Beispiel sollte nur veranschaulichen, wie schnell ein Steuerelement durch die Verwendung von Vererbung erstellt werden kann, daher war es ziemlich begrenzt. Für mein erstes Beispiel zeige ich Ihnen, wie Sie ein Steuerelement erstellen, das dieses Ziel auf elegantere Weise erreicht. Anstatt dieses Steuerelement einfach zu erweitern, um Währungen und andere numerische Formate zu unterstützen, besteht ein besserer Ansatz darin, ein generischeres Steuerelement zu erstellen, um die Texteingabe einzuschränken. Wenn Sie ASP.NET (Web)-Anwendungen erstellen, wurde bereits ein Steuerelement bereitgestellt, um genau das zu erreichen, was ich beschreibe: das RegularExpressionValidator-Steuerelement, das in der .NET Framework Allgemeine Referenz dokumentiert ist. Mit diesem Steuerelement können Sie die Texteingabe auf ein beliebiges Format beschränken, das mit einem regulären Ausdruck beschrieben werden kann, d. h. auf ein beliebiges Format. Da eine Version dieses Steuerelements nicht für die Verwendung in Windows Forms bereitgestellt wurde, ist es ein hervorragendes Beispiel für ein benutzerdefiniertes Steuerelement, das Sie erstellen können– ein Windows Form-Textfeld, das seinen Inhalt anhand eines regulären Ausdrucks überprüft.

Eine kurze Diskussion zu regulären Ausdrücken

Bevor ich in die Steuerungsentwicklung einspringe, sind Sie vielleicht daran interessiert, etwas über reguläre Ausdrücke zu erfahren. Im Folgenden finden Sie einige Ressourcen, die Ihnen helfen:

• Reguläre Ausdrücke von .NET Framework
  Dieser Abschnitt der .NET Framework Dokumentation enthält sowohl eine Einführung in das Konzept und den Zweck von regulären Ausdrücken als auch einen Verweis auf die Verwendung der relevanten Klassen innerhalb des Frameworks.
• Beispiele für reguläre Ausdrücke auf der Website der Bibliothek für reguläre Ausdrücke
  Nachdem Sie das Material in der .NET Framework-Dokumentation gelesen haben, bietet diese Website eine große Liste von regulären Beispielausdrücken, die Sie verwenden können.

Was muss ich erstellen?

Um mein überprüfendes TextBox-Element zu erstellen, muss ich einige verschiedene Schritte ausführen. Zunächst muss ein neues leeres Steuerelement erstellt werden, das von TextBox erbt. Als Nächstes wird eine neue Eigenschaft hinzugefügt, die den regulären Ausdruck enthält, für den überprüft werden soll, und eine private Funktion wird geschrieben, die den Inhalt des TextBox-Objekts anhand der Eigenschaft für reguläre Ausdrücke überprüft. Schließlich kann ich durch Überschreiben des OnValidating-Ereignisses des Steuerelements überprüfen, ob der Inhalt des Steuerelements gültig ist, und das Ereignis abbrechen.

Schritt 1: Erstellen eines neuen benutzerdefinierten Steuerelements

Wenn Sie Steuerelemente für sich selbst oder andere Benutzer entwickeln, empfiehlt es sich, sie in ein eigenes Projekt zu integrieren, sodass sie als kompilierte Assembly (in diesem Fall eine DLL) freigegeben werden können, anstatt den Code zu übergeben. In diesem Sinne erstelle ich ein neues Windows-Steuerelementbibliotheksprojekt, das das neue Steuerelement enthält, und dann ein reguläres Windows-Anwendungsprojekt in derselben Projektmappe, um das Testen des Steuerelements zu vereinfachen. Wenn Sie ein neues Windows-Steuerelementbibliotheksprojekt erstellen, wird standardmäßig ein neues leeres Benutzersteuerelement als Ausgangspunkt hinzugefügt. In diesem Fall möchte ich kein Benutzersteuerelement verwenden, da ich von einem vorhandenen Steuerelement erbe. Daher lösche ich diese Datei und füge einfach eine neue Klassendatei hinzu.

Hinweis Sie können auch einfach die Codeansicht für das Element Benutzersteuerung öffnen, den gesamten Code löschen und dann einen eigenen hinzufügen, anstatt das Element zu löschen und eine neue Klassendatei hinzuzufügen.

Um als Nächstes anzugeben, dass diese neue Klasse von der TextBox-Klasseerben soll, füge ich der leeren Klasse, die Microsoft® Visual Studio® .NET erstellt, eine Inherits-Anweisung hinzu:

Public Class RegExTextBox
    Inherits System.Windows.Forms.TextBox

End Class

Mit nur diesem kleinen Code habe ich bereits meine eigene Version von TextBox erstellt, indem ich vom vorhandenen Steuerelement geerbt habe. Da ich keinen eigenen Code hinzugefügt habe, würde dieses neue Steuerelement genau wie ein normales TextBox-Steuerelement aussehen und sich verhalten. Durch das Vererben ändert sich nichts, bis Sie mit dem Hinzufügen von Code oder Attributen beginnen.

Schritt 2: Hinzufügen einer neuen Eigenschaft

Der nächste Schritt beim Erstellen dieses Steuerelements besteht darin, eine neue String-Eigenschaft hinzuzufügen, die die Anweisung für reguläre Ausdrücke enthält. Um kreativ zu sein, nenne ich es RegularExpression, und zusätzlich zur Eigenschaft selbst erstell ich auch eine interne Variable, die den Wert der Eigenschaft m_RegularExpression. Obwohl diese Klasse ein Windows Form-Steuerelement beschreibt, unterscheidet sich das Hinzufügen einer neuen Eigenschaft nicht vom Hinzufügen zu einer anderen Microsoft Visual Basic® .NET-Klasse:

    Private m_RegularExpression As String

    Public Property RegularExpression() As String
        Get
            Return m_RegularExpression
        End Get
        Set(ByVal Value As String)
            m_RegularExpression = Value
        End Set
    End Property

Um diese neue Eigenschaft zu verwenden und die Gültigkeit der TextBox-Inhalte zu überprüfen, verwenden Sie den System.Text.RegularExpressions-Namespace. Anhand der Beispiele für diese Referenzdokumentation kann ich ein neues RegEx-Objekt erstellen, das die RegularExpression-Eigenschaft im Konstruktor angibt, und dann dieses Objekt verwenden, um zu überprüfen, ob die TextBox-Inhalte mit dem Ausdruck übereinstimmen:

    'added a Imports System.Text.RegularExpressions to the 
    'top of the class to simplify the code
    Private Function IsValid(ByVal Contents As String) As Boolean
        Dim myRegEx As New Regex(RegularExpression)
        Dim myMatch As Match
        myMatch = myRegEx.Match(Contents)
        Return myMatch.Success
    End Function

Wenn ich das Steuerelement an diesem Punkt ausprobieren könnte, würde ich feststellen, dass dieser Code nicht korrekt ist, da er True zurückgibt, wenn eine Übereinstimmung innerhalb der Zeichenfolge gefunden wird. Mit diesem Code würde ein regulärer Ausdruck, der fünfstellige Postleitzahlen finden soll, mit den ersten fünf Ziffern in einer Zeichenfolge wie "23434fred" übereinstimmen, obwohl der zusätzliche Text am Ende hinzugefügt wurde. Wir möchten tatsächlich testen, ob die Zeichenfolge und der Ausdruck genau übereinstimmen. Wenn Sie eine Überprüfung hinzufügen, um sicherzustellen, dass die gefundene Übereinstimmung gleich der gesamten Zeichenfolge ist, funktioniert diese Routine ordnungsgemäß. Gleichzeitig habe ich diesen Test auch in einen sehr einfachen Fehlerbehandlungsblock eingeschlossen, sodass ein ungültiger RegularExpression den Rückgabewert False verursacht:

    'added a Imports System.Text.RegularExpressions to the 
    'top of the class to simplify the code
    Private Function IsValid(ByVal Contents As String) As Boolean
        Try
            Dim myRegEx As New Regex(RegularExpression)
            Dim myMatch As Match
            myMatch = myRegEx.Match(Contents)
            If myMatch.Success _
              AndAlso myMatch.Index = 0 _
              AndAlso myMatch.Length = Contents.Length Then
                Return True
            Else
                Return False
            End If
        Catch
            'some form of error in parsing the pattern
            Return False
        End Try
    End Function

Dieser Code gibt nur True zurück, wenn die Übereinstimmung gefunden wird, und deckt die gesamte Länge der Inhaltszeichenfolge ab, was genau das ist, was ich möchte.

Schritt 3: Überschreiben von OnValidating

Windows Forms-Steuerelemente bieten eine Vielzahl von Methoden und Ereignissen, die sich bereits mit der Validierung befassen. Daher scheint es angebracht, meinen neuen RegularExpression-Check in dieses vorhandene Modell einzupassen, indem Sie die TextBox-Inhalte in der OnValidating-Methode überprüfen. Diese Methode wird aufgerufen, wenn das Steuerelement den Fokus verliert und die CausesValidation-Eigenschaft des Steuerelements gleich True ist. Um dieses Steuerelement auch dann nützlich zu machen, wenn Validation nicht verwendet wird (CausesValidation = False), wird auch eine schreibgeschützte Eigenschaft (Gültig) hinzugefügt, um die direkte Überprüfung auf gültigen Inhalt zu unterstützen:

    Public ReadOnly Property Valid() As Boolean
        Get
            Return IsValid(Text)
        End Get
    End Property
    Protected Overrides Sub OnValidating(ByVal e As _
      System.ComponentModel.CancelEventArgs)
        If Not Valid() Then
            e.Cancel = True
        End If
        MyBase.OnValidating(e)
    End Sub

Fügen Sie den gesamten Code zusammen, und Sie haben eine vollständige Kontrolle, die Sie ausprobieren können. Erstellen Sie das Steuerelementprojekt, und wechseln Sie dann zum Testprojekt (eine Windows-Anwendung, die der gleichen Projektmappe hinzugefügt wurde), fügen Sie einen Verweis auf Ihr RegExTextBox-Projekt hinzu, und passen Sie die Toolbox an, um Ihr neues Steuerelement anzuzeigen. Nachdem Sie das neue TextBox-Objekt ihrem Windows Form hinzugefügt haben, können Sie das Standardeigenschaftenfenster verwenden, um die RegularExpression-Eigenschaft des Steuerelements zu bearbeiten. Einige Beispiele für reguläre Ausdrücke, die Sie möglicherweise ausprobieren möchten, sind hier aufgeführt:

• Einfache Postleitzahl, überprüft auf 5 numerische Ziffern: "\d{5}".
• Datumsformat, überprüft auf MM/TT/JJJJ: "\d{1,2}\/\d{1,2}/\d{4}".
  Beachten Sie, dass die Werte nicht überprüft werden, nur das Format, sodass 34/58/2341 vollkommen korrekt wäre, auch wenn es sich nicht um einen ordnungsgemäßen Datumswert handelt.

Einfügen von Eigenschaften in Kategorien und Hinzufügen einer Toolbox-Bitmap

Die Verwendung des Steuerelements in einem anderen Projekt zeigt einige kosmetische Details, die geändert werden müssen, damit es professionell aussieht. Das erste Problem besteht darin, dass unsere Eigenschaften unten in der Liste Eigenschaften unter der Kategorie "Sonstige" angezeigt werden. Dies ist das Standardverhalten, wenn Sie keine bestimmte Kategorie festlegen.

Zuweisen von Eigenschaften zu Kategorien

Durch Hinzufügen eines Attributs zur Eigenschaftendefinition kann es problemlos in eine Kategorie eingefügt oder sogar ganz vor dem Eigenschaftenfenster ausgeblendet werden. Für dieses Steuerelement gibt es zwei Eigenschaften: Valid und RegularExpression. Ich werde RegularExpression in die Kategorie Verhalten einfügen, aber es gibt keine wirkliche Einschränkung, wo Sie eine bestimmte Eigenschaft platzieren; Sie können sogar eine eigene Kategorie erstellen. Das System.ComponentModel.Category-Attribut wird verwendet, um die entsprechende Kategorie anzugeben. Beachten Sie jedoch, dass es nur eine Zeichenfolge als Argument verwendet. Stellen Sie daher sicher, dass Sie den Kategorienamen richtig schreiben:

    <System.ComponentModel.Category("Behavior")> _
     Public Property RegularExpression() As String
        Get
      …

Als Kanadier habe ich ursprünglich die "richtige" Schreibweise für das Verhalten eingefügt und am Ende eine völlig neue Kategorie in meinem Eigenschaftenfenster.

Abbildung 1. Sie können einen beliebigen Kategorienamen verwenden, der als Abschnitt des Eigenschaftenfensters angezeigt wird.

Richtiger Kategoriename oder nicht, Sie können feststellen, dass meiner neuen Eigenschaft eine Beschreibung fehlt (die normalerweise im unteren Bereich des Eigenschaftenfenster angezeigt wird), und, wie Sie vielleicht erraten haben, kann ein anderes Attribut verwendet werden, um dies zu beheben. Das System.ComponentModel.Description-Attribut akzeptiert eine Zeichenfolge als Argument, das dann angezeigt wird, wenn diese Eigenschaft im Eigenschaftenfenster ausgewählt wird:

Private Const regularExpressionDescription As String _
= "The Regular Expression used to validate the contents of this TextBox"

    <System.ComponentModel.Category("Behavior"), _
    System.ComponentModel.Description(regularExpressionDescription)> _
    Public Property RegularExpression() As String
        Get

Valid ist im Gegensatz zu RegularExpression zur Entwurfszeit nicht sehr nützlich (es ist schreibgeschützt und wird basierend auf dem Inhalt des TextBox-Elements berechnet), daher möchte ich, dass es in keiner Kategorie im Eigenschaftenfenster angezeigt wird. Glücklicherweise kann ein anderes Attribut dies für mich übernehmen: das System.ComponentModel.Browsable-Attribut, das ein boolesches Argument akzeptiert, das angibt, ob die Eigenschaft im Eigenschaftenfenster sichtbar sein soll:

<System.ComponentModel.Browsable(False)> _
    Public ReadOnly Property Valid() As Boolean
        Get
            Return IsValid(Text)
        End Get
    End Property

Hinzufügen einer Toolbox-Bitmap

Ein weiteres Problem mit der Darstellung meines neuen Steuerelements besteht darin, dass ich kein Toolboxsymbol angegeben habe, sodass stattdessen das Standardsteuerelementsymbol verwendet wird. Genau wie die Eigenschaftenkategorien wird das Hinzufügen eines Toolboxsymbols durch die Verwendung von Attributen verarbeitet, in diesem Fall das ToolboxBitmap-Attribut . Mit diesem Attribut können Sie einen Pfad zu einer tatsächlichen Bitmapdatei (16 x 16) angeben oder eine Toolbox-Bitmap angeben, die als Ressource in eine Assembly eingebettet ist. In diesem Beispiel werde ich nur einen Dateipfad angeben und eine Toolbox-Bitmap verwenden, die ich in Paint erstellt habe:

<ToolboxBitmap("C:\mytoolboxbitmap.bmp")> _
Public Class regexTextBox
    Inherits System.Windows.Forms.TextBox

Beispiel 1b: Hinzufügen der Validierung regulärer Ausdrücke als alternative Methode

Das Erstellen einer eigenen Version des TextBox-Steuerelements ist eine Möglichkeit, zusätzliche Funktionen hinzuzufügen, aber in .NET können Sie auch ein ähnliches Ergebnis erzielen, indem Sie ein Extenderanbieterobjekt verwenden. Extenderanbieter, z. B. die Komponenten ErrorProvider oder QuickInfo, die bereits in Windows Forms vorhanden sind, ermöglichen ihnen das dynamische Hinzufügen von Eigenschaften zu anderen Steuerelementen. Mithilfe einer solchen Komponente konnte ich allen TextBox-Steuerelementen in meinem Formular eine RegularExpression-Eigenschaft hinzufügen und Validierungsdienste für jedes Steuerelement bereitstellen, das über einen Wert für diese neue Eigenschaft verfügte. In diesem speziellen Fall unterscheidet sich das Endergebnis nicht so vom Erstellen Einer eigenen TextBox-Variante , aber der Extenderanbieteransatz eignet sich gut für jede Art von Funktionalität, die Sie auf eine Gruppe von Steuerelementen gleichzeitig anwenden möchten.

Erstellen eines eigenen Extenderanbieters

Im Gegensatz zu anderen Steuerelementen werden Extenderanbieter durch die Implementierung einer Schnittstelle und nicht durch Vererbung erstellt. Diese Schnittstelle (IExtenderProvider) definiert nur die einzelne Methode CanExtend, aber diese einzelne Methode funktioniert in Kombination mit einer Vielzahl von Attributen auf Klassenebene, um die Funktionalität Ihres Anbieters zu beschreiben. Da Sie Ihren Extenderanbieter in der Windows Forms-Umgebung bearbeiten möchten, sollten Sie ihn zusätzlich zur Implementierung der IExtenderProvider-Schnittstelle von Component oder Control erben:

Public Class regexRevisted
    Inherits System.ComponentModel.Component
    Implements System.ComponentModel.IExtenderProvider

End Class

Hinzufügen von Attributen für jede Eigenschaft

Nachdem Sie Ihre Klasse deklariert haben, müssen Sie ein Attribut für jede Eigenschaft hinzufügen, die Sie anderen Steuerelementen bereitstellen möchten. In diesem Fall möchte ich eine ValidationExpression-Eigenschaft hinzufügen, die die regulären Ausdrücke für jedes TextBox-Steuerelement enthält, und eine Valid-Eigenschaft , die einen True - oder False-Wert zurückgibt, um anzugeben, ob die aktuelle ValidationExpression erfüllt wird. Das Attribut, das ich hinzufügen muss, ist System.ComponentModel.ProvideProperty und benötigt zwei Parameter für den Konstruktor: den Namen der neuen Eigenschaft, die Sie bereitstellen möchten, und den Typ des Steuerelements, dem diese neue Eigenschaft hinzugefügt wird. In meinem Fall habe ich also den folgenden Code hinzugefügt:

<ProvideProperty("ValidationExpression", GetType(TextBox)), _
ProvideProperty("Valid", GetType(TextBox))> _
Public Class regexRevisted

Hinweis Die Dokumentation zu ProvideProperty hatte mich ziemlich verwirrt; Ich war davon überzeugt, dass der zweite Parameter der Typ der Eigenschaft sein sollte, und ich habe versucht, es mithilfe von GetType(String) zum Funktionieren zu bringen. Glücklicherweise hat jemand meinen Fehler ziemlich schnell erkannt, als ich ihn hier bei Microsoft passierte, und ich habe ihn in GetType(TextBox) geändert.

Erstellen von Eigenschaftenroutinen

Für jede Eigenschaft, die Sie mit Ihren Attributen definieren, müssen Sie außerdem Get - und Set-Routinen bereitstellen, damit die Eigenschaft in allen anderen Steuerelementen angezeigt und bearbeitet werden kann. Diese Routinen sind den von Ihnen angegebenen Eigenschaften nur nach Name zugeordnet:

Public Function GetValidationExpression(ByVal o As TextBox) As String

Public Sub SetValidationExpression(ByVal o As TextBox, _
      ByVal ValidationExpression As String)

In diesen Eigenschaftsroutinen müssen Sie die für jedes Steuerelement festgelegten Werte beibehalten, damit Sie nachverfolgen können, welcher Eigenschaftswert auf welches Steuerelement angewendet wird. Um dies in meinem Code zu erreichen, habe ich eine NameValueCollection hinzugefügt, um die ValidationExpression-Eigenschaft für jedes Steuerelement nachzuverfolgen, das sich für das Festlegen eines Werts entscheidet. Mit einer NameValueCollection können Sie eine Auflistung von Zeichenfolgenwerten Zeichenfolgenschlüsselwerten zuordnen, sodass sie einem Dictionary-Objekt sehr ähnlich ist, aber stark typisiert ist, um nur mit Zeichenfolgen zu arbeiten. In diesem Fall habe ich einen einzelnen ValidationExpression-Eintrag dem Namen des entsprechenden Steuerelements zugeordnet. Kontrollnamen müssen auf demselben Formular eindeutig sein, sodass ich sicher sein kann, dass es keine Konflikte gibt:

    Dim RegExpressions As New _
      System.Collections.Specialized.NameValueCollection()

    Public Function GetValidationExpression(ByVal o As TextBox) As String
        Return RegExpressions.Get(o.Name)
    End Function

    Public Sub SetValidationExpression(ByVal o As TextBox, _
            ByVal ValidationExpression As String)
        RegExpressions.Set(o.Name, ValidationExpression)
    End Sub

Zusätzlich zum Festlegen und Abrufen des Werts des regulären Ausdrucks füge ich jedem Steuerelement einen Ereignishandler hinzu, das einen nicht leeren Wert festgelegt hat (was angibt, dass das Steuerelement eine Überprüfung wünscht). Dieser Ereignishandler ist so eingerichtet, dass er das OnValidation-Ereignis jedes TextBox-Objekts abfangen kann, sodass mein ExtenderProvider den Inhalt des Textfelds genau wie regExTextBox überprüfen kann (siehe Beispiel 1a). Wenn die Überprüfung fehlschlägt, wird ein Ereignis des ExtenderProvider ausgelöst, sodass ein einzelner Ereignishandler alle Validierungsfehler der zugeordneten Steuerelemente abfangen kann:

    Public Sub SetValidationExpression(ByVal o As TextBox, _
            ByVal ValidationExpression As String)
        RegExpressions.Set(o.Name, ValidationExpression)
        If ValidationExpression <> "" Then
            AddHandler o.Validating, _
     New System.ComponentModel.CancelEventHandler(AddressOf OnValidating)
        Else
            RemoveHandler o.Validating, _
     New System.ComponentModel.CancelEventHandler(AddressOf OnValidating)
        End If
    End Sub

    Private Sub OnValidating(ByVal sender As Object, _
            ByVal e As System.ComponentModel.CancelEventArgs)
        Dim tb As TextBox
        If TypeOf sender Is TextBox Then
            tb = CType(sender, TextBox)
            Dim validationExpression As String
            validationExpression = RegExpressions.Get(tb.Name)
            If validationExpression <> "" Then
                If Not IsValid(validationExpression, tb.Text) Then
                    RaiseEvent ValidationError(tb, _
                     New System.EventArgs())
                End If
            End If
        End If
    End Sub

Beachten Sie, dass ich den Handler entferne, wenn ValidationExpression auf eine leere Zeichenfolge festgelegt ist. warum Ereignisse behandeln oder anderweitig mit einem Steuerelement arbeiten, das nichts mit meinem Anbieter zu tun haben möchte? Jetzt ist die Valid-Eigenschaft etwas einfacher zu implementieren, da sie eine schreibgeschützte Eigenschaft ist und nur eine GetValid-Funktion erstellt werden muss. Diese Funktion (ruft tatsächlich eine andere Funktion auf, IsValid) überprüft den Inhalt eines bestimmten TextBox-Steuerelements anhand seiner ValidationExpression und gibt True oder False zurück, je nachdem, ob der Inhalt mit dem Ausdruck übereinstimmt:

    Private Function IsValid(ByVal validationExpression As String, _
            ByVal input As String) As Boolean
        Dim reCheck As New Regex(validationExpression)
        Dim myMatch As Match
        myMatch = reCheck.Match(input)
        If Not (myMatch.Success AndAlso _
              myMatch.Index = 0 AndAlso _
              myMatch.Length = input.Length) Then
            Return False
        Else
            Return True
        End If
    End Function

    Public Function GetValid(ByVal o As TextBox) As Boolean
        Dim validationExpression As String
        validationExpression = RegExpressions.Get(o.Name)
        If validationExpression <> "" Then
            Return IsValid(validationExpression, o.Text)
        Else
            Return True
        End If
    End Function

Implementieren der CanExtend-Funktion

Obwohl es logisch erscheint, diese Funktion zuerst zu erstellen, da die IExtenderProvider-Schnittstelle erfordert, dass sie vorhanden ist und sich beschwert, bis Sie sie hinzufügen, war das Hinzufügen meiner Implementierung von CanExtend das letzte Stück Code, den ich geschrieben habe. Die wichtigste Aufgabe von CanExtend besteht darin, für jedes übergebene Steuerelement True oder False zurückzugeben, um anzugeben, ob meine beiden neuen Eigenschaften auf dieses bestimmte Steuerelement angewendet werden sollen. Im Fall meines ExtenderProviders möchte ich, dass diese Eigenschaften auf jedes einzelne TextBox-Element angewendet werden. Daher überprüfen Sie einfach den Typ des angegebenen Steuerelements und geben True zurück, wenn es textBox ist, oder false, wenn dies nicht der Fall ist. Sobald ich mich entschieden habe, ein Steuerelement zu behandeln, füge ich auch einen leeren Eintrag in meine NameValueCollection als Platzhalter für eine mögliche ValidationExpression hinzu:

    Public Function CanExtend(ByVal extendee As Object) As Boolean _
     Implements System.ComponentModel.IExtenderProvider.CanExtend
        If TypeOf extendee Is System.Windows.Forms.TextBox Then
            RegExpressions.Set(CType(extendee, TextBox).Name, "")
            Return True
        Else
            Return False
        End If
    End Function

Letzte Schliffe

Wie beim vorherigen Steuerelement gibt es immer einige zusätzliche Attribute, die festgelegt werden können, oder zusätzlichen Code, der hinzugefügt werden könnte, um das Steuerelement nützlicher oder professioneller im Erscheinungsbild zu machen. Im Fall meines ExtenderProviders möchte ich nicht, dass Programmierer versehentlich die Routinen Get und Set für meine beiden neuen Eigenschaften aufrufen, sodass ich sie mithilfe von EditorBrowsableAttribute in Microsoft Intellisense® ausblenden kann:

    <EditorBrowsableAttribute(EditorBrowsableState.Never)> _
    Public Function GetValid(ByVal o As TextBox) As Boolean

Wenn Sie weitere Informationen zu ExtenderProvider benötigen, können Sie eine exemplarische Vorgehensweise zu diesem Prozess in der .NET Framework-Dokumentation anzeigen, und der Code für dieses Beispiel wird als Teil des Downloads für diesen Artikel bereitgestellt. Der fertige ExtenderProvider namens regexRevisited, wenn er auf einem Windows Form platziert wird, fügt jedem TextBox-Objekt zwei Eigenschaften hinzu: ValidationExpression und Valid. Das Endergebnis und die Programmierererfahrung sind sehr ähnlich wie das Ersetzen jedes TextBox durch den benutzerdefinierten regulären Ausdruck TextBox, den ich zuvor erstellt habe, aber der gesamte Code ist in der einzelnen Komponente enthalten.

Zusammenfassung

Beide Versionen dieses Beispiels bieten das gleiche Ergebnis – die Überprüfung eines TextBox-Steuerelements mit regulären Ausdrücken – aber auf unterschiedliche Weise. Es ist schwierig, eine Methode gegenüber der anderen zu empfehlen, da beide funktionieren und der Code nicht so unterschiedlich ist, aber Sie sollten sich über beide mögliche Möglichkeiten zum Hinzufügen von Features zu Windows Forms Steuerelementen bewusst sein, damit Sie die am besten geeignete Lösung für Ihr bestimmtes Projekt auswählen können.