C# 正则表达式：理解与实践 – wiki基地

---

C# 正则表达式：深入理解与实践

正则表达式（Regular Expression，简称 Regex 或 Regexp）是一种强大的文本处理工具，用于描述、匹配、查找和操作字符串中符合特定模式的文本。无论是在数据验证、文本解析、搜索替换还是日志分析等场景，正则表达式都展现出其独特的灵活性和高效性。

在 C# 中，.NET 框架提供了 System.Text.RegularExpressions 命名空间，为开发者提供了丰富的功能来使用和操作正则表达式。本文将深入探讨 C# 中正则表达式的核心概念、语法特性以及如何在实际开发中进行有效地应用。

第一部分：理解正则表达式基础

在使用 C# 的 Regex 类之前，掌握正则表达式本身的语法是至关重要的。正则表达式语法是一套通用的规则，虽然在不同语言或工具中可能存在细微差异，但核心概念是普适的。

1. 字面量与元字符

• 字面量（Literal Characters）: 大多数字符在正则表达式中都代表其本身。例如，模式 hello 会精确匹配字符串 “hello”。
• 元字符（Metacharacters）: 这些字符在正则表达式中有特殊含义。它们是构建复杂模式的基础。常见的元字符包括：
  • .: 匹配除换行符 \n 之外的任意单个字符。
  • *: 匹配前一个元素零次或多次。例如，a* 匹配 “”, “a”, “aa”, “aaa” 等。
  • +: 匹配前一个元素一次或多次。例如，a+ 匹配 “a”, “aa”, “aaa” 等，但不匹配 “”。
  • ?: 匹配前一个元素零次或一次。例如，a? 匹配 “” 或 “a”。
  • []: 字符集合。匹配方括号中任意一个字符。例如，[aeiou] 匹配任意一个元音字母。可以使用连字符 - 表示范围，如 [0-9] 匹配任意数字，[a-z] 匹配任意小写字母。[^...] 表示否定集合，匹配除方括号中字符之外的任意一个字符。
  • (): 分组与捕获。将一个或多个字符组合成一个整体，可以对其应用量词，也可以用于捕获匹配的子串。
  • |: 或运算符。匹配 | 符号前或后的模式。例如，cat|dog 匹配 “cat” 或 “dog”。
  • ^: 锚点。匹配输入字符串的开头。
  • $: 锚点。匹配输入字符串的结尾。
  • \: 转义字符。用于转义元字符，使其失去特殊含义，或用于引入特殊序列。例如，\. 匹配实际的点号，\$ 匹配实际的美元符号。

2. 特殊字符序列（Special Sequences）

使用反斜杠 \ 引入的字符序列通常有特殊含义：

• \d: 匹配任意数字（0-9）。等同于 [0-9]。
• \D: 匹配任意非数字字符。等同于 [^0-9]。
• \w: 匹配任意字母、数字或下划线字符。等同于 [a-zA-Z0-9_]。
• \W: 匹配任意非字母、非数字、非下划线字符。等同于 [^a-zA-Z0-9_]。
• \s: 匹配任意空白字符，包括空格、制表符 \t、换行符 \n、回车符 \r、换页符 \f 等。
• \S: 匹配任意非空白字符。
• \b: 匹配单词边界。单词边界是指一个 \w 字符和一个 \W 字符之间的位置，或者一个 \w 字符与字符串开头/结尾之间的位置。例如，\bword\b 匹配独立的单词 “word”。
• \B: 匹配非单词边界。
• \n: 匹配换行符。
• \r: 匹配回车符。
• \t: 匹配制表符。

3. 量词（Quantifiers）

量词指定了前一个元素应该出现的次数：

• {n}: 匹配前一个元素恰好 n 次。例如，a{3} 匹配 “aaa”。
• {n,}: 匹配前一个元素至少 n 次。例如，a{2,} 匹配 “aa”, “aaa”, “aaaa” 等。
• {n,m}: 匹配前一个元素至少 n 次，至多 m 次。例如，a{2,4} 匹配 “aa”, “aaa”, “aaaa”。
• *: 等同于 {0,}。
• +: 等同于 {1,}。
• ?: 等同于 {0,1}。

默认情况下，量词是“贪婪的”（Greedy），它们会匹配尽可能多的字符。例如，模式 <.*> 应用于字符串 <b>bold</b><i>italic</i> 时，会匹配整个字符串 <b>bold</b><i>italic</i>，而不是只匹配 <b>bold</b>。

