Mithilfe regulärer Ausdrücke auf Gültigkeit prüfen

Artikel
04/18/2008

Veröffentlicht: 28. Aug 2002 | Aktualisiert: 22. Jun 2004

Von Duncan Mackenzie

Dieser Artikel beschreibt die Grundlagen der Vererbung von anderen Steuerelementen und das Hinzufügen eigener Eigenschaften, Methoden und Ereignisse sowie eigenem Code. Der Artikel gehört zu einer Artikelreihe mit Beispielen für die Entwicklung von Microsoft Windows-Steuerelementen. Diese Reihe sollte in Verbindung mit einem Übersichtsartikel gelesen werden.

Adding Regular Expression Validation

WinFormControls.exe

* * *

Auf dieser Seite

Einführung
Beispiel 1a: Hinzufügen einer Gültigkeitsprüfung mithilfe regulärer Ausdrücke zum TextBox-Steuerelement
Eine kurze Erläuterung von regulären Ausdrücken
Was benötigen Sie für den Entwicklungsprozess?
Beispiel 1b: Alternative Möglichkeit zum Hinzufügen einer Gültigkeitsprüfung mithilfe regulärer Ausdrücke
Zusammenfassung

Dieser Artikel ist der zweite Artikel einer fünfteiligen Reihe zur Entwicklung von Steuerelementen in Microsoft® .NET:

Developing Custom Windows Controls Using Visual Basic .NET (Übersicht)
Hinzufügen einer Überprüfung mithilfe regulärer Ausdrücke
Combining Multiple Controls into One
Erweitern des TreeView-Steuerelements
Drawing Your Own Controls Using GDI+

Einführung

In diesem Artikel sind zwei Beispiele erläutert: Zum einen das Programmieren eines benutzerdefinierten TextBox-Steuerelements, das eine Gültigkeitsprüfung mithilfe regulärer Ausdrücke durchführt, und zum anderen das Programmieren eines Extenderproviders, der eine andere Methode der Gültigkeitsprüfung verwendet.

Beispiel 1a: Hinzufügen einer Gültigkeitsprüfung mithilfe regulärer Ausdrücke zum TextBox-Steuerelement

Im Übersichts-Artikel wurde das schnelle Verbessern des TextBox-Steuerelements dargestellt, so dass nur numerische Daten angenommen werden. Auf diese Weise kann mit wenig Aufwand ein neues Steuerelement entwickelt werden. Das Beispiel sollte lediglich veranschaulichen, wie schnell ein Steuerelement mithilfe von Vererbung entstehen kann, und beschränkte sich daher auf diesen Punkt.

Das erste Beispiel in diesem Artikel soll das Programmieren eines Steuerelements auf elegantere Weise darstellen. Das Steuerelement soll also nicht einfach erweitert werden, um Währungs- und weitere numerische Formate zu verarbeiten. Stattdessen wird das Entwickeln eines allgemeineren Steuerelements veranschaulicht, das die Texteingabe beschränkt.

Beim Entwickeln von ASP.NET-Anwendungen (Webanwendungen) wird bereits ein Steuerelement zur Verfügung gestellt, um den hier beschriebenen Vorgang durchzuführen: dabei handelt es sich um das RegularExpressionValidator-Steuerelement, das in der .NET Framework General Reference erläutert ist. Dieses Steuerelement ermöglicht Ihnen, die Texteingabe auf Formate zu beschränken, die mithilfe eines regulären Ausdrucks beschrieben werden können; im Wesentlichen also alle Formate.

Da von diesem Steuerelement keine Version für Windows Forms vorhanden ist, kann es als anschauliches Beispiel für ein benutzerdefiniertes, von Ihnen entwickeltes Steuerelement dienen - ein Windows Forms TextBox-Steuerelement, das seinen Inhalt mithilfe eines regulären Ausdrucks überprüft.

Eine kurze Erläuterung von regulären Ausdrücken

Bevor ich auf die Steuerelemententwicklung eingehe, möchte ich Ihnen einige Hilfestellungen zu regulären Ausdrücken zur Verfügung stellen. Die folgenden Ressourcen enthalten entsprechende Informationen:

