Regular Expressions in C# or Visual Basic

Developers frequently need to process text.  A developer might need to process input from a user to remove or replace special characters or process text that has been output from a legacy application to integrate an application with an existing system. For decades, UNIX and Perl developers have used a complex but efficient technique for processing text: regular expressions.

A regular expression is a set of characters that can be compared to a string to determine whether the string meets specified format requirements and supports dozens of special characters and operators. You also can use regular expressions to extract portions of the text or to replace text. To make decisions based on text, you can create regular expressions that match strings consisting entirely of integers — strings that contain only lowercase letters, or strings that can match hexadecimal input. You can also extract key portions of a block of text, which you could use to extract the state from a user’s address or image links from an HTML page. Finally, you can update text using regular expressions to change the format of text or remove invalid characters. This article focuses on the most fundamental use of regular expressions — matching and validating strings.

The most commonly used regular expressions are: “^” to match the beginning of a string, “$” to match the end of a string, “?” to make a character optional, “.” to match any character and “*” to match a repeated character.

To be able to test regular expressions, create a Visual Basic or C# console app named TestRegExp that accepts two strings as input and determines whether the first string (a regular expression) matches the second string. The following console application, which uses the System.Text.RegularExpressions namespace, performs this check using the static System.Text.RegularExpressions.Regex.IsMatch method and displays the results to the console:

' VB
Imports System.Text.RegularExpressions
 
Namespace TestRegExp
    Class Class1
        <STAThread> _
        Shared  Sub Main(ByVal args() As String)
            If Regex.IsMatch(args(1),args(0)) then
                Console.WriteLine  (“Input matches regular expression.”)
            Else
                Console.WriteLine (“Input DOES NOT match regular expression.”)
            End If
        End Sub
    End Class
End Namespace

// C#
using System.Text.RegularExpressions;

namespace TestRegExp
{
    class: Class1
    {
         [STAThread]
        static void Main(string[] args)
        {
            If (Regex.IsMatch(args[1], args[0]))
                Console.WriteLine  (“Input matches regular expression.”);
            Else
                Console.WriteLine(“Input DOES NOT match regular expression.”);
        }
    }
}

Next, run the application by determining whether the regular expression “^\d{5}$” matches the string “12345” or “1234.” The regular expression won’t make sense now, but it will by the end of the article. Your output should resemble the following:

C:\>TestRegExp ^\d{5}$ 1234
Input DOES NOT match regular expression.

C:\>TestRegExp ^\d{5}$ 12345
Input matches regular expression.

As this code demonstrates, the Regex.IsMatch method compares a regular expression to a string and returns true if the string matches the regular expression. In this example, “^\d{5}$” means that the string must be exactly five numeric digits. As shown in Figure 1, the carat (“^”) represents the start of the string, “\d” means numeric digits, “{5}” indicates five sequential numeric digits, and “$” represents the end of the string.


Analysis of a regular expression

If you remove the first character from the regular expression, you drastically change the meaning of the pattern. The regular expression “\d{5}$” will still match valid five-digit numbers, such as “12345.” However, it also will match the input string “abcd12345” or “drop table customers —12345”. In fact, the modified regular expression will match any input string that ends in any five-digit number. When validating input, always begin regular expressions with a “^” character and end them with “$.” This system ensures that input exactly matches the specified regular expression and does not merely contain matching input.

Table 1 lists other characters you can use to make your regular expression match a specific location in a string.

Characters that Match Locations in Strings

Notice that regular expressions are case-sensitive, even in Visual Basic. Often, capitalized characters have the opposite meaning of lowercase characters.

The simplest use of regular expressions is to determine whether a string matches a pattern. For example, the regular expression “abc” matches the strings “abc”, “abcde”, or “yzabc” because each of the strings contains the regular expression. No wild cards are necessary.

You can also use regular expressions to match repeated characters. The “*” symbol matches the preceding character zero or more times. For example, “to*n” matches “ton”, “tooon”, or “tn.” The “+” symbol works similarly, but it must match one or more times. For example, “to+n” matches “ton” or “tooon”, but not “tn”.

To match a specific number of repeated characters, use “{n}” where n is a digit. For example, “to{3}” matches “tooon” but not “ton” or “tn”. To match a range of repeated characters, use “{min,max}”. For example, “to{1,3}n” matches “ton” or “tooon” but not “tn” or “toooon”. To specify only a minimum, leave the second number blank. For example, “to{3,}n” requires 3 or more consecutive “o” characters.

To make a character optional, use the “?” symbol. For example, “to?n” matches “ton” or “tn”, but not “tooon”. To match any single character, use “.”. For example, “to.n” matches “totn” or “tojn” but not “ton” or “tn”.

To match one of several characters, use brackets. For example, “to[ro]n” would match “toon” or “torn”, but not “ton” or “toron”. You can also match a range of characters. For example, “to[o-r]n” matches “toon”, “topn”, “toqn”, or “torn”, but would not match “toan” or “toyn”.

Table 2 summarizes the regular expression characters used to match multiple characters or a range of characters.

Wild card and Character Ranges Used in Regular Expressions

Regular expressions also provide special characters to represent common character ranges. You could use “[0-9]” to match any numeric digit, or you can use “\d”. Similarly, “\D” matches any non-numeric digit. Use “\s” to match any white-space character, and use “\S” to match any non-white-space character. Table 3 summarizes these characters.

Characters Used in Regular Expressions

To match a group of characters, surround the characters with parentheses. For example, “foo(loo){1,3}hoo” would match “fooloohoo” and “fooloolooloohoo” but not “foohoo” or “foololohoo”. Similarly, “foo(loo|roo|)hoo” would match either “fooloohoo” or “fooroohoo”. You can apply any wild card or other special character to a group of characters.

You also can name groups to refer to the matched data later. To name a group, use the format “(?<name>pattern)”. For example, the regular expression “foo(?<mid>loo|roo)hoo” would match “fooloohoo”. Later, you could reference the group “mid” to retrieve “loo”. If you used the same regular expression to match “fooroohoo”, “mid” would contain “roo”.

Regular expressions can be used to match complex input patterns, too. The following regular expression matches e-mail addresses:

^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))
([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$