When a regular expression is constructed, compilation flags can be provided to modify its behavior. In .NET, these flags are specified as a bit mask using members of the System.Text.RegularExpressions.RegexOptions enumeration. Table 7-13 summarizes the more useful flags alongside their Java equivalents.

Given that all regular expressions must be compiled, the name of this flag is a little confusing. However, a regular expression is normally compiled to an intermediate form that is interpreted by the regular expressions engine at run time. The RegexOptions.Compiled flag forces compilation of the regular expression down to MSIL code. This results in faster execution but slower loading.

Use the Compiled flag sparingly. The common language runtime (CLR) cannot unload generated MSIL code without unloading the entire application domain. Using the Compiled flag frequently will result in compiled regular expressions consuming system resources.

If we are concerned only with determining whether an input text contains an occurrence of the regular expression, we use the Regex.IsMatch method. This returns a bool indicating whether a match was found but does not give access to any further match details. For example:

// Create an input text string
string input = "author = Allen Jones, author = Adam Freeman";

// Compile regular expression to find "name = value" pairs
Regex r = new Regex(@"w+s*=s*.*");

// Test for a match
bool b = r.IsMatch(input);        // b = true;

If we need access to the number and location of matches found, two approaches are available. First, the Regex.Match method returns an instance of Match, which represents the result of a single match operation. The Match.Success property signals whether the match was successful. Match.NextMatch returns a new Match instance representing the next match in the input text. The use of Regex.Match, Match.Success, and Match.NextMatch enables the programmer to sequentially step through the matches in an input text. This is similar to the Java model of using repeated calls to Matcher.find.

Alternatively, the Regex.Matches method returns an instance of MatchCollection containing an enumerable set of Match instances representing all matches in the input text. Either the MatchCollection indexer or MatchCollection.GetEnumerator can be used to iterate across the set of Match instances. We demonstrate both the use of Match.NextMatch and MatchCollection.GetEnumerator in the following example:

// Create an input text string
string input = "author = Allen Jones 
 author = Adam Freeman";

// Compile regular expression to find "name = value" pairs
Regex r = new Regex(@"w+s*=s*.*");

// Using Match.NextMatch() to process all matches
Match m = r.Match(input);
while (m.Success) {
    System.Console.WriteLine(m.Value);
    m = m.NextMatch();
}

// Using MatchCollection to process all matches
MatchCollection mc = r.Matches(input);
foreach (Match x in mc) {
    System.Console.WriteLine(x.Value);
}

Both loops in this example produce the same output, resulting in the following display:

author = Allen Jones
author = Adam Freeman
author = Allen Jones
author = Adam Freeman

The Match instance provides access to details of the match, including the results of each capture group and subexpression capture. The members of the Match and MatchCollection classes are summarized in Table 7-14 and Table 7-15.

The Match class is derived from Group, which in turn is derived from Capture. The Capture and Group instances retrievable through the Match class represent the specific group and subexpression matches that constitute a successful match. The CaptureCollection and GroupCollection classes provide the same functionality for the Group and Capture objects that the MatchCollection provides for the Match object. The members of Capture, Group, CaptureCollection, and GroupCollection are similar to those of Match and MatchCollection, discussed previously, and will not be covered in detail. Refer to the .NET documentation for complete details.

There are two approaches to substring replacement. First, the Regex.Replace method replaces any matches in an input text with a specified substitution string. Overloaded versions of Replace allow the specification of a maximum number of replacements to make and a search starting position in the input text.

Alternatively, an overloaded version of the Replace method takes a MatchEvaluator delegate as an argument. For each match that occurs, the delegate is invoked. The delegate is passed a Match instance that represents the current match. The delegate implements any decision-making logic required and returns a string that will be used as the substitution string.

The MatchEvaluator delegate has the following signature:

public delegate string MatchEvaluator(Match match);

The following example demonstrates both of these approaches:

using System;
using System.Text.RegularExpressions;

public class REReplace {

    // Declare MatchEvaluator delegate target method
    public static string MyEval(Match match) {
        switch (match.Value) {
            case "fox" : return "cow";
            case "dog" : return "pig";
            default : return match.Value;
        }
    }

    public static void Main() {

        // Create an input text
        string text =
            "the quick red fox jumped over the lazy brown dog.";
        // Perform a complete replacement of "the" with "a"
        Regex r = new Regex("the");
        System.Console.WriteLine(r.Replace(text, "a"));

        // Perform evaluated replacement of any word that
        // has the lower case letter "o" in, but not at
        // the beginning or end.
        r = new Regex(@"w+ow+");
        System.Console.WriteLine(r.Replace(text,
            new MatchEvaluator(REReplace.MyEval)));
    }
}

The output from the example with the replacements highlighted is

a  quick red fox jumped over a lazy brown dog
the quick red cow jumped over the lazy brown pig

Note that in the second line of output, although brown matches our regular expression, it is not replaced based on the logic in the MyEval delegate.

The splitting of an input text around a regular expression is handled using the Regex.Split method. Split takes an input string and an optional integer that sets the maximum number of splits to perform and returns a string array containing the extracted substrings. This is demonstrated in the following code fragment:

// Split the String at the first two occurrences of the regex "and"
string input = "bill and bob and betty and dave";
Regex r = new Regex(" and ");
string[] result = r.Split(input, 3);
foreach (string s in result) {
    System.Console.WriteLine(s);
}

The code produces the following output:

bill
bob
betty and dave

Note that we specified a maximum of three splits in Regex.Split, so betty and dave remains unsplit.