This appendix summarizes methods of creating and using regular expressions.

Creating Regular Expressions

This section describes the characters you can use to define regular expressions.

Character Escapes

Character escapes are character sequences that match special characters. The following table summarizes useful character escapes.

Character Classes

A character class matches one of a set of characters. The following table summarizes useful character class constructs.

Anchors

An anchor matches a part of the input without reading any characters from it. The following table summarizes useful anchors.

Regular Expression Options

You can specify regular expression options in three ways:

• Pass a RegexOptions parameter to a Regex object’s constructor or to a pattern matching methods such as IsMatch.
• Use the syntax (?options) to include inline options within a regular expression. Options can include i, m, n, s, and x. If the list begins with a – character, the following options are turned off.
• Use the syntax (?options:subexpression) within a regular expression. In this case, options is as before and subexpression is the part of a regular expression during which the options should apply.

The following table lists the available options.

Grouping Constructs

Grouping constructs let you define capture groups within matching pieces of a string. Parentheses create groups. There are several kinds of groups, some of which are fairly specialized and confusing. The two most common are numbered and named groups.

To create a numbered group, simply enclose a subexpression in parentheses as in (w)1. The w in this expression matches a single word character. The parentheses mean this character is in the first numbered group. The 1 that follows matches whatever is in group 1, in this case a single word character. That means this expression matches a single word character that appears twice.

To create a named group, use the syntax (?<name>subexpression) where name is the name you want to assign to the group and subexpression is a subexpression. Use the syntax k<name> to refer to a named group.

For example, the expression (?<twice>w)k<twice> is equivalent to the previous expression (w)1 except the group is named twice.

Quantifiers

A quantifier makes the regular expression engine match the previous element a certain number of times. The following table describes regular expression quantifiers.

If you follow one of these with ?, the pattern matches the preceding expression as few times as possible. For example, the pattern BO+ matches B followed by 1 or more Os, so it would match the BOO in BOOK. The pattern BO+? also matches B followed by 1 or more Os, but it matches as few Os as possible, so it would match only the BO in BOOK.

Alternation Constructs

An alternation construct uses the | character to allow a pattern to match either of two subexpressions. For example, the expression ^(true|yes)$ matches either true or yes.

Sample Regular Expressions

The following list shows several useful regular expressions.

• ^d{3}-d{4}$—Matches a simple 7-digit phone number.
• ^[2-9][0-9]{2}-d{4}$—Matches a 7-digit phone number more precisely.
• ^[2-9][0-8]d-[2-9][0-9]{2}-d{4}$—Matches a 10-digit U.S. phone number with the format NPA-NXX-XXXX where N is a digit 2-9, P is a digit 0-8, A is any digit 0-9, and X is any digit 0-9.
• ^([2-9][0-8]d-)?[2-9][0-9]{2}-d{4}$—Matches a U.S. phone number with an optional area code such as 202-234-5678 or 234-5678.
• ^d{5}(-d{4})?$—Matches a U.S. ZIP code with optional +4 as in 12345 or 12345-6789.
• ^[A-Z]d[A-Z] d[A-Z]d$—Matches a Canadian postal code with the format A1A 1A1 where A is any capital letter and 1 is any digit.
• ^[a-zA-Z0-9._-]{3,16}$—Matches a username with 3 to 16 characters that can be dashes, letters, digits, periods, or underscores.
• ^[a-zA-Z][a-zA-Z0-9._-]{2,15}$—Matches a username that includes a letter followed by 2 to 15 dashes, letters, digits, periods, or underscores.
• ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9._%+-]+.[a-zA-Z]{2,4}$—Matches an e-mail address. (This pattern isn’t perfect but it matches most valid e-mail addresses.)
• ^[+-]?[a-fA-Z0-9]{3}$—Matches a 3-digit hexadecimal value with an optional sign + or – as in +A1F.
• ^(https?://)?([w-]+.)+[w-]+$—Matches a top-level HTTP web address such as http://www.csharphelper.com. (This pattern isn’t perfect. In particular it doesn’t validate the final part of the domain, so it would match www.something.whatever.)
• ^(https?://)?([w-]+.)+[w-]+(/(([w-]+)(.[w-]+)*)*)*$—Matches an HTTP web URI such as http://www.csharphelper.com/howto_index.html. (Again this pattern isn’t perfect and doesn’t handle some more advanced URLs such as those that include =, ?, and # characters, but it does handle many typical URLs.)

Using Regular Expressions

The Regex class provides objects that you can use to work with regular expressions. The following table summarizes the Regex class’s most useful methods.

The Regex class also provides static versions of these methods that take both a string to examine and a regular expression as parameters.

The following sections summarize how to use the Regex class to perform common regular expression tasks.

Matching Patterns

The Regex class’s static IsMatch method gives you an easy way to determine whether a string satisfies a regular expression. The following code tests whether the text in variable text matches the pattern in variable pattern.

if (Regex.IsMatch(text, pattern))
    result = "Match";
else
    result = "No match";

Finding Matches

The Regex class’s Matches method can give you information about places where a string matches a regular expression. The following code locates pieces of the string in variable text that match the pattern in variable pattern.

// Make the regex object.
Regex regex = new Regex(pattern);

// Find the matches.
foreach (Match match in regex.Matches(text))
{
    // Display the match.
    Console.WriteLine(match.Value);
}

The following table lists the Match class’s most useful properties.

Making Replacements

The Regex class’s static Replace method enables you to replace the parts of a string that match a pattern with a new string. The following code examines the string in variable text, locates pieces that match the pattern in variable pattern, and replaces them with the text in variable replaceWith.

string result = Regex.Replace(
    text,
    pattern,
    replaceWith);

For example, the following code replaces vowels in a string with question marks.

string result =
    Regex.Replace("The quick brown fox jumps over the lazy dog", "[aeiou]", "?")

The following text shows the result.

Th? q??ck br?wn f?x j?mps ?v?r th? l?zy d?g