可以通过在量词后加上 ? 使其变为“惰性的”（Lazy）或“非贪婪的”（Non-Greedy）。惰性量词会匹配尽可能少的字符。

• *?: 匹配前一个元素零次或多次，但尽可能少。
• +?: 匹配前一个元素一次或多次，但尽可能少。
• ??: 匹配前一个元素零次或一次，但尽可能少。
• {n,m}?: 匹配前一个元素 n 到 m 次，但尽可能少。

例如，模式 <.*?> 应用于字符串 <b>bold</b><i>italic</i> 时，会先匹配 <b>bold</b>，然后继续匹配 <i>italic</i>。

4. 分组与捕获（Grouping and Capturing）

使用括号 () 可以将模式的一部分分组。分组有几个主要用途：

• 应用量词到整个组: 例如，(ab)+ 匹配 “ab”, “abab”, “ababab” 等。
• 捕获匹配的子串: 括号内的匹配内容会被“捕获”，之后可以通过索引或名称来引用。这是从字符串中提取特定信息的核心机制。
• 非捕获分组: 如果你只需要分组功能（例如应用量词），但不需要捕获内容，可以使用 (?:...)。这可以提高性能，因为引擎不需要存储捕获的子串。

5. 零宽度断言（Zero-Width Assertions / Lookarounds）

零宽度断言匹配的是一个位置，而不是实际的字符。它们用于指定在匹配某个模式时，其前后必须满足的条件。

• 肯定先行断言（Positive Lookahead）: (?=...)。匹配后面紧跟着指定模式的位置。
• 否定先行断言（Negative Lookahead）: (?!...)。匹配后面 没有 紧跟着指定模式的位置。
• 肯定后发断言（Positive Lookbehind）: (?<=...)。匹配前面紧跟着指定模式的位置。
• 否定后发断言（Negative Lookbehind）: (?<!...)。匹配前面 没有 紧跟着指定模式的位置。

例如，\d+(?=%$) 匹配一个数字序列，但只在它后面紧跟着 “%” 和字符串结尾时才匹配这个数字序列本身（不包括 “%”）。

第二部分：C# 中的正则表达式

.NET 框架在 System.Text.RegularExpressions 命名空间中提供了处理正则表达式所需的一切。核心类是 Regex，它代表了一个不可变的正则表达式。

1. Regex 类

Regex 类提供了多种静态方法和实例方法来执行匹配操作。

• 构造函数:

  • new Regex(string pattern): 创建一个 Regex 实例，使用指定的正则表达式模式。
  • new Regex(string pattern, RegexOptions options): 创建一个 Regex 实例，并指定匹配选项。

• 静态方法: 这些方法方便用于一次性匹配，无需创建 Regex 实例。对于频繁使用的模式，创建实例并编译 (RegexOptions.Compiled) 会更高效。

  • static bool IsMatch(string input, string pattern): 检查输入字符串中是否包含匹配模式的子串。
  • static bool IsMatch(string input, string pattern, RegexOptions options): 同上，带选项。
  • static Match Match(string input, string pattern): 查找输入字符串中第一个匹配模式的子串，返回一个 Match 对象。
  • static Match Match(string input, string pattern, RegexOptions options): 同上，带选项。
  • static MatchCollection Matches(string input, string pattern): 查找输入字符串中所有匹配模式的子串，返回一个 MatchCollection 对象。
  • static MatchCollection Matches(string input, string pattern, RegexOptions options): 同上，带选项。
  • static string Replace(string input, string pattern, string replacement): 在输入字符串中查找所有匹配模式的子串，并用指定的替换字符串替换它们。
  • static string Replace(string input, string pattern, string replacement, RegexOptions options): 同上，带选项。
  • static string Replace(string input, string pattern, MatchEvaluator evaluator): 使用一个委托来动态生成替换字符串。
  • static string[] Split(string input, string pattern): 使用匹配模式的子串作为分隔符，将输入字符串分割成字符串数组。
  • static string[] Split(string input, string pattern, RegexOptions options): 同上，带选项。

