Regular Expressions (Regex) in C#

For an in-depth understanding of what Regular Expressions (Regex) in C# entail, readers can refer to the following article by Mytour.

Regular Expressions (Regex) in C#
 

1. Regular Expressions (Regex) in C#

C# supports regular expressions through classes in the System.Text.RegularExpressions namespace in the standard .NET framework. While there are some differences in advanced features that the .NET regex library supports compared to PCRE, both share the majority of syntax, patterns, and expressions that can be used in C# and other languages.

The example below illustrates how to use regular expressions in C#. A small note is that if you are testing the code, you must include the namespace at the beginning of the source file.

Utilize System.Text.RegularExpressions; in C# for powerful string pattern handling.

Discover the magic of 2. Verbatim String Literal in C#

When constructing formal expressions in C#, opt for verbatim strings over regular ones. Verbatim strings, initiated with a special prefix (@), signal to C# not to interpret backslashes and special characters in the string. This allows for direct transmission to regex tools.

This implies that patterns like '\n\w' can elegantly be expressed as @'\n\w', avoiding the need for \\n\\w <\\n\\w> seen in other programming languages, resulting in more readable code.

Delve into 3. String Matching in C#

Within the System.Text.RegularExpressions namespace lies the Regex class. This class acts as an encapsulation of the regular expression tool, enabling you to perform matching and extract information from text using regular expressions.

To check whether a regular expression matches a string, you can employ the static method Regex.Match() to obtain a set of options from the RegexOptions enum. This returns a Match object containing information about the position where the matching result was found (if any).

Method: Match match = Regex.Match(InputStr, Pattern, RegexOptions)

Explore this C# string matching example:

4. Capture Groups in C#

To perform a global search across the entire input string and retrieve all matching results with corresponding captured data, use the static method Regex.Matches() to obtain a MatchCollection. This collection can be iterated and processed as demonstrated in the above example.

Method

MatchCollection matches = Regex.Matches(InputStr, Pattern, RegexOptions)

Explore this C# example demonstrating Capture Groups:

5. Find and Replace Strings in C#

Another common task involves finding and replacing a portion of a string using regular expressions. This could be replacing all instances of old email domains or rearranging the order of text. To achieve this in C#, we will utilize the static method Regex.Replace().

The replacement string can be a regular expression containing references to capture groups in the pattern or just a plain string.

Method:

string replaced = Regex.Replace(InputStr, Pattern, ReplacementPattern, RegexOption)

6. RegexOptions Enum in C#

Among the various regular expression methods mentioned above, you may observe that each method has an optional RegexOptions parameter. Most available flags can be directly written into the regex pattern and can be useful in specific cases. These include:
- RegexOptions.Compiled accelerates the matching process for multiple input strings with the same pattern by allowing the regex engine to compile the pattern in advance. By default, no options are set.
- RegexOptions.IgnoreCase creates a case-insensitive pattern to match uppercase and lowercase strings.
- RegexOptions.Multiline is necessary if your input string has newline characters (\n) and allows metacharacters (^ and $ respectively) to match the start and end of each line instead of the entire input string.
- RegexOptions.RightToLeft is used for matching in right-to-left languages.
- RegexOptions.Singleline allows the metacharacter (.) to match all characters, including newline characters (\n).

7. Compiling Patterns

While the static methods above handle common tasks, if you are dealing with millions of input strings with the same pattern, you can reduce object allocation to improve performance by initializing a Regex object with the pattern in the constructor.

With this Regex object, all the similar methods mentioned above are available within the object, except you don't have to pass the pattern in each call.

This article by Mytour has just introduced you to Regular Expressions in C#. If you have any questions or need clarification on topics like Polymorphism in C#, feel free to leave your thoughts in the comments section below the article. Mytour will address your queries as soon as possible.