C# regex

A Regex (Regular Expression) is a pattern that is used to check whether a given string matches that pattern. For example,

// a regex pattern
"^m.t$"

The above pattern indicates a three-letter string where,

• ^ - indicates string starts with m
• . - indicates any one letter or character
• $ - indicates string ends with t

For example strings like "mat" and "mit" match the above regex pattern. However, strings like "mom" and "magnet" don't match because these strings are not 3 letter words that start with m and end with t.

We will learn about regular expressions in detail below.

C# Regex Class

C# provides a class called Regex to use features of a regular expression. Before using the Regex class, we need to use System.Text.RegularExpression namespace.

Then, we need to create an instance of the Regex class:

Regex regexName = new Regex(pattern);

Here,

• regexName - name of the instance of the Regex class
• pattern - regular expression pattern that we want to pass

Example: C# Regex

using System;
using System.Text.RegularExpressions;
class Program
{
    // a regular expression pattern for a five-letter word
    // that starts with "a" and ends with "e"  
    static string pattern = "^a...e$";

    static void Main()
    {
        // create an instance of Regex class and
        //  pass the regular expression (i.e pattern)
        Regex rg = new Regex(pattern);

        // IsMatch() returns true if "apple" matches the regular expression 
        if (rg.IsMatch("apple"))
        {
            Console.WriteLine("String matches the pattern");
        }
        else
        {
            Console.WriteLine("String doesn't match the pattern");
        }
    }
}

Output

String matches the pattern

In the above example, we have checked whether the string "apple" matches the defined regular expression pattern.

The pattern "^a...e$" indicates any five-letter string starting with a and ending with e. Here, the IsMatch() method returns True if the string that we pass matches the regex pattern.

If we pass another string for example - "apache", it doesn't match with pattern because "apache" has more than three letters between a and e.

string pattern = "^a...e$";

How Regex Works?

In C#, there is an engine called regex engine which internally checks the regex pattern in the given string.

In the above image, the regex engine process the two inputs :

• ^a…e$ - the regex pattern
• "apple" - the given string that we want to match

When the regex pattern is passed into the engine, it is interpreted. The engine is then responsible for search operation i.e, matching the regex expression pattern with the input string.

Metacharacters

To specify regular expressions, metacharacters are used. Metacharacters are characters that are interpreted in a special way by a regex engine.

Some of the basic metacharacters are:

• [] - square bracket
• . - period
• ^ - caret
• $ - dollar
• * - star
• + - plus
• ? - question mark
• {} - braces
• () - parenthesis
• | - alternation

[]- Square brackets

[] specifies a set of characters you wish to match.

For example,

• regex - [abc]
• matches - any string that contains any of the a, b, or c.

Let's check if the following string examples match the regex pattern [abc].

. - Period

A period specifies any single character (except newline '\n').

For example,

• regex - …
• matches - strings containing three letters

Let's check if the following string examples match the regex pattern …

^ - Caret

The caret symbol ^ specifies the string starts with a certain character.

For example,

• regex - ^m
• matches - string starting with the letter "m"

Let's check if the following string examples match the regex pattern ^m.

$ - Dollar

The dollar symbol $ specifies the string ends with a certain character.

For example,

• regex - y$
• matches - string ending with the letter "y"

Let's check if the following string examples match the regex pattern y$.

* - Star

The star symbol * matches zero or more occurrences of the pattern left to it.

For example,

• regex - ca*t
• matches - string that has any number[including zero] of a in between c and t

Let's check if the following string examples match the regex pattern ca*t.

+ - Plus

The plus symbol + matches one or more occurrences of the pattern left to it.

For example,

• regex - ma+t
• matches - string that has one or more numbers of a in between m and t

Let's check if the following string examples match the regex pattern ma+t.

? - Question Mark

The question mark symbol ? matches zero or one occurrence of the pattern left to it.

For example,

• regex - ma?n
• matches - string that has one or zero number of a in between m and n

Let's check if the following string examples match the regex pattern ma?n.

{} - Braces

The braces symbol {} is used to specify the range of repetitions of the pattern left to it.

For example,

• regex - a{2,3}
• matches - string that has at least 2 a's and at most 3 a's left to it

Let's check if the following string examples match the regex pattern a{2,3}.

| - Alternation

The vertical bar | is used as or operator.

For example,

• regex - a|b
• matches - string that has either a or b

Let's check if the following string examples match the regex pattern a|b.

() - Parenthesis

Parenthesis () is used to group sub-patterns.

For example,

• regex - (a|b|c)xz
• matches - any string that has either a or b or c followed by xz

Let's check if the following string examples match the regex pattern (a|b|c)xz.

Special Sequences

Special sequences make commonly used patterns easier to write.

Some of the special sequences are:

\A - Matches if the specified characters are at the start of a string.

Let's check if the following string examples match the regex pattern \Athe.

\b - Matches if the specified characters are at the beginning or end of a word.

For example,

• regex - \bfoo
• matches - any word in a string that has foo at the beginning.

Let's check if the following string examples match the regex pattern \bfoo.

Take another regex for example,

• regex - foo\b
• matches - any word in a string that has foo at the end.

Let's check if the following string examples match the regex pattern foo\b.

\B - Matches if the specified characters are not at the beginning or end of a word.

For example,

• regex - \Bfoo
• matches - any word in a string that doesn't have foo at the beginning.

Take another regex for example,

• regex - foo\B
• matches - any word in a string that doesn't have foo at the end

Let's check if the following string examples match the regex pattern foo\B.

\d - Matches any decimal digit. Equivalent to [0-9]

Let's check if the following string examples match the regex pattern \d.

\D - Matches any non-decimal digit. Equivalent to [^0-9]

Let's check if the following string examples match the regex pattern \D.

\s - Matches where a string contains any whitespace character. Equivalent to [ \t\n\r\f\v].

Let's check if the following string examples match the regex pattern \s.

\S - Matches where a string contains any non-whitespace character. Equivalent to [^ \t\n\r\f\v].

Let's check if the following string examples match the regex pattern \S.

\w - Matches any alphanumeric character (digits and alphabets). Equivalent to [a-zA-Z0-9_].

Let's check if the following string examples match the regex pattern \w.

Note: Underscore (_) is also considered as an alphanumeric character.

\W - Matches any non-alphanumeric character. Equivalent to [^a-zA-Z0-9_].

Let's check if the following string examples match the regex pattern \W.