现在位置: 首页 > C# 教程 > 正文

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;
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 类中一些常用的方法:

序号方法 & 描述
1public bool IsMatch( string input )
判断输入字符串是否包含与正则模式匹配的内容。常用于表单验证,如验证手机号、邮箱格式。
2public bool IsMatch( string input, int startat )
从字符串中指定的起始位置开始进行匹配判断。
3public static bool IsMatch( string input, string pattern )
静态方法,无需先创建 Regex 对象,直接传入模式字符串进行匹配判断。适合一次性使用的场景。
4public MatchCollection Matches( string input )
在输入字符串中搜索所有匹配项,返回 MatchCollection 集合,可用 foreach 遍历每个匹配结果。
5public string Replace( string input, string replacement )
将输入字符串中所有匹配正则模式的内容替换为指定字符串。
6public string[] Split( string input )
按照正则模式定义的分隔符,将输入字符串分割为子字符串数组。比 string.Split() 更灵活,支持复杂分隔规则。

如需了解 Regex 类的完整的属性列表,请参阅微软的 C# 文档。

实例 1

下面的实例匹配了以 'S' 开头的单词:

解析:\b 是单词边界,S 匹配大写字母 S,\S* 匹配零个或多个非空白字符,组合起来就是"以 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();
      }
   }
}

当上面的代码被编译和执行时,它会产生下列结果:

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;
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;
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 提升运行速度,但编译仍在运行时进行,且会增加启动时间和内存占用。

传统方式

using System.Text.RegularExpressions;

// 方式一:每次调用都重新解析(最慢)
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;
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 对比

下表从多个维度对比两种方式,帮助你选择适合的用法:

对比维度传统 RegexGeneratedRegex(源生成器)推荐
最低版本要求.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;
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: 无效