Extend the Textbox Control to Validate Against Regular Expressions

using System;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Text.RegularExpressions;
namespace RegExControls
{
    public partial class RegExTextBox : TextBox
    {

#region "Declarations"
        private string mRegularExpression;
#endregion

#region "Properties"
    public string Regular_Expression
    {
        get
        {
            return mRegularExpression;
        }
        set
        {
            mRegularExpression = value;
        }
    }
#endregion

#region "Constructor"
    public RegExTextBox()
    {
        InitializeComponent();
    }
#endregion

#region "Methods"
    protected override void OnPaint(PaintEventArgs pe)
    {
        // TODO: Add custom paint code here
        // Calling the base class OnPaint
        base.OnPaint(pe);
    }
    public bool ValidateControl()
    {
        string TextToValidate;
        Regex expression;
        try
        {
            TextToValidate = this.Text;
            expression = new Regex(Regular_Expression);
        }
        catch
        {
            return false;
        }
        // test text with expression
        if (expression.IsMatch(TextToValidate))
        {
            return true;
        }
        else
        {
            // no match
            return false;
        }
    }
#endregion

This concluded the discussion of the custom text box control. The next section of this document will provide an example of a win forms application using several of the controls to validate user input against regular expressions.

Project 2 - TestRegExControls

The Code for Form1:

The project contains only a single form. The form contains a group box which contains five labels and five of the custom regular expression text box controls.

Each of the labels describes the input required for the text box and each of the regular expression text box controls contains a regular expression used to test the control's text property.

Below the group box are two button controls, one is used to validate the form's input and the other is used to validate and then exit the form (by closing the application). The validate button calls a validate function which will test each regular expression text box and fail on any detected invalid entries. The submit button does the same thing but allows the application to close only if none of the regular expression tests fails.

In addition to the visible content, the form also has an associate error provider. The error provider is used to mark any controls that fail validation.

Figure 3. Form1 in the IDE Designer

The control's regular expression may be set at either run or design time; the expression must not contain the '^' at the start or the '$' at end of the string.

Figure 4. Regular Expression Set at Design Time

The Form1 class is initialized with the defaults:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace TestRegExControls
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

After the class is initiated, a region called "Handle Validations" is defined and for each of the regular expression text boxes, the validating event is handled; the first one looks like this:

#region "Handle Validations"
    private void regExTextBox1_Validating(object sender, CancelEventArgs e)
    {
        // test the control for invalid input
        if (regExTextBox1.ValidateControl() == false)
        {
            // display error if user input is invalid
            errorProvider1.SetError(regExTextBox1, "Invalid SSN (e.g., 123-22-3344)");
        }
        else
        {
            // set error message to nothing if control
            // passes validation
            errorProvider1.SetError(regExTextBox1, "");
        }
    }

All five of the validating event handlers work essentially the same but show different text when the user hovers over the error indication. The validating event handler calls the control's ValidateControl method which validates the control's text property against its regular expression. If the validate control method returns a false, the error provider is used to set the control's error and the text for the error provider is set. In the example provided above, the control is validating the text against a regular expression used to validate a social security number; if the validate control function returns a false, the user is shown the correct format for a valid entry.

If the control passes validations, the error provider's text is set to an empty string and as such the error provider's error indication will not be shown to the user.

The next method provided in this region is used to validate all of the controls; this method is called by the validate button and the submit button to check the form for invalid entries:

private bool PerformFormValidation()
{
    // check for errors to set return value
    if (regExTextBox1.ValidateControl() == false)
    {
        return false;
    }
    if (regExTextBox2.ValidateControl() == false)
    {
        return false;
    }
    if (regExTextBox3.ValidateControl() == false)
    {
        return false;
    }
    if (regExTextBox4.ValidateControl() == false)
    {
        return false;
    }
    if (regExTextBox5.ValidateControl() == false)
    {
        return false;
    }
    // if it has not found an invalid control, return with true
    return true;
}

The last code in the application is used to handle the button event clicks for the validate and submit buttons. The submit (btnExit) button's click event handler is as follows:

private void btnExit_Click(object sender, EventArgs e)
{
    // test the form before allowing the user to close it
    bool valResult = PerformFormValidation();
    if (valResult == true)
        Application.Exit();
    else
        MessageBox.Show("Fix errors on this page prior to closing form");
}

This click event handler calls the PerformFormValidation method; the returned value is used to set a boolean and the boolean is then evaluated and if true, the application exists, if not the user is shown a message instructing them to fix the errors before closing the form.

The validate button's click event handler works essentially the same way but it only used to tell the user whether or not the form contains invalid entries:

private void btnValidate_Click(object sender, EventArgs e)
{
    // test the form
    bool valResult = PerformFormValidation();
    if (valResult == true)
        MessageBox.Show("All form fields are valid");
    else
        MessageBox.Show("This form contains errors");
}

That is all there is to the test application's Form1 class code.

Summary.

This article demonstrates an approach to validating user input against a regular expression in a win forms application. The approach is based upon extending the standard win forms text box control to allow storage of a regular expression and to provide the means to validate the text contained in the control against the pattern defined in the regular expression. The article further described how the extended text box control could be used in conjunction with an error provider to display meaningful information to the user if the control's validation function indicates a mismatch between the control's text and the regular expression provided with the control.