C# Regular Expressions

Regular Expressions are patterns used to match input text.

The .NET framework provides a regular expression engine that allows such matching.

Patterns consist of one or more characters, operators, and constructs.

If you are not familiar with regular expressions, you can read our Regular Expressions - Tutorial.

Defining Regular Expressions

The following lists various categories of characters, operators, and constructs used to define regular expressions.

• Character Escapes
• Character Classes
• Anchors
• Grouping Constructs
• Quantifiers
• Backreference Constructs
• Alternation Constructs
• Substitutions
• Miscellaneous Constructs

Character Escapes

The backslash character (\) in a regular expression indicates that the character following it is either a special character or should be interpreted literally.

The table below lists escape characters:

Character Classes

Character classes match any one character from a set of characters.

The table below lists character classes:

Anchors

Anchors or atomic zero-width assertions cause a match to succeed or fail depending on the current position in the string, but they do not cause the engine to advance through the string or consume characters.

The following table lists the anchors:

Grouping Constructs

Grouping constructs delineate the subexpressions of a regular expression and capture the substrings of an input string.

This part is difficult to understand and can be aided by reading *, * for better understanding.

The following table lists the grouping constructs:

Example

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "1851 1999 1950 1905 2003";
      string pattern = @"(?<=19)\d{2}\b";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}

Quantifiers

Quantifiers specify how many instances of the previous element (which can be a character, a group, or a character class) must be present in the input string for a match to occur. Quantifiers include the language elements listed in the table below.

The table lists the quantifiers:

Backreference Constructs

Backreferences allow you to specify previously matched subexpressions in the same regular expression.

The table lists the backreference constructs:

Alternation Constructs

Alternation constructs modify the regular expression to enable either/or matching.

The table lists the alternation constructs:

| Alternation Construct | Description | Pattern | Matches | | --- | --- | --- | --- | This is an English translation of the Chinese text.

Alternation

Alternation is a feature in regular expressions that allows matching any one element separated by a vertical bar (|).

Substitution

Substitution is a regular expression used in the replacement pattern.

The following table lists characters used for substitution:

Miscellaneous Constructs

The following table lists various miscellaneous constructs:

Regex Class

The Regex class is used to represent a regular expression.

The following table lists some commonly used methods in the Regex class:

string input, string replacement ) Replaces all strings that match a specified regular expression pattern in the input string with the specified replacement string. | 6 | public string[] Split( string input ) Splits the input string into an array of substrings at the positions defined by the regular expression pattern specified in the Regex constructor.

To view the complete list of properties for the Regex class, please refer to Microsoft's C# documentation.

Example 1

The following example matches words that start with 'S':

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
    class Program
    {
        private static void showMatch(string text, string expr)
        {
            Console.WriteLine("The Expression: " + expr);
            MatchCollection mc = Regex.Matches(text, expr);
            foreach (Match m in mc)
            {
                Console.WriteLine(m);
            }
        }
        static void Main(string[] args)
        {
            string str = "A Thousand Splendid Suns";

            Console.WriteLine("Matching words that start with 'S': ");
            showMatch(str, @"\bS\S*");
            Console.ReadKey();
        }
    }
}

When the above code is compiled and executed, it produces the following result:

Matching words that start with 'S':
The Expression: \bS\S*
Splendid
Suns

Example 2

The following example matches words that start with 'm' and end with 'e':

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
    class Program
    {
        private static void showMatch(string text, string expr)
        {
            Console.WriteLine("The Expression: " + expr);
            MatchCollection mc = Regex.Matches(text, expr);
            foreach (Match m in mc)
            {
                Console.WriteLine(m);
            }
        }
        static void Main(string[] args)
        {
            string str = "make maze and manage to measure it";

            Console.WriteLine("Matching words start with 'm' and ends with 'e':");
            showMatch(str, @"\bm\S*e\b");
            Console.ReadKey();
        }
    }
}

When the above code is compiled and executed, it produces the following result:

Matching words start with 'm' and ends with 'e':
The Expression: \bm\S*e\b
make
maze
manage
measure

Example 3

The following example replaces extra spaces:

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            string input = "The    quick   brown   fox";
            string pattern = "\\s+";
            string replacement = " ";
            Regex rgx = new Regex(pattern);
            string result = rgx.Replace(input, replacement);

            Console.WriteLine("Original String: {0}", input);
            Console.WriteLine("Replacement String: {0}", result);
            Console.ReadKey();
        }
    }
}

When the above code is compiled and executed, it produces the following result:

Original String: The    quick   brown   fox
Replacement String: The quick brown fox

string input = "Hello   World   ";
string pattern = "\\s+";
string replacement = " ";
Regex rgx = new Regex(pattern);
string result = rgx.Replace(input, replacement);

Console.WriteLine("Original String: {0}", input);
Console.WriteLine("Replacement String: {0}", result);
Console.ReadKey();
}
}

When the above code is compiled and executed, it produces the following result:

Original String: Hello   World   
Replacement String: Hello World