C# regular expressions

Regular expression is a pattern that matches input text. The .Net framework provides a regular expression engine that allows such matching. A pattern consists of one or more characters, operators, and structures.

Define regular expressions

Listed below are the various categories of characters, operators, and structures used to define regular expressions.

• Character escape

• Character class

• Anchor point

• Group construction

• Qualifier

• Backreference construction

• Alternate Construction

• Replacement

• Miscellaneous construction

Character escape

Regular The backslash character (\) in an expression indicates that the character that follows it is a special character or that the character should be interpreted literally.

The following table lists the escape characters:

Character class

Character class matches any one character in a set of characters.

The following table lists the character classes:

Anchors

Anchor points 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 in the string or use characters.

The following table lists the anchor points:

Group construction

The grouping construction describes a subexpression of a regular expression, usually used to capture substrings of the input string.

The following table lists the grouping constructs:

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);
   }
}

Qualifier

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

The following table lists the qualifiers:

Backreference Construction

Backreference allows subsequent identification of previously matched subexpressions within the same regular expression.

The following table lists the backreference constructs:

Alternate constructs are used to modify regular expressions to enable either/or matching.

The following table lists the alternate constructs:

Replacement

Replacement is the regular expression used in the replacement pattern.

The following table lists the characters used for substitution:

Miscellaneous construction

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:

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

Example 1

The following example matches words starting 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 results:

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

Example 2

The following example matches words starting with 'm' and ending 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 Will produce the following results:

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 the extra spaces:

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();
      }
   }
}

When the above code is compiled and executed, it will produce the following Result:

Original String: Hello   World   
Replacement String: Hello World