C# Regular Expressions

Regular expressions It is a pattern that matches input text.

.Net framework provides a regular expression engine that allows this kind of matching.

A pattern is composed of one or more characters, operators, and structures.

Defining regular expressions

The following lists various characters, operators, and structures used to define regular expressions.

• Character escaping

• Character class

• Locators

• Group construction

• Quantifiers

• Backreference construction

• Alternative construction

• Replacement

• Miscellaneous constructions

Character escaping

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

The following table lists escape characters:

Character class

Character classes match any character in a set of characters.

The following table lists character classes:

Locators

Locators or atomic zero-width assertions can make a match successful or fail, depending on the current position in the string, but they will not advance the engine or use characters in the string.

The table below lists the locators:

Group construction

Group constructions describe the subexpressions of regular expressions, which are usually used to capture substrings of the input string.

The following table lists the group constructions:

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};
　　　　　　foreach (Match match in Regex.Matches(input, pattern))
　　　　　　　　　Console.WriteLine(match.Value);
　　　}
}

Run example »

Quantifiers

Quantifiers specify how many instances of the preceding element (which can be a character, group, or character class) must exist in the input string to produce a match. Quantifiers include the language elements listed in the table.

The following table lists the quantifiers:

Backreference construction

Backreference allows to identify previously matched subexpressions within the same regular expression.

The following table lists the backreference constructions:

Alternative construction

Alternative construction is used to modify the regular expression to enable either/or match.

The following table lists the alternative constructions:

Replacement

Replacement is the regular expression used in the replacement pattern.

The following table lists characters used for replacement:

Miscellaneous constructions

The following table lists various miscellaneous constructions:

Regex Class

The Regex class is used to represent a regular expression.

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

For a complete list of properties of the Regex class, please refer to Microsoft's C# documentation.

Example 1

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

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

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 end with 'e':");
　　　　　　　　　showMatch(str, @"\bm\S*e\b
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

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

using System;
using System.Text.RegularExpressions;
namespace RegExApplication
{
　　　class Program
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　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();
　　　　　　}
　　　}
}

Original String: Hello     World　　　
Replacement String: Hello World