Reguläre Ausdrücke im .NET Framework
Dieser Abschnitt der .NET Framework-Dokumentation enthält sowohl eine Einführung in den Begriff und den Zweck der regulären Ausdrücke als auch eine Referenz für den Einsatz relevanter Klassen im Framework.
Reguläre Ausdrücke-Beispiele auf der Website der Bibliothek zu regulären Ausdrücken
Nachdem Sie das .NET Framework-Dokumentationsmaterial studiert haben, stellt diese Website dazu ergänzend eine umfangreiche Liste mit Beispielen regulärer Ausdrücke zur praktischen Verwendung zur Verfügung.

Was benötigen Sie für den Entwicklungsprozess?

Das Entwickeln der Überprüfungs-TextBox erfordert mehrere Schritte. Zunächst muss ein leeres Steuerelement programmiert werden, das von TextBox erbt. Als Nächstes wird eine neue Eigenschaft hinzugefügt, die den regulären Ausdruck für die Überprüfung enthalten soll. Anschließ;end wird eine private Funktion geschrieben, die den Inhalt von TextBox mithilfe der Eigenschaft für reguläre Ausdrücke überprüft. Schließ;lich kann durch Auß;erkraftsetzen des OnValidating-Ereignisses des Steuerelements die Gültigkeit des Steuerelementinhalts geprüft und das Ereignis abgebrochen werden.

Schritt 1: Programmieren eines neuen benutzerdefinierten Steuerelements

Wenn Sie Steuerelemente für sich und andere Benutzer entwickeln, empfiehlt es sich, dafür jeweils eigene Projekte zu verwenden. In diesem Fall muss der Code nicht weitergegeben werden, weil die Freigabe als kompilierte Assembly (in diesem Fall als DLL) erfolgen kann. Daher wird hier das Entwickeln eines neuen Projekts einer Windows-Steuerelementbibliothek beschrieben, das das neue Steuerelement enthält.

Anschließ;end wird ein Projekt mit einer regulären Windows-Anwendung als Bestandteil der Lösung erstellt, um das Steuerelement zu testen. Standardmäß;ig wird beim Entwickeln eines neuen Projekts einer Windows-Steuerelementbibliothek ein neues leeres Benutzersteuerelement als Ausgangspunkt hinzugefügt. In diesem Fall soll das Benutzersteuerelement jedoch nicht verwendet werden, da die Vererbung von einem vorhandenen Steuerelement durchgeführt wird. Die Datei wird daher gelöscht, und eine neue Klassendatei wird hinzugefügt.

Anmerkung Sie können auch die Codeansicht des Benutzersteuerelements öffnen, den gesamten Code löschen und Ihren Code hinzufügen. Das Löschen des Elements und das Hinzufügen einer neuen Klassendatei ist nicht unbedingt erforderlich.

Um anzugeben, dass die neue Klasse von der TextBox-Klasse erbt, wird eine Inherits-Anweisung zu der von Microsoft® Visual Studio® .NET angelegten Klasse hinzugefügt:

Public Class RegExTextBox
    Inherits System.Windows.Forms.TextBox
End Class

Mit diesem kurzen Code wurde bereits eine eigene Version von TextBox programmiert, die vom vorhandenen Steuerelement erbt. Da kein eigener Code hinzugefügt wurde, entsprechen Aussehen und Verhalten des neuen Steuerelements genau dem regulären TextBox-Steuerelement; das Vererben führt nicht zu Veränderungen, solange kein Code oder keine Attribute hinzugefügt werden.

Schritt 2: Hinzufügen einer neuen Eigenschaft

Der nächste Schritt beim Entwickeln des Steuerelements besteht im Hinzufügen einer neuen String-Eigenschaft, die den regulären Ausdruck enthält. In diesem Fall wird die Eigenschaft RegularExpression genannt. Daneben wird eine interne Variable m_RegularExpression hinzugefügt, die den Wert selbst speichert. Obwohl diese Klasse ein Windows Forms-Steuerelement beschreibt, unterscheidet sich das Hinzufügen einer Eigenschaft nicht vom Hinzufügen einer Eigenschaft zu einer beliebigen 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

