C# 正则表达式
正则表达式 是一种用来描述、匹配文本模式的搜索公式。简单来说,你可以把它理解成一套特殊的通配符语言,用来精确地找到、验证或替换字符串中的内容。
例如,想判断用户输入的是不是一个合法的邮箱地址、手机号,或者想从一段文本里提取所有日期——这些都是正则表达式的典型应用场景。
.NET 框架内置了功能完善的正则表达式引擎,通过 System.Text.RegularExpressions 命名空间提供支持。
一个正则表达式模式由一个或多个字符、运算符和结构组成,它们共同描述要匹配的文本规则。
如果你还不理解正则表达式可以先阅读我们的正则表达式 - 教程。
定义正则表达式
正则表达式由以下几类构建块组成,每类负责不同的匹配功能:
- 字符转义:让特殊字符被当作普通字符处理(如
\.匹配真正的句点) - 字符类:匹配"某一类"字符(如
\d匹配任意数字) - 定位点:指定匹配发生的"位置"(如
^表示行首) - 分组构造:将子模式组合在一起,方便捕获或引用
- 限定符:控制某个元素出现的次数(如
+表示一次或多次) - 反向引用构造:引用前面已捕获的内容进行再次匹配
- 备用构造:实现"或"逻辑(如
cat|dog) - 替换:在替换操作中引用捕获的内容
- 杂项构造:内联选项、注释等辅助功能
字符转义
正则表达式中,反斜杠字符(\)有两个作用:一是将其后的普通字符变成特殊含义(如 \n 表示换行),二是将特殊字符转义为原义字符(如 \. 匹配真实的点号而非"任意字符")。
初学者常见误区:在 C# 字符串中,\ 本身也是转义字符,所以正则中写 \d,在 C# 字符串里要写 "\\d",或者使用逐字字符串 @"\d"(推荐)。
下表列出了常用的转义字符:
| 转义字符 | 描述 | 模式 | 匹配 |
|---|---|---|---|
| \a | 与报警 (bell) 符 \u0007 匹配。 | \a | "Warning!" + '\u0007' 中的 "\u0007" |
| \b | 在字符类中,与退格键 \u0008 匹配。(注意:在字符类外,\b 表示单词边界,见"定位点"部分) | [\b]{3,} | "\b\b\b\b" 中的 "\b\b\b\b" |
| \t | 与制表符 \u0009 匹配。常用于匹配 Tab 分隔的文本。 | (\w+)\t | "Name\tAddr\t" 中的 "Name\t" 和 "Addr\t" |
| \r | 与回车符 \u000D 匹配。(\r 与换行符 \n 不是等效的。Windows 换行通常是 \r\n) | \r\n(\w+) | "\r\nHello\nWorld." 中的 "\r\nHello" |
| \v | 与垂直制表符 \u000B 匹配。 | [\v]{2,} | "\v\v\v" 中的 "\v\v\v" |
| \f | 与换页符 \u000C 匹配。 | [\f]{2,} | "\f\f\f" 中的 "\f\f\f" |
| \n | 与换行符 \u000A 匹配。Unix/Linux 系统的行尾通常只有 \n。 | \r\n(\w+) | "\r\nHello\nWorld." 中的 "\r\nHello" |
| \e | 与转义符 \u001B 匹配。 | \e | "\x001B" 中的 "\x001B" |
| \ nnn | 使用八进制表示形式指定一个字符(nnn 由二到三位数字组成)。 | \w\040\w | "a bc d" 中的 "a b" 和 "c d" |
| \x nn | 使用十六进制表示形式指定字符(nn 恰好由两位数字组成)。 | \w\x20\w | "a bc d" 中的 "a b" 和 "c d" |
| \c X \c x | 匹配 X 或 x 指定的 ASCII 控件字符,其中 X 或 x 是控件字符的字母。 | \cC | "\x0003" 中的 "\x0003" (Ctrl-C) |
| \u nnnn | 使用十六进制表示形式匹配一个 Unicode 字符(由 nnnn 表示的四位数)。 | \w\u0020\w | "a bc d" 中的 "a b" 和 "c d" |
| \ | 在后面带有不识别的转义字符时,与该字符匹配。 | \d+[\+-x\*]\d+\d+[\+-x\*\d+ | "(2+2) * 3*9" 中的 "2+2" 和 "3*9" |
字符类
字符类用于匹配"某一类"字符中的任意一个。例如 [aeiou] 匹配任意一个元音字母,\d 匹配任意一个数字。这是正则表达式中最常用的基础功能之一。
下表列出了字符类:
| 字符类 | 描述 | 模式 | 匹配 |
|---|---|---|---|
| [character_group] | 匹配 character_group 中的任何单个字符。 默认情况下,匹配区分大小写。 | [mn] | "mat" 中的 "m","moon" 中的 "m" 和 "n" |
| [^character_group] | 非:与不在 character_group 中的任何单个字符匹配。 默认情况下,character_group 中的字符区分大小写。 | [^aei] | "avail" 中的 "v" 和 "l" |
| [ first - last ] | 字符范围:与从 first 到 last 的范围中的任何单个字符匹配。 | [b-d] | [b-d]irds 可以匹配 Birds、 Cirds、 Dirds |
| . | 通配符:与除 \n 之外的任何单个字符匹配。
若要匹配原意句点字符(. 或 \u002E),您必须在该字符前面加上转义符 (\.)。 | a.e | "have" 中的 "ave", "mate" 中的 "ate" |
| \p{ name } | 与 name 指定的 Unicode 通用类别或命名块中的任何单个字符匹配。 | \p{Lu} | "City Lights" 中的 "C" 和 "L" |
| \P{ name } | 与不在 name 指定的 Unicode 通用类别或命名块中的任何单个字符匹配。 | \P{Lu} | "City" 中的 "i"、 "t" 和 "y" |
| \w | 与任何单词字符匹配(字母、数字、下划线)。等价于 [a-zA-Z0-9_](ASCII 范围内)。 | \w | "Room#1" 中的 "R"、 "o"、 "m" 和 "1" |
| \W | 与任何非单词字符匹配。是 \w 的反义。 | \W | "Room#1" 中的 "#" |
| \s | 与任何空白字符匹配(空格、制表符、换行等)。 | \w\s | "ID A1.3" 中的 "D " |
| \S | 与任何非空白字符匹配。是 \s 的反义。 | \s\S | "int __ctr" 中的 " _" |
| \d | 与任何十进制数字匹配。等价于 [0-9]。 | \d | "4 = IV" 中的 "4" |
| \D | 匹配不是十进制数的任意字符。是 \d 的反义。 | \D | "4 = IV" 中的 " "、 "="、 " "、 "I" 和 "V" |
定位点
定位点(也叫"锚点")不匹配任何具体字符,而是匹配字符串中的某个位置。它们是"零宽度"的,不消耗任何字符,只是断言当前位置满足某个条件。
例如 ^\d{3} 表示"字符串开头的三个数字",\b 表示"单词与非单词字符之间的边界"。
下表列出了定位点:
| 断言 | 描述 | 模式 | 匹配 |
|---|---|---|---|
| ^ | 匹配必须从字符串或一行的开头开始。 | ^\d{3} | "567-777-" 中的 "567" |
| $ | 匹配必须出现在字符串的末尾或出现在行或字符串末尾的 \n 之前。 | -\d{4}$ | "8-12-2012" 中的 "-2012" |
| \A | 匹配必须出现在字符串的开头(不受多行模式影响,始终是整个字符串的开头)。 | \A\w{4} | "Code-007-" 中的 "Code" |
| \Z | 匹配必须出现在字符串的末尾或出现在字符串末尾的 \n 之前。 | -\d{3}\Z | "Bond-901-007" 中的 "-007" |
| \z | 匹配必须出现在字符串的末尾(严格末尾,不允许末尾有 \n)。 | -\d{3}\z | "-901-333" 中的 "-333" |
| \G | 匹配必须出现在上一个匹配结束的地方。常用于连续匹配场景。 | \G\(\d\) | "(1)(3)(5)[7](9)" 中的 "(1)"、 "(3)" 和 "(5)" |
| \b | 匹配一个单词边界,也就是指单词和空格间的位置。 | er\b | 匹配"never"中的"er",但不能匹配"verb"中的"er"。 |
| \B | 匹配非单词边界。 | er\B | 匹配"verb"中的"er",但不能匹配"never"中的"er"。 |
分组构造
分组构造使用圆括号 ( ) 将正则表达式的一部分括起来,形成一个子表达式。分组有两个主要用途:
- 捕获:将匹配到的子字符串"保存"下来,方便后续提取或在替换中引用。
- 作用域限定:让限定符或备用构造只作用于组内的子表达式。
这一部分比较难于理解,可以阅读 正则表达式-选择 、正则表达式的先行断言(lookahead)和后行断言(lookbehind) 帮助理解。
下表列出了分组构造:
| 分组构造 | 描述 | 模式 | 匹配 |
|---|---|---|---|
| ( subexpression ) | 捕获匹配的子表达式并将其分配到一个从零开始的序号中。 | (\w)\1 | "deep" 中的 "ee" |
| (?< name >subexpression) | 将匹配的子表达式捕获到一个命名组中。命名组比数字编号更易读,推荐在复杂正则中使用。 | (?< double>\w)\k< double> | "deep" 中的 "ee" |
| (?< name1 -name2 >subexpression) | 定义平衡组定义。用于匹配嵌套结构(如括号配对),属于高级特性。 | (((?'Open'\()[^\(\)]*)+((?'Close-Open'\))[^\(\)]*)+)*(?(Open)(?!))$ | "3+2^((1-3)*(3-1))" 中的 "((1-3)*(3-1))" |
| (?: subexpression) | 定义非捕获组。当只需要分组(限定范围)而不需要保存匹配内容时使用,性能略优于捕获组。 | Write(?:Line)? | "Console.WriteLine()" 中的 "WriteLine" |
| (?imnsx-imnsx:subexpression) | 应用或禁用 subexpression 中指定的选项。 | A\d{2}(?i:\w+)\b | "A12xl A12XL a12xl" 中的 "A12xl" 和 "A12XL" |
| (?= subexpression) | 零宽度正预测先行断言(lookahead)。匹配后面紧跟 subexpression 的位置,但不消耗字符。 | \w+(?=\.) | "He is. The dog ran. The sun is out." 中的 "is"、 "ran" 和 "out" |
| (?! subexpression) | 零宽度负预测先行断言。匹配后面不跟 subexpression 的位置。 | \b(?!un)\w+\b | "unsure sure unity used" 中的 "sure" 和 "used" |
| (?<=subexpression) | 零宽度正回顾后发断言(lookbehind)。匹配前面紧接 subexpression 的位置。 | (?<=19)\d{2}\b | "1851 1999 1950 1905 2003" 中的 "99"、"50"和 "05" |
| (?<! subexpression) | 零宽度负回顾后发断言。匹配前面不接 subexpression 的位置。 | (?<!wo)man\b | "Hi woman Hi man" 中的 "man" |
| (?> subexpression) | 非回溯(原子组)子表达式。匹配成功后不允许回溯,可以提升某些场景的性能。 | [13579](?>A+B+) | "1ABB 3ABBC 5AB 5AC" 中的 "1ABB"、 "3ABB" 和 "5AB" |
实例
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);
}
}
运行实例 »
限定符
限定符指定前面的元素(字符、字符类或分组)必须出现多少次才算匹配成功。
限定符默认是贪婪的,即尽可能多地匹配字符。在限定符后加 ? 可变为懒惰(非贪婪)模式,即尽可能少地匹配字符。初学者可先掌握 *、+、?、{n} 这四种基础限定符。
下表列出了限定符:
| 限定符 | 描述 | 模式 | 匹配 |
|---|---|---|---|
| * | 匹配上一个元素零次或多次。(零次也算匹配) | \d*\.\d | ".0"、 "19.9"、 "219.9" |
| + | 匹配上一个元素一次或多次。(至少一次) | "be+" | "been" 中的 "bee", "bent" 中的 "be" |
| ? | 匹配上一个元素零次或一次。(即该元素可选) | "rai?n" | "ran"、 "rain" |
| { n } | 匹配上一个元素恰好 n 次。 | ",\d{3}" | "1,043.6" 中的 ",043", "9,876,543,210" 中的 ",876"、 ",543" 和 ",210" |
| { n ,} | 匹配上一个元素至少 n 次。 | "\d{2,}" | "166"、 "29"、 "1930" |
| { n , m } | 匹配上一个元素至少 n 次,但不多于 m 次。 | "\d{3,5}" | "166", "17668", "193024" 中的 "19302" |
| *? | 匹配上一个元素零次或多次,但次数尽可能少(懒惰模式)。 | \d*?\.\d | ".0"、 "19.9"、 "219.9" |
| +? | 匹配上一个元素一次或多次,但次数尽可能少(懒惰模式)。 | "be+?" | "been" 中的 "be", "bent" 中的 "be" |
| ?? | 匹配上一个元素零次或一次,但次数尽可能少(懒惰模式)。 | "rai??n" | "ran"、 "rain" |
| { n }? | 匹配前导元素恰好 n 次。 | ",\d{3}?" | "1,043.6" 中的 ",043", "9,876,543,210" 中的 ",876"、 ",543" 和 ",210" |
| { n ,}? | 匹配上一个元素至少 n 次,但次数尽可能少。 | "\d{2,}?" | "166"、 "29" 和 "1930" |
| { n , m }? | 匹配上一个元素的次数介于 n 和 m 之间,但次数尽可能少。 | "\d{3,5}?" | "166", "17668", "193024" 中的 "193" 和 "024" |
反向引用构造
反向引用允许在同一正则表达式中,引用前面已捕获的分组内容进行再次匹配。例如,用 (\w)\1 可以找出像 "ee"、"ll" 这样的连续重复字符。
下表列出了反向引用构造:
| 反向引用构造 | 描述 | 模式 | 匹配 |
|---|---|---|---|
| \ number | 反向引用。 匹配编号子表达式的值。 | (\w)\1 | "seek" 中的 "ee" |
| \k< name > | 命名反向引用。 匹配命名表达式的值。比数字引用更易读,推荐使用。 | (?< char>\w)\k< char> | "seek" 中的 "ee" |
备用构造
备用构造使用竖线 | 实现"或"逻辑,让正则表达式可以匹配多个候选模式中的任意一个。类似于编程语言中的 || 运算符。
下表列出了备用构造:
| 备用构造 | 描述 | 模式 | 匹配 |
|---|---|---|---|
| | | 匹配以竖线 (|) 字符分隔的任何一个元素。 | th(e|is|at) | "this is the day. " 中的 "the" 和 "this" |
| (?( expression )yes | no ) | 如果正则表达式模式由 expression 匹配指定,则匹配 yes;否则匹配可选的 no 部分。 expression 被解释为零宽度断言。 | (?(A)A\d{2}\b|\b\d{3}\b) | "A10 C103 910" 中的 "A10" 和 "910" |
| (?( name )yes | no ) | 如果 name 或已命名或已编号的捕获组具有匹配,则匹配 yes;否则匹配可选的 no。 | (?< quoted>")?(?(quoted).+?"|\S+\s) | "Dogs.jpg "Yiska playing.jpg"" 中的 Dogs.jpg 和 "Yiska playing.jpg" |
替换
替换语法用于 Regex.Replace() 方法的替换模式字符串中,可以通过 $ 加编号或名称来引用之前捕获的分组内容,实现灵活的文本重组。
下表列出了用于替换的字符:
| 字符 | 描述 | 模式 | 替换模式 | 输入字符串 | 结果字符串 |
|---|---|---|---|---|---|
| $number | 替换按组 number 匹配的子字符串。 | \b(\w+)(\s)(\w+)\b | $3$2$1 | "one two" | "two one" |
| ${name} | 替换按命名组 name 匹配的子字符串。 | \b(?< word1>\w+)(\s)(?< word2>\w+)\b | ${word2} ${word1} | "one two" | "two one" |
| $$ | 替换字符"$"。 | \b(\d+)\s?USD | $$$1 | "103 USD" | "$103" |
| $& | 替换整个匹配项的一个副本。 | (\$*(\d*(\.+\d+)?){1}) | **$& | "$1.30" | "**$1.30" |
| $` | 替换匹配前的输入字符串的所有文本。 | B+ | $` | "AABBCC" | "AAAACC" |
| $' | 替换匹配后的输入字符串的所有文本。 | B+ | $' | "AABBCC" | "AACCCC" |
| $+ | 替换最后捕获的组。 | B+(C+) | $+ | "AABBCCDD" | AACCDD |
| $_ | 替换整个输入字符串。 | B+ | $_ | "AABBCC" | "AAAABBCCCC" |
杂项构造
下表列出了各种杂项构造:
| 构造 | 描述 | 实例 |
|---|---|---|
| (?imnsx-imnsx) | 在模式中间对诸如不区分大小写这样的选项进行设置或禁用。 | \bA(?i)b\w+\b 匹配 "ABA Able Act" 中的 "ABA" 和 "Able" |
| (?#注释) | 内联注释。该注释在第一个右括号处终止。 | \bA(?#匹配以A开头的单词)\w+\b |
| # [行尾] | 该注释以非转义的 # 开头,并继续到行的结尾。 | (?x)\bA\w+\b#匹配以 A 开头的单词 |
Regex 类
Regex 类是 .NET 中使用正则表达式的核心类,位于 System.Text.RegularExpressions 命名空间下。使用前需要在文件顶部添加:
using System.Text.RegularExpressions;
下表列出了 Regex 类中一些常用的方法:
| 序号 | 方法 & 描述 |
|---|---|
| 1 | public bool IsMatch(
string input
)
判断输入字符串是否包含与正则模式匹配的内容。常用于表单验证,如验证手机号、邮箱格式。 |
| 2 | public bool IsMatch(
string input,
int startat
)
从字符串中指定的起始位置开始进行匹配判断。 |
| 3 | public static bool IsMatch(
string input,
string pattern
)
静态方法,无需先创建 Regex 对象,直接传入模式字符串进行匹配判断。适合一次性使用的场景。 |
| 4 | public MatchCollection Matches(
string input
)
在输入字符串中搜索所有匹配项,返回 MatchCollection 集合,可用 foreach 遍历每个匹配结果。 |
| 5 | public string Replace(
string input,
string replacement
)
将输入字符串中所有匹配正则模式的内容替换为指定字符串。 |
| 6 | public string[] Split(
string input
)
按照正则模式定义的分隔符,将输入字符串分割为子字符串数组。比 string.Split() 更灵活,支持复杂分隔规则。 |
如需了解 Regex 类的完整的属性列表,请参阅微软的 C# 文档。
实例 1
下面的实例匹配了以 'S' 开头的单词:
解析:\b 是单词边界,S 匹配大写字母 S,\S* 匹配零个或多个非空白字符,组合起来就是"以 S 开头的完整单词"。
实例
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();
}
}
}
当上面的代码被编译和执行时,它会产生下列结果:
Matching words that start with 'S': The Expression: \bS\S* Splendid Suns
实例 2
下面的实例匹配了以 'm' 开头以 'e' 结尾的单词:
解析:\bm 匹配以 m 开头的单词,\S* 匹配中间的任意非空白字符,e\b 要求以 e 结尾且后面是单词边界,合起来就是找所有 m 开头 e 结尾的单词。
实例
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();
}
}
}
当上面的代码被编译和执行时,它会产生下列结果:
Matching words start with 'm' and ends with 'e': The Expression: \bm\S*e\b make maze manage measure
实例 3
下面的实例替换掉多余的空格:
解析:\\s+ 匹配一个或多个连续空白字符(空格、制表符等),将它们全部替换为单个空格,从而合并多余空白。
实例
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
GeneratedRegex:源生成器优化(.NET 7+)
从 .NET 7 开始,C# 引入了 [GeneratedRegex] 特性(源生成器),这是对传统 Regex 类的重要升级,专门用于对性能敏感或反复使用的正则表达式场景。
传统方式的问题
使用传统 new Regex(pattern) 时,正则表达式的解析和编译发生在运行时,每次创建都有开销。虽然可以用 RegexOptions.Compiled 提升运行速度,但编译仍在运行时进行,且会增加启动时间和内存占用。
传统方式
// 方式一:每次调用都重新解析(最慢)
bool isMatch = Regex.IsMatch(input, @"\d{4}-\d{2}-\d{2}");
// 方式二:静态字段 + Compiled(常见优化做法)
private static readonly Regex DateRegex = new Regex(@"\d{4}-\d{2}-\d{2}", RegexOptions.Compiled);
GeneratedRegex 的用法
使用 [GeneratedRegex] 特性,编译器会在编译阶段将正则表达式直接生成为高效的 C# 代码,无需运行时解析或编译。
使用条件:需要 .NET 7 或更高版本,且该方法必须是 partial 方法,所在类也必须是 partial 类。
GeneratedRegex 基本用法
using System.Text.RegularExpressions;
namespace RegExApplication
{
// 类必须声明为 partial
partial class Program
{
// 使用 [GeneratedRegex] 特性,编译器自动生成实现
[GeneratedRegex(@"\d{4}-\d{2}-\d{2}")]
private static partial Regex DateRegex();
// 也可以附加选项,例如忽略大小写
[GeneratedRegex(@"\bS\S*", RegexOptions.IgnoreCase)]
private static partial Regex StartsWithSRegex();
static void Main(string[] args)
{
string input = "Today is 2024-06-18, next event: 2025-01-01";
// 像调用普通方法一样使用,返回的是 Regex 实例
foreach (Match m in DateRegex().Matches(input))
{
Console.WriteLine("找到日期:" + m.Value);
}
// 验证是否匹配
Console.WriteLine(StartsWithSRegex().IsMatch("Splendid")); // True
}
}
}
当上面的代码被编译和执行时,它会产生下列结果:
找到日期:2024-06-18 找到日期:2025-01-01 True
GeneratedRegex 与传统 Regex 对比
下表从多个维度对比两种方式,帮助你选择适合的用法:
| 对比维度 | 传统 Regex | GeneratedRegex(源生成器) | 推荐 |
|---|---|---|---|
| 最低版本要求 | .NET Framework / .NET Core 全版本支持 | .NET 7 及以上 | — |
| 编译时机 | 运行时解析和编译 | 编译阶段(build time)由 Roslyn 源生成器生成代码 | GeneratedRegex |
| 执行性能 | 普通:较慢;加 Compiled 选项:较快,但启动开销大 | 最快,接近手写代码的性能,且无启动开销 | GeneratedRegex |
| 内存占用 | Compiled 模式会生成 IL 代码,内存占用较高 | 生成的是普通 C# 代码,内存更友好 | GeneratedRegex |
| AOT 兼容性 | RegexOptions.Compiled 不兼容 AOT(提前编译) | 完全兼容 Native AOT,适合发布独立应用 | GeneratedRegex |
| 代码可读性 | 模式字符串直接写在代码中,较直观 | 需要定义 partial 方法,代码结构略复杂 | 传统 Regex(简单场景) |
| 动态模式 | 支持,模式可以是运行时的变量 | 不支持,模式必须是编译时常量 | 传统 Regex(动态场景) |
| 调试支持 | 普通 | 生成的代码可直接查看和调试,更透明 | GeneratedRegex |
| 适用场景 | 一次性使用、动态模式、旧版 .NET 项目 | 高频调用、性能敏感、AOT 发布、新版 .NET 项目 | 视场景而定 |
使用建议
- 如果你使用 .NET 7+ 且正则表达式模式是固定的,优先使用
[GeneratedRegex]。 - 如果正则模式需要在运行时动态构建(如根据用户输入生成),则只能使用传统
new Regex(pattern)。 - 如果项目需要支持 Native AOT 发布(如 .NET 8 的 AOT 模式),务必使用
[GeneratedRegex]而非RegexOptions.Compiled。 - 对于初学者,可以先用传统方式学习和练习,理解正则原理后,在实际项目中逐步迁移到
[GeneratedRegex]。
实例:用 GeneratedRegex 验证邮箱格式
using System.Text.RegularExpressions;
partial class EmailValidator
{
// 定义邮箱验证正则,忽略大小写
[GeneratedRegex(@"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$", RegexOptions.IgnoreCase)]
private static partial Regex EmailRegex();
public static bool IsValidEmail(string email)
{
return EmailRegex().IsMatch(email);
}
static void Main(string[] args)
{
string[] emails = { "user@example.com", "bad-email", "hello@world.org", "missing@dot" };
foreach (var email in emails)
{
Console.WriteLine($"{email}: {(IsValidEmail(email) ? "有效" : "无效")}");
}
}
}
当上面的代码被编译和执行时,它会产生下列结果:
user@example.com: 有效 bad-email: 无效 hello@world.org: 有效 missing@dot: 无效