• 实例方法: 这些方法在创建 Regex 实例后调用，通常用于多次使用同一个模式。

  • bool IsMatch(string input)
  • bool IsMatch(string input, int startindex)
  • Match Match(string input)
  • Match Match(string input, int startindex)
  • Match Match(string input, int startindex, int length)
  • MatchCollection Matches(string input)
  • MatchCollection Matches(string input, int startindex)
  • MatchCollection Matches(string input, int startindex, int length)
  • string Replace(string input, string replacement)
  • string Replace(string input, string replacement, int count)
  • string Replace(string input, string replacement, int count, int startindex)
  • string Replace(string input, MatchEvaluator evaluator)
  • string Replace(string input, MatchEvaluator evaluator, int count)
  • string Replace(string input, MatchEvaluator evaluator, int count, int startindex)
  • string[] Split(string input)
  • string[] Split(string input, int count)
  • string[] Split(string input, int count, int startindex)

2. RegexOptions 枚举

RegexOptions 枚举提供了多个选项来控制正则表达式的匹配行为：

• None: 使用默认行为。
• IgnoreCase: 不区分大小写匹配。
• Multiline: 使 ^ 和 $ 匹配每一行的开头和结尾（由 \n 定义），而不仅仅是整个字符串的开头和结尾。
• Singleline: 使 . 匹配包括 \n 在内的所有字符。
• ExplicitCapture: 禁用默认的捕获行为，只有命名或编号的分组 ((...)) 才会被捕获。
• Compiled: 将正则表达式编译为更快的委托。这会增加初始化时间，但对于频繁使用的模式，后续匹配速度会更快。
• IgnorePatternWhitespace: 忽略模式字符串中的未转义的空白字符和以 # 开头的注释。这有助于编写更易读的复杂模式。
• RightToLeft: 从右向左进行搜索。

3. Match 类

Match 对象表示一次成功的匹配结果。

• bool Success: 指示匹配是否成功。
• string Value: 获取匹配到的子串。
• int Index: 获取匹配到的子串在输入字符串中的起始索引。
• int Length: 获取匹配到的子串的长度。
• GroupCollection Groups: 获取所有捕获的组的集合。索引 0 的 Group 对象代表整个匹配（即 Match.Value）。

4. Group 和 Capture 类

• Group 类代表一个捕获组的结果。它是 Match 对象的 Groups 集合中的元素。

  • bool Success: 指示该组是否成功匹配并捕获（即使捕获到空字符串）。
  • string Value: 获取该组捕获的子串。
  • int Index: 获取该组捕获的子串在输入字符串中的起始索引。
  • int Length: 获取该组捕获的子串的长度。
  • CaptureCollection Captures: 获取该组在输入字符串中所有成功匹配的子串的集合（当一个组在模式中被量词修饰并多次匹配时，会有多个 Capture）。

• Capture 类代表一次单独的捕获结果。Group.Captures 集合包含了该组所有独立的捕获。对于大多数情况，一个组只有一次捕获，此时 Group.Value 等于 Group.Captures[0].Value。

5. MatchCollection 类

MatchCollection 是由 Regex.Matches 方法返回的一个集合，包含所有成功的 Match 对象。它实现了 IEnumerable 接口，可以通过 foreach 循环遍历。

第三部分：C# 正则表达式实践

下面通过一些 C# 代码示例来展示如何使用 Regex 类进行常见的文本处理任务。

为了方便编写正则表达式模式，特别是包含大量反斜杠时，强烈推荐使用 C# 的逐字字符串（Verbatim Strings），即在字符串前加 @ 符号。例如，@"c:\path\to\file" 比 "c:\\path\\to\\file" 更清晰。正则表达式中的反斜杠 \ 在逐字字符串中仍然需要转义（用于正则表达式语法本身），但在 C# 字符串层面不需要额外的反斜杠转义。例如，匹配数字的模式 \d+ 在代码中写为 Regex regex = new Regex(@"\d+");。

示例 1: 检查字符串是否符合模式 (IsMatch)

“`csharp
using System;
using System.Text.RegularExpressions;

public class RegexExamples
{
public static void Main(string[] args)
{
string emailPattern = @”^[^@\s]+@[^@\s]+.[^@\s]+$”; // 简化的邮箱模式
string[] emails = { “[email protected]”, “invalid-email”, “[email protected]” };

    Console.WriteLine("--- Checking Email Format ---");
    foreach (string email in emails)
    {
        bool isMatch = Regex.IsMatch(email, emailPattern);
        Console.WriteLine($"'{email}' is a valid email format? {isMatch}");
    }

    // 使用实例方法和选项
    string datePattern = @"^\d{4}-\d{2}-\d{2}$"; // YYYY-MM-DD
    Regex dateRegex = new Regex(datePattern);
    string dateString = "2023-10-27";
    Console.WriteLine($"'{dateString}' is YYYY-MM-DD format? {dateRegex.IsMatch(dateString)}");

    string caseInsensitivePattern = @"hello";
    string text = "Hello World";
    Regex caseInsensitiveRegex = new Regex(caseInsensitivePattern, RegexOptions.IgnoreCase);
    Console.WriteLine($"'{text}' contains '{caseInsensitivePattern}' (case-insensitive)? {caseInsensitiveRegex.IsMatch(text)}");
}

}
“`