Nutzen Sie zur Verwendung dieser neuen Eigenschaft und zur Überprüfung der TextBox-Inhalte den System.Text.RegularExpressions-Namespace. Entsprechend den Beispielen für die Dokumentation kann ein neues RegEx-Objekt instanziert werden, indem man die RegularExpression-Eigenschaft im Konstruktor angibt. Dieses Objekt kann dann dazu verwendet werden, die Übereinstimmung von TextBox-Inhalten mit diesem Ausdruck zu überprüfen:

'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 ein Test des Steuerelements zu diesem Zeitpunkt möglich wäre, wäre erkennbar, dass der Code nicht korrekt ist, da er True zurückgibt, wenn er eine Übereinstimmung irgendwo înnerhalb der Zeichenfolge findet. Bei diesem Code würde ein regulärer Ausdruck, der 5-stellige Postleitzahlen finden soll, die ersten fünf Stellen in einer Zeichenfolge wie "23434fred" zurückgeben, obwohl darin zusätzlicher Text enthalten ist.

Tatsächlich soll jedoch getestet werden, ob Zeichenfolge und Ausdruck genau übereinstimmen. Nach Hinzufügen einer Überprüfung, die testet, ob die gefundene Übereinstimmung tatsächlich der gesamten Zeichenfolge entspricht, funktioniert diese Routine ordnungsgemäß;. Zugleich wurde dieser Test hier in einen einfachen Fehlerverarbeitungsblock gekleidet, so dass bei einer ungültigen RegularExpression-Eigenschaft der Wert False zurückgegeben wird:

'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 wunschgemäß; nur dann True zurück, wenn die Übereinstimmung gefunden wurde und für die gesamte Inhaltszeichenfolge zutrifft.

Schritt 3: Auß;erkraftsetzen von OnValidating

Windows Forms-Steuerelemente enthalten für die Überprüfung bereits eine Vielzahl von Methoden und Ereignissen. Daher erscheint es günstig, die neue RegularExpression-Überprüfung zum vorhandenen Modell hinzuzufügen, indem der TextBox-Inhalt durch die OnValidating-Methode überprüft wird. Diese Methode wird immer aufgerufen, wenn das Steuerelement den Fokus verliert und die CausesValidation-Eigenschaft des Steuerelements True ist. Damit dieses Steuerelement auch ohne Überprüfung nützlich ist (CausesValidation = False), wird eine schreibgeschützte Eigenschaft (Valid) hinzugefügt, die die direkte Überprüfung gültigen Inhalts unterstützt:

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

Wenn Sie den gesamten Code kombinieren, verfügen Sie über ein vollständiges Steuerelement für einen Test. Programmieren Sie das Steuerelementprojekt, und öffnen Sie dann das Testprojekt (eine zur Lösung hinzugefügte Windows-Anwendung), fügen Sie einen Verweis auf Ihr RegExTextBox-Projekt hinzu, und passen Sie die Toolbox an, so dass Ihr Steuerelement angezeigt wird. Nach Hinzufügen des neuen TextBox-Steuerelements zu Windows Form können Sie mit dem Standardeigenschaftenfenster die RegularExpression-Eigenschaft des Steuerelements bearbeiten. Hier finden Sie eine Auflistung einiger Beispiele zum Testen regulärer Ausdrücke:

Simple Zip Code sucht nach 5 numerischen Stellen: "\d{5}".
Date Format sucht nach dem Format MM/TT/JJJJ: "\d{1,2}\/\d{1,2}/\d{4}".

Es werden jedoch nicht die Werte überprüft, sondern nur das Format; 34/58/2341 wäre also eine korrekte Angabe, obwohl dies kein gültiger Wert für ein Datum ist.

Festlegen von Kategorien für Eigenschaften und Hinzufügen einer Toolboxbitmap
Wenn das Steuerelement in einem anderen Projekt verwendet wird, zeigen sich einige Details, die für den professionellen Anspruch geändert werden sollten. Zunächst werden die Eigenschaften am Ende der Eigenschaftenliste in der Kategorie Misc angezeigt, da dies das Standardverhalten ist, wenn keine bestimmte Kategorie festgelegt wurde.

