C# Regular expression

Regular expressionIt is a search formula used to describe and match text patterns. Simply put, you can understand it as a special wildcard language used to precisely find, validate, or replace content in strings.

For example, if you want to determine whether user input is a valid email address or phone number, or want to extract all dates from a piece of text—these are typical use cases for regular expressions.

The .NET framework has a built-in fully-featured regular expression engine, throughSystem.Text.RegularExpressionsThe namespace provides support.

A regular expression pattern consists of one or more characters, operators, and structures that together describe the text rules to match.

If you don't yet understand regular expressions, you can first read ourRegular Expressions - Tutorial。

Define a regular expression

Regular expressions are composed of the following types of building blocks, each responsible for different matching functions:

• Character escape: treat special characters as ordinary characters (e.g.,\.match a literal period)
• character class: matches a "certain type" of character (e.g.\dMatch any digit)
• Anchor point: specifies the "position" where the match occurs (e.g.^represents the start of a line)
• Grouping construct: group subpatterns together for easy capture or reference
• Qualifiers: controls the number of times an element appears (e.g.+indicates one or more times)
• Backreference construct: reference previously captured content for re-matching
• Alternation construct: implements "or" logic (e.g.cat|dog）
• replace: references captured content in replacement operations
• Miscellaneous construct: auxiliary functions such as inline options, comments, etc.

Character escape

In regular expressions, the backslash character (\) has two functions: first, it escapes the followingOrdinary characters take on special meaning(such as\nrepresents a newline), and second, it turnsSpecial characters are escaped to literal characters(such as\.match a real dot instead of "any character").

Common beginner misconception: in C# strings,\is itself an escape character, so writing in regex\d, in C# strings you need to write"\\d", or use a verbatim string@"\d"(Recommended).

The following table lists common escape characters:

character class

Character classes are used to match a character among "a certain type" of charactersAny one. For example[aeiou]matches any one vowel letter,\dMatches any single digit. This is one of the most commonly used basic functions in regular expressions.

The following table lists character classes:

Anchor point

Anchors (also called "anchors") do not match any specific character, but match a certain position in the string.Position. They are "zero-width", do not consume any characters, just assert that the current position satisfies a certain condition.

For example^\d{3}means "three digits at the start of the string",\bmeans "boundary between word and non-word characters".

The following table lists anchors:

Grouping construct

Grouping constructs use parentheses( )Enclose a part of the regular expression to form a subexpression. Grouping has two main purposes:

• catch: "save" the matched substring for later extraction or reference in replacement.
• Scope restriction: allow quantifiers or alternation constructs to only apply to the subexpression within the group.

This part is relatively difficult to understand; you can readRegular Expression - Selection 、Lookahead and lookbehind assertions in regular expressionsHelps understanding.

The following table lists grouping constructs:

Qualifiers

Quantifiers specify that the preceding element (character, character class, or group) must appearhow many timesOnly then is the match considered successful.

Quantifiers are by defaultgreedy, that is, match as many characters as possible. Adding after a quantifier?can becomeLazy (non-greedy)pattern, that is, match as few characters as possible. Beginners can first master*、+、?、{n}These four basic quantifiers.

The following table lists quantifiers:

Backreference constructs

Backreferences allow, within the same regular expression, referencingContent of previously captured groupsperforms a match again. For example, using(\w)\1can find consecutive repeated characters like "ee", "ll".

The following table lists backreference constructs:

Alternation construct

Alternation constructs use the vertical bar|Implements "or" logic, allowing the regular expression to match any one of multiple candidate patterns. Similar to the||Operators.

The following table lists alternation constructs:

replace

Replacement syntax is used forRegex.Replace()method'sReplacement Pattern StringIn, you can use$Use numbers or names to reference previously captured group content, enabling flexible text reorganization.

The following table lists characters used for substitution:

Miscellaneous construct

The following table lists miscellaneous constructs:

Regex Class

The Regex class is the core class for using regular expressions in .NET, located inSystem.Text.RegularExpressionsunder the namespace. Before using it, you need to add at the top of the file:

using System.Text.RegularExpressions;

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

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

Example 1

The following example matches words starting with 'S':

Analysis:\bis a word boundary,Smatches the uppercase letter S,\S*Matches zero or more non-whitespace characters; combined, this means "complete words starting with S".

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 starting with 'm' and ending with 'e':

Analysis:\bmmatches words starting with m,\S*matches any non-whitespace character in the middle,e\bRequires ending with e followed by a word boundary; together, it finds all words starting with m and ending with e.

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:

Analysis:\\s+Matches one or more consecutive whitespace characters (spaces, tabs, etc.) and replaces them all with a single space, thereby merging extra whitespace.

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

Original String: Hello   World   
Replacement String: Hello World   

GeneratedRegex: source generator optimization (.NET 7+)

Beginning with .NET 7, C# introduced[GeneratedRegex]attribute (source generator), which is a major upgrade to the traditionalRegexan important upgrade to the class, specifically forPerformance-sensitiveorRepeated useregex scenarios.

Problems with traditional approaches

Use traditionalnew Regex(pattern)When ..., the parsing and compilation of the regular expression occurs atruntime, each creation has overhead. Although you can useRegexOptions.CompiledImproves runtime speed, but compilation still occurs at runtime and increases startup time and memory usage.

Usage of GeneratedRegex

Usage[GeneratedRegex]With the attribute, the compiler willCompilation phasegenerate the regular expression directly as efficient C# code, without runtime parsing or compilation.

Usage requirements: .NET 7 or higher is required, and the method must bepartialmethod, the containing class must also bepartialclass.

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

找到日期：2024-06-18
找到日期：2025-01-01
True

GeneratedRegex vs Traditional Regex

The following table compares the two approaches from multiple dimensions to help you choose the appropriate usage:

Usage suggestions

• If you use.NET 7+and the regex pattern is fixed,Prefer to use[GeneratedRegex]。
• If the regex pattern needs to be dynamically built at runtime (e.g., generated from user input), only the traditionalnew Regex(pattern)。
• If the project needs to supportNative AOTWhen publishing (e.g., .NET 8's AOT mode), be sure to use[GeneratedRegex]rather thanRegexOptions.Compiled。
• For beginners, you can first use the traditional method to learn and practice. After understanding the principles of regex, gradually migrate to[GeneratedRegex]。

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

[email protected]: 有效
bad-email: 无效
[email protected]: 有效
missing@dot: 无效