示例 2: 查找第一个匹配项并提取信息 (Match)

“`csharp
using System;
using System.Text.RegularExpressions;

public class RegexMatchExample
{
public static void Main(string[] args)
{
string text = “Contact us at [email protected] or call +1 (123) 456-7890.”;
// 模式：查找一个简化的邮箱地址，捕获用户名和域名
string pattern = @”(\w+)@([\w.-]+)”; // (\w+): 捕获用户名, ([\w.-]+): 捕获域名 (包含子域和点号)

    Match match = Regex.Match(text, pattern);

    Console.WriteLine("--- Finding First Email ---");
    if (match.Success)
    {
        Console.WriteLine("Match Found:");
        Console.WriteLine($"  Full Match: {match.Value}");
        Console.WriteLine($"  Index: {match.Index}");
        Console.WriteLine($"  Length: {match.Length}");

        // 访问捕获组
        Console.WriteLine($"  Groups Count: {match.Groups.Count}"); // Group[0] 是整个匹配
        if (match.Groups.Count > 1) // Group[1] 是第一个捕获组 (用户名)
        {
            Console.WriteLine($"  Username (Group 1): {match.Groups[1].Value}");
            Console.WriteLine($"  Domain (Group 2): {match.Groups[2].Value}");
        }

        // 遍历所有捕获组
        Console.WriteLine("  Iterating through Groups:");
        for (int i = 0; i < match.Groups.Count; i++)
        {
             Group group = match.Groups[i];
             Console.WriteLine($"    Group {i}: Value='{group.Value}', Index={group.Index}, Length={group.Length}");
             // 对于 Group[0] 以外的组，通常只有一个 Capture，其信息与 Group 本身一致
             // 如果一个组被量词多次匹配 (不常见)，Captures 集合会包含多个 Capture 对象
             if (group.Captures.Count > 1)
             {
                  Console.WriteLine($"      Captures ({group.Captures.Count}):");
                  foreach (Capture capture in group.Captures)
                  {
                       Console.WriteLine($"        Value='{capture.Value}', Index={capture.Index}, Length={capture.Length}");
                  }
             }
        }
    }
    else
    {
        Console.WriteLine("No email found.");
    }
}

}
“`

示例 3: 查找所有匹配项 (Matches)

“`csharp
using System;
using System.Text.RegularExpressions;

public class RegexMatchesExample
{
public static void Main(string[] args)
{
string html = “

This is bold text.

And this is italic.

“;
// 模式：查找 HTML 标签 (简化的例子)
string tagPattern = @”<.*?>”; // 非贪婪匹配 <…>

    MatchCollection matches = Regex.Matches(html, tagPattern);

    Console.WriteLine("--- Finding All HTML Tags ---");
    if (matches.Count > 0)
    {
        Console.WriteLine($"Found {matches.Count} tags:");
        foreach (Match match in matches)
        {
            Console.WriteLine($"  Tag: {match.Value} (at index {match.Index})");
            // 对于没有捕获组的模式，match.Groups[0] 就是整个匹配
        }
    }
    else
    {
        Console.WriteLine("No tags found.");
    }

    // 查找所有数字
    string numbersText = "The numbers are 123, 45, and 67890.";
    string numberPattern = @"\d+";
    MatchCollection numberMatches = Regex.Matches(numbersText, numberPattern);

    Console.WriteLine("\n--- Finding All Numbers ---");
    Console.WriteLine($"Found {numberMatches.Count} numbers:");
    foreach (Match match in numberMatches)
    {
         Console.WriteLine($"  Number: {match.Value}");
    }
}

}
“`

示例 4: 替换匹配项 (Replace)