Zuweisen von Eigenschaften zu Kategorien
Durch Hinzufügen eines Attributs zur Eigenschaftendefinition kann es problemlos in eine Kategorie eingeordnet oder im Fenster Eigenschaften vollkommen ausgeblendet werden. Für dieses Steuerelement sind zwei Eigenschaften vorhanden: Valid und RegularExpression. RegularExpression wird der Kategorie Behavior zugewiesen. Es besteht jedoch keine Einschränkung bei der Auswahl der Kategorie; sogar das Einrichten einer eigenen Kategorie ist möglich. Das System.ComponentModel.Category-Attribut wird zum Angeben der geeigneten Kategorie verwendet. Als Argument wird jedoch nur eine Zeichenfolge verwendet, so dass Sie auf die richtige Eingabe des Kategorienamens achten müssen:

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

Wird z. B. statt der US-amerikanischen die britische Schreibweise für Behavior eingegeben, ist im Fenster Eigenschaften anschließ;end eine neue Kategorie Behaviour vorhanden.

Bild01

Abbildung 1. Sie können einen beliebigen Namen für die Kategorie verwenden, die als Abschnitt im Fenster "Eigenschaften" angezeigt wird.

Trotz des korrekten Namens der Kategorie fehlt der neuen Eigenschaft in diesem Beispiel jedoch eine Beschreibung (die normalerweise im unteren Bereich des Fensters Eigenschaften angezeigt wird). Dies kann jedoch durch ein weiteres Attribut gelöst werden. Das System.ComponentModel.Description-Attribut nimmt eine Zeichenfolge als Argument an und zeigt dieses anschließ;end immer dann an, wenn die entsprechende Eigenschaft im Fenster Eigenschaften 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 während der Entwicklung nicht sehr hilfreich (das Attribut ist schreibgeschützt und anhand der Inhalte von TextBox berechnet). Daher sollte es im Eigenschaftenfenster der Kategorien nicht angezeigt werden. Zu diesem Zweck kann ein weiteres Attribut verwendet werden: Verwenden Sie das System.ComponentModel.Browsable-Attribut, das ein Boolesches Argument annimmt, um anzugeben, ob eine Eigenschaft im Fenster Eigenschaften angezeigt werden soll:

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

Hinzufügen einer Toolboxbitmap
Ein weiteres Problem beim Anzeigen des neuen Steuerelements besteht darin, dass kein Toolboxsymbol angegeben wurde. Daher wird das Standardsymbol für Steuerelemente verwendet. Wie die Eigenschaftenkategorien wird auch das Hinzufügen eines Toolboxsymbols mithilfe von Attributen durchgeführt: in diesem Fall mit dem ToolboxBitmap-Attribut. Dieses Attribut ermöglicht Ihnen, den Pfad zu einer Bitmapdatei (16x16) oder zu einem Toolboxbitmap anzugeben, das als Ressource in eine Assembly eingebettet ist. In diesem Beispiel wird ein Dateipfad angeben und ein in Paint gestaltetes Toolboxbitmap verwendet:

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

Beispiel 1b: Alternative Möglichkeit zum Hinzufügen einer Gültigkeitsprüfung mithilfe regulärer Ausdrücke

Durch das Entwickeln einer eigenen Version des TextBox-Steuerelements kann zusätzliche Funktionalität hinzugefügt werden. In .NET können Sie dieses Ergebnis jedoch auch mithilfe eines Extenderprovider-Objekts erreichen. Extenderprovider ermöglichen Ihnen das dynamische Hinzufügen von Eigenschaften zu anderen Steuerelementen auf ähnliche Art und Weise wie die Komponenten ErrorProvider oder ToolTip, die in Windows Forms bereits vorhanden sind. Mit einer solchen Komponente kann z. B. ausgewählt werden, dass die Eigenschaft RegularExpression zu allen TextBox-Steuerelementen im bearbeiteten Formular hinzugefügt wird und Überprüfungsdienste für alle Steuerelemente hinzugefügt werden, die bereits über einen Wert für die neue Eigenschaft verfügten. In diesem besonderen Fall unterscheidet sich das Ergebnis nur wenig von einer neu entwickelten TextBox-Variante, aber der Extenderprovideransatz funktioniert sehr gut für Funktionen, die gleichzeitig für alle Steuerelemente gelten sollen.

Gestalten eines eigenen Extenderproviders
Im Unterschied zu anderen Steuerelementen werden Extenderprovider durch Implementieren einer Schnittstelle und nicht durch Vererbung gebildet. Diese Schnittstelle (IExtenderProvider) definiert nur eine einzige Methode, CanExtend; aber in Verbindung mit unterschiedlichen Atttributen auf Klassenebene kann diese Methode die Funktionalität Ihres Providers beschreiben. Da der entwickelte Extenderprovider in der Windows-Forms-Umgebung bearbeitet werden soll, soll er entweder von Component oder von Control erben, und die IExtenderProvider-Schnittstelle soll implementiert werden:

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

Hinzufügen von Attributen für jede Eigenschaft
Nachdem Deklarieren Ihrer Klasse müssen Sie für jede Eigenschaft, die Sie anderen Steuerelementen zur Verfügung stellen möchten, ein Attribut hinzufügen. In diesem Fall soll die ValidationExpression-Eigenschaft hinzugefügt werden, die den regulären Ausdruck für jedes TextBox-Steuerelement enthält, sowie die Valid-Eigenschaft, die den Wert True oder False zurückgibt. Der Wert zeigt an, ob der aktuellen ValidationExpression-Eigenschaft entsprochen wird. Hinzugefügt werden muss das System.ComponentModel.ProvideProperty-Attribut, für dessen Konstruktor zwei Parameter erforderlich sind: der Name der neuen bereitzustellenden Eigenschaft und der Steuerelementtyp, zu dem die neue Eigenschaft hinzugefügt werden soll. In diesem Beispiel wurde also folgender Code hinzugefügt:

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

Anmerkung Die Erläuterung zu ProvideProperty ist möglicherweise verwirrend; so könnte z. B. angenommen werden, dass der zweite Parameter der Eigenschaftentyp ist. Fälschlicherweise wurde daher zunächst GetType(String) eingefügt. Richtig ist jedoch GetType(TextBox).

Entwickeln von Eigenschaftenroutinen
Für jede Eigenschaft, die Sie mit Attributen definieren, müssen auch Get- und Set-Routinen bereitgestellt werden, die das Anzeigen und Bearbeiten der Eigenschaft in allen anderen Steuerelementen ermöglichen. Diese Routinen sind nur über den Namen den bereitgestellten Eigenschaften zugeordnet:

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

In diesen Eigenschaftenroutinen müssen Sie die für jedes Steuerelement festgelegten Werte beibehalten, damit Sie nach halten können, welcher Eigenschaftenwert auf welches Steuerelement angewendet wurde. In diesem Code wurde daher NameValueCollection hinzugefügt, um die ValidationExpression-Eigenschaft für jedes Steuerelement zu protokollieren, das einen entsprechenden Wert festlegt. NameValueCollection ermöglicht Ihnen, eine Auflistung von Zeichenfolgenwerten zu Zeichenfolgenschlüsselwerten zuzuordnen. Damit gleicht die Auflistung einem Dictionary-Objekt, ist jedoch stark typgebunden und funktioniert nur mit Zeichenfolgen. Hier wurde ein ValidationExpression-Eintrag dem Namen des entsprechenden Steuerelements zugeordnet. Die Namen von Steuerelementen im selben Formular müssen eindeutig sein, um Konflikte zu vermeiden:

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 Wertes des regulären Ausdrucks wird ein Ereignishandler zu jedem Steuerelement hinzugefügt, dessen Wert nicht leer ist (das demnach überprüft werden soll). Dieser Ereignishandler wird eingerichtet, um das OnValidation-Ereignis jedes TextBox-Steuerelements aufzufangen. Dadurch kann ExtenderProvider den Inhalt von TextBox überprüfen, so wie dies von RegExTextBox durchgeführt wird (siehe Beispiel 1a). Schlägt die Überprüfung fehl, wird ein ExtenderProvider-Ereignis ausgelöst; dadurch können alle Überprüfungsfehler der zugeordneten Steuerelemente von einem Ereignishandler aufgefangen werden:

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 der Handler hier entfernt wird, wenn für ValidationExpression eine leere Zeichenfolge festgelegt wurde; da das Steuerelement nicht zu überprüfen ist, entfällt die Ereignisverarbeitung. Die Valid-Eigenschaft kann jetzt einfacher implementiert werden, da es sich um eine schreibgeschützte Eigenschaft handelt und für den Aufbau nur eine GetValid-Funktion erforderlich ist. Diese Funktion (die wiederum die IsValid-Funktion aufruft) überprüft den Inhalt eines bestimmten TextBox-Steuerelements mithilfe von ValidationExpression und gibt je nach vorhandener Übereinstimmung von Inhalt und Ausdruck True oder False zurück:

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
Es erscheint zwar logisch, die Implementierung von CanExtend anfangs zu programmieren, da die IExtenderProvider-Schnittstelle darauf angewiesen ist und Sie auch dazu auffordert. In diesem Beispiel wurde dieser Code dennoch zum Schluss geschrieben. Die Schlüsselaufgabe von CanExtend besteht darin, True bzw. False für jedes erhaltene Steuerelement zurückzugeben und dadurch anzugeben, ob die beiden neu entwickelten Eigenschaften auf das Steuerelement anzuwenden sind. Im Fall von ExtenderProvider sollen die beiden Eigenschaften auf jedes TextBox-Steuerelement angewendet werden. Daher wird hier einfach jeweils der Steuerelementtyp geprüft und mit True für TextBox oder False für andere Typen charakterisiert. Soll ein Steuerelement verarbeitet werden, wird zudem ein leerer Eintrag zu NameValueCollection hinzugefügt, der ggf. als Platzhalter für ValidationExpression dient:

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

Der letzte Schliff
Wie beim früheren Steuerelement können meist einige zusätzliche Attribute festgelegt oder zusätzlicher Code kann hinzugefügt werden, um die Nützlichkeit des Steuerelements oder die Professionalität zu erhöhen. In diesem Beispiel mit ExtenderProvider soll verhindert werden, dass Programmierer die Get- und Set-Routinen für die beiden neuen Eigenschaften unbeabsichtigt aufrufen. Dazu können die Routinen mithilfe von EditorBrowsableAttribute vor Microsoft Intellisense® verborgen werden:

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

Wenn Sie weitere Informationen zu ExtenderProvider erhalten möchten, können Sie sich die Anleitung für diesen Vorgang in der .NET Framework-Dokumentation anschauen; der Code für dieses Beispiel ist Bestandteil des Downloads für diesen Artikel. Der fertige ExtenderProvider wird mit regexRevisited bezeichnet und fügt als Bestandteil einer Windows Form die beiden Eigenschaften ValidationExpression und Valid zu jedem TextBox-Steuerelement hinzu. Das Ergebnis und die Programmierung sind dabei vergleichbar mit dem Ersetzen jeder TextBox durch den anfangs entwickelten benutzerdefinierten regulären Ausdruck TextBox, aber der gesamte Code liegt in einer Komponente vor.

Zusammenfassung

Beide Versionen des Beispiels führen zum selben Ergebnis - der Überprüfung von TextBox mithilfe regulärer Ausdrücke - jedoch auf unterschiedlichen Wegen. Es ist schwierig, eine der Methoden besonders zu empfehlen, da sie beide funktionsfähig sind und der Code sich nur geringfügig unterscheidet. Entscheidend ist vielmehr, dass es zwei Möglichkeiten gibt, Features zu Windows-Forms-Steuerelementen hinzuzufügen, und Sie die für Ihr jeweiliges Projekt geeignete Lösung auswählen können.