“`csharp
using System;
using System.Text.RegularExpressions;

public class RegexReplaceExample
{
public static void Main(string[] args)
{
string text = “This is a sample text with some words to censor, like ‘bad’ and ‘ugly’.”;
string pattern = @”\b(bad|ugly)\b”; // 查找独立的 “bad” 或 “ugly” 单词
string replacement = “***”;

    Console.WriteLine("--- Replacing Words ---");
    string censoredText = Regex.Replace(text, pattern, replacement, RegexOptions.IgnoreCase); // 不区分大小写替换
    Console.WriteLine($"Original: {text}");
    Console.WriteLine($"Censored: {censoredText}");

    // 使用捕获组和替换模式
    string filePath = @"c:\Users\Username\Documents\file.txt";
    // 模式：捕获路径、文件名和扩展名
    string filePathPattern = @"^(?<Path>.*?)[\\/](?<FileName>[^\\/.]+)\.(?<Extension>[^.]+)$";
    string newPathFormat = @"/mnt/data/${FileName}.${Extension}"; // 使用命名组替换

    Match fileMatch = Regex.Match(filePath, filePathPattern);
    if (fileMatch.Success)
    {
         // 替换模式可以使用 $n (编号组) 或 ${name} (命名组)
         string reformattedPath = fileMatch.Result(newPathFormat); // Result 方法也方便进行基于捕获的替换
         // 或者使用 Regex.Replace 的 overload，但 Match.Result 更适合单个匹配的格式化
         // string reformattedPath2 = Regex.Replace(filePath, filePathPattern, newPathFormat);
         Console.WriteLine("\n--- Reformatting File Path ---");
         Console.WriteLine($"Original: {filePath}");
         Console.WriteLine($"Reformatted: {reformattedPath}");

         // 也可以使用 Regex.Replace 静态方法直接替换
         string examplePath = @"/usr/local/bin/my_script.sh";
         // 模式：查找目录 `/usr/local/bin` 并替换为 `/opt/app`
         string pathReplacePattern = @"^/usr/local/bin(?=/)"; // 使用先行断言匹配但不包含 `/`
         string replacedPath = Regex.Replace(examplePath, pathReplacePattern, @"/opt/app");
         Console.WriteLine("\n--- Direct Path Replacement ---");
         Console.WriteLine($"Original: {examplePath}");
         Console.WriteLine($"Replaced: {replacedPath}");
    }

    // 使用 MatchEvaluator 进行动态替换
    string numbers = "The numbers are 10, 25, 100.";
    // 将每个数字加 1
    string incrementedNumbers = Regex.Replace(numbers, @"\d+", match => (int.Parse(match.Value) + 1).ToString());
    Console.WriteLine("\n--- Dynamic Replacement (Incrementing Numbers) ---");
    Console.WriteLine($"Original: {numbers}");
    Console.WriteLine($"Incremented: {incrementedNumbers}");
}

}
“`

示例 5: 分割字符串 (Split)

“`csharp
using System;
using System.Text.RegularExpressions;

public class RegexSplitExample
{
public static void Main(string[] args)
{
string data = “Apple, Banana; Orange\tGrape”;
// 模式：使用逗号、分号或制表符作为分隔符
string separatorPattern = @”[,\;\t]”;

    Console.WriteLine("--- Splitting String ---");
    string[] items = Regex.Split(data, separatorPattern);

    Console.WriteLine("Items found:");
    foreach (string item in items)
    {
        Console.WriteLine($"- {item.Trim()}"); // 使用 Trim() 去除可能存在的空白
    }

    // 使用多个连续的分隔符或包含空白的分隔符
    string dataWithSpaces = "Item1 ,  Item2;Item3   \t Item4";
    // 模式：匹配一个或多个空白字符，后跟一个或多个分隔符，再后跟一个或多个空白字符
    string complexSeparator = @"\s*[,\;\t]\s*";
    string[] complexItems = Regex.Split(dataWithSpaces, complexSeparator);

    Console.WriteLine("\n--- Splitting String with Complex Separators ---");
    Console.WriteLine("Items found:");
    foreach (string item in complexItems)
    {
        if (!string.IsNullOrWhiteSpace(item)) // 过滤掉可能因分隔符在开头/结尾/连续出现导致的空字符串
        {
             Console.WriteLine($"- {item.Trim()}");
        }
    }
}

}
“`

第四部分：高级主题与注意事项

1. 命名捕获组

除了使用数字索引，还可以使用命名捕获组，这可以提高模式的可读性。语法是 (?<name>...) 或 (?'name'...)。在 C# 中，通过 Match.Groups["name"] 来访问。

csharp
string pattern = @"^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$";
Match match = Regex.Match("2023-10-27", pattern);
if (match.Success)
{
string year = match.Groups["year"].Value;
string month = match.Groups["month"].Value;
string day = match.Groups["day"].Value;
Console.WriteLine($"Year: {year}, Month: {month}, Day: {day}");
}

2. RegexOptions.Compiled

对于需要多次使用的 Regex 模式，使用 RegexOptions.Compiled 选项创建 Regex 实例可以将模式编译成中间语言 (MSIL)，从而提高后续匹配操作的性能。但是，第一次创建和编译实例会花费更多时间。因此，对于只使用一两次的模式，静态方法更方便；对于需要重复使用的模式，创建编译的 Regex 实例并重用是更好的选择。

“`csharp
// 频繁使用的模式
private static readonly Regex PhoneNumberRegex = new Regex(@”^\d{3}-\d{3}-\d{4}$”, RegexOptions.Compiled);

public bool IsValidPhoneNumber(string number)
{
return PhoneNumberRegex.IsMatch(number);
}
“`

3. 性能考虑与灾难性回溯 (Catastrophic Backtracking)

正则表达式非常强大，但也可能带来性能问题，特别是对于设计不当的模式。一个常见的陷阱是“灾难性回溯”。当模式中包含嵌套的量词（如 (a+)+）或交错的量词（如 (a|a)* 或 (.+)*），并且匹配失败时，正则表达式引擎可能会尝试指数级数量的匹配可能性，导致 CPU 占用率飙升甚至程序无响应。

例如，模式 (a+)+b 应用于字符串 “aaaaaaaaaaaaaaaaaaaaaaaaaaaaac” (大量 a 后面跟着 c) 会非常慢，因为引擎会不断地尝试不同的分组和量词组合去匹配大量的 ‘a’，最终才发现无法匹配 ‘b’。

编写高效正则表达式的建议：

• 避免使用嵌套量词如 (x+)+。
• 避免使用点号 . 和星号 * 的组合 .* 除非确实需要匹配任意字符并确定其范围。尽可能使用更具体的字符类 \d+, [a-zA-Z]+ 或限定匹配范围的模式。
• 了解贪婪与惰性量词的区别，根据需要选择。
• 如果模式比较复杂且输入字符串可能很长，考虑使用 RegexOptions.Compiled。
• 对于非常复杂或嵌套层级很深的文本结构（如完整的 HTML/XML 解析），正则表达式可能不是最佳工具，专用的解析器通常更健壮和高效。
• 使用在线正则表达式测试工具（如 Regex101, RegExr）来测试你的模式，它们通常提供了性能分析和解释功能，可以帮助你发现潜在的性能问题。

4. 何时 不 使用正则表达式

虽然正则表达式功能强大，但并非万能或总是最佳选择。对于简单的任务，使用标准的字符串方法可能更清晰和高效：

• 检查字符串是否包含子串：使用 string.Contains().
• 检查字符串是否以特定前缀开头或后缀结尾：使用 string.StartsWith() 和 string.EndsWith().
• 简单的替换：使用 string.Replace().
• 简单的分割：使用 string.Split() (特别是使用字符数组作为分隔符时).

过度使用或滥用正则表达式可能导致代码难以阅读和维护，且容易引入性能问题。

第五部分：工具和资源

学习和使用正则表达式离不开实践和工具的帮助：

• 在线正则表达式测试工具:
  • Regex101: 提供详细的匹配解释、错误检测和性能分析。
  • RegExr: 交互式工具，提供语法参考和实时匹配。
• Microsoft Docs: 关于 System.Text.RegularExpressions 命名空间的官方文档是学习 C# 中 Regex API 的权威资源。
• Regex Tutorial: 许多网站提供正则表达式语法的详细教程，例如 regular-expressions.info。

结论

C# 中的正则表达式通过 System.Text.RegularExpressions 命名空间提供了强大而灵活的文本处理能力。掌握正则表达式的语法和 C# 中 Regex 类及相关对象的用法，能够极大地提高你在处理字符串时的效率和能力。

从基础的字面量和元字符，到量词、分组、特殊序列，再到 C# 中 IsMatch, Match, Matches, Replace, Split 等方法的应用，以及高级的命名组、编译选项和性能注意事项，理解这些概念并勤加实践，你就能自信地运用正则表达式解决各种复杂的字符串匹配和操作问题。

记住，强大的工具伴随着使用的责任。编写清晰、高效且易于维护的正则表达式模式是成为一名优秀开发者的重要一步。不断练习，利用可用的工具，你将能充分发挥正则表达式的威力。

---