信息
您所需的主题如下所示。但此主题未包含在此库中。

Regex 类

2013/12/13

表示不可变的正则表达式。

System.Object
  System.Text.RegularExpressions.Regex

Namespace:  System.Text.RegularExpressions
程序集:  System(位于 System.dll 中)

public class Regex

Regex 类型公开以下成员。

  名称说明
受保护的方法Regex()初始化 Regex 类的新实例。
公共方法Regex(String)为指定的正则表达式初始化并编译 Regex 类的一个新实例。
公共方法Regex(String, RegexOptions)用修改模式的选项为指定的正则表达式初始化并编译 Regex 类的一个新实例。
公共方法Regex(String, RegexOptions, TimeSpan)为指定的正则表达式初始化 Regex 类的新实例,并带有修改模式和值的选项,该值指定模式匹配的方法应在超时前多久尝试匹配。
返回顶部

  名称说明
公共属性静态成员CacheSize获取或设置已编译的正则表达式的当前静态缓存中的最大项数。
公共属性MatchTimeout获取当前实例的超时间隔。
公共属性Options返回传入 Regex 构造函数的选项。
公共属性RightToLeft获取一个值,该值指示正则表达式是否从右向左进行搜索。
返回顶部

  名称说明
公共方法Equals(Object)确定指定的 Object 是否等于当前的 Object (从 Object 继承。)
公共方法静态成员Escape通过替换为转义码来转义最小的字符集(\、*、+、?、|、{、[、(、)、^、$、.、# 和空白)。这将指示正则表达式引擎按原义解释这些字符而不是解释为元字符。
受保护的方法Finalize允许 Object 在垃圾回收器回收该对象之前尝试释放资源并执行其他清理操作。 (从 Object 继承。)
公共方法GetGroupNames返回正则表达式的捕获组名称的数组。
公共方法GetGroupNumbers返回与数组中的组名称相对应的捕获组号的数组。
公共方法GetHashCode用作特定类型的哈希函数。 (从 Object 继承。)
公共方法GetType获取当前实例的 Type (从 Object 继承。)
公共方法GroupNameFromNumber获取与指定组号相对应的组名称。
公共方法GroupNumberFromName返回与指定组名称相对应的组号。
公共方法IsMatch(String)指示 Regex 构造函数中指定的正则表达式在输入字符串中是否找到匹配项。
公共方法IsMatch(String, Int32)指示 Regex 构造函数中指定的正则表达式从输入字符串的指定起始位置开始是否找到匹配项。
公共方法静态成员IsMatch(String, String)指示正则表达式使用 pattern 参数中指定的正则表达式是否在输入字符串中找到匹配项。
公共方法静态成员IsMatch(String, String, RegexOptions)指示正则表达式使用 pattern 参数中指定的正则表达式和 options 参数中提供的匹配选项是否在输入字符串中找到匹配项。
公共方法静态成员IsMatch(String, String, RegexOptions, TimeSpan)指示所指定的正则表达式是否使用指定的匹配选项和超时间隔在指定的输入字符串中找到了匹配项。
公共方法Match(String)在指定的输入字符串中搜索 Regex 构造函数中指定的正则表达式的第一个匹配项。
公共方法Match(String, Int32)从指定的输入字符串起始位置开始在输入字符串中搜索正则表达式的第一个匹配项。
公共方法静态成员Match(String, String)在指定的输入字符串中搜索 pattern 参数中提供的正则表达式的第一个匹配项。
公共方法Match(String, Int32, Int32)从指定的输入字符串起始位置开始在输入字符串中搜索具有指定输入字符串长度的正则表达式的第一个匹配项。
公共方法静态成员Match(String, String, RegexOptions)在输入字符串中搜索 pattern 参数中提供的正则表达式的第一个匹配项(匹配选项在 options 参数中提供)。
公共方法静态成员Match(String, String, RegexOptions, TimeSpan)使用指定的匹配选项和超时间隔在输入字符串中搜索指定的正则表达式的第一个匹配项。
公共方法Matches(String)在指定的输入字符串中搜索正则表达式的所有匹配项。
公共方法Matches(String, Int32)从字符串中的指定起始位置开始,在指定的输入字符串中搜索正则表达式的所有匹配项。
公共方法静态成员Matches(String, String)在指定的输入字符串中搜索 pattern 参数中指定的正则表达式的所有匹配项。
公共方法静态成员Matches(String, String, RegexOptions)在指定的输入字符串中搜索 pattern 参数中提供的正则表达式的所有匹配项(匹配选项在 options 参数中提供)。
公共方法静态成员Matches(String, String, RegexOptions, TimeSpan)使用指定的匹配选项和超时间隔在指定的输入字符串中搜索指定的正则表达式的所有匹配项。
受保护的方法MemberwiseClone创建当前 Object 的浅表副本。 (从 Object 继承。)
公共方法Replace(String, String)在指定的输入字符串内,使用指定的替换字符串替换与某个正则表达式模式匹配的所有字符串。
公共方法Replace(String, MatchEvaluator)在指定的输入字符串内,使用 MatchEvaluator 委托返回的字符串替换与指定正则表达式匹配的所有字符串。
公共方法Replace(String, String, Int32)在指定输入字符串内,使用指定替换字符串替换与某个正则表达式模式匹配的字符串(其数目为指定的最大数目)。
公共方法静态成员Replace(String, String, String)在指定的输入字符串内,使用指定的替换字符串替换与指定正则表达式匹配的所有字符串。
公共方法静态成员Replace(String, String, MatchEvaluator)在指定的输入字符串内,使用 MatchEvaluator 委托返回的字符串替换与指定正则表达式匹配的所有字符串。
公共方法Replace(String, MatchEvaluator, Int32)在指定的输入字符串内,使用 MatchEvaluator 委托返回的字符串替换与某个正则表达式模式匹配的字符串(其数目为指定的最大数目)。
公共方法Replace(String, String, Int32, Int32)在指定输入子字符串内,使用指定替换字符串替换与某个正则表达式模式匹配的字符串(其数目为指定的最大数目)。
公共方法静态成员Replace(String, String, String, RegexOptions)在指定的输入字符串内,使用指定的替换字符串替换与指定正则表达式匹配的所有字符串。指定的选项将修改匹配操作。
公共方法静态成员Replace(String, String, MatchEvaluator, RegexOptions)在指定的输入字符串内,使用 MatchEvaluator 委托返回的字符串替换与指定正则表达式匹配的所有字符串。指定的选项将修改匹配操作。
公共方法Replace(String, MatchEvaluator, Int32, Int32)在指定的输入子字符串内,使用 MatchEvaluator 委托返回的字符串替换与某个正则表达式模式匹配的字符串(其数目为指定的最大数目)。
公共方法静态成员Replace(String, String, String, RegexOptions, TimeSpan)在指定的输入字符串内,使用指定的替换字符串替换与指定正则表达式匹配的所有字符串。附加的参数指定在没有找到匹配时将修改匹配操作和超时间隔的选项。
公共方法静态成员Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)在指定的输入字符串内,使用 MatchEvaluator 委托返回的字符串替换与指定正则表达式匹配的所有子字符串。其他参数指定修改匹配操作以及在未找到匹配时修改超时时间间隔的选项。
公共方法Split(String)在由 Regex 构造函数指定的正则表达式模式所定义的位置,拆分指定的输入字符串。
公共方法Split(String, Int32)在由 Regex 构造函数中指定的正则表达式定义的位置,将指定的输入字符串拆分指定的最大次数。
公共方法静态成员Split(String, String)在由正则表达式模式定义的位置拆分输入字符串。
公共方法Split(String, Int32, Int32)在由 Regex 构造函数中指定的正则表达式定义的位置,将指定的输入字符串拆分指定的最大次数。从输入字符串的指定字符位置开始搜索正则表达式模式。
公共方法静态成员Split(String, String, RegexOptions)在由指定的正则表达式模式定义的位置拆分输入字符串。指定的选项将修改匹配操作。
公共方法静态成员Split(String, String, RegexOptions, TimeSpan)在由指定的正则表达式模式定义的位置将输入字符串拆分为一个子字符串数组。其他参数指定修改匹配操作以及在未找到匹配时修改超时时间间隔的选项。
公共方法ToString返回传入 Regex 构造函数的正则表达式模式。 (重写 Object.ToString()。)
公共方法静态成员Unescape取消转义输入字符串中的任何转义字符。
受保护的方法UseOptionR基础结构。 由正则表达式引擎在内部使用。
返回顶部

  名称说明
受保护的字段capsize基础结构。 由正则表达式引擎在内部使用。
受保护的字段capslist基础结构。 由正则表达式引擎在内部使用。
公共字段静态成员InfiniteMatchTimeout指定模式匹配的操作不应超时。
受保护的字段pattern基础结构。 由正则表达式引擎在内部使用。
受保护的字段roptions基础结构。 由正则表达式引擎在内部使用。
返回顶部

Regex 类表示 .NET Framework 的正则表达式引擎。可以使用该类快速分析大量文本,以查找特定字符模式;验证文本,提取、编辑、替换或删除文本子字符串;或者将提取的字符串添加到集合中以生成报告。

若要使用正则表达式,应使用 .NET Framework 文档的 Regular Expression Language Elements(正则表达式语言元素)中介绍的语法,定义您要在文本流中标识的模式。接下来,您可以选择实例化 Regex 对象。最后,执行某种操作,如替换与正则表达式模式匹配的文本或标识模式匹配。

正则表达式与字符串方法

System.String 类包括多种搜索和比较方法,可用于执行模式与文本的匹配。例如,String.ContainsString.EndsWithString.StartsWith 方法确定字符串实例是否包含指定的子字符串;String.IndexOfString.IndexOfAnyString.LastIndexOfString.LastIndexOfAny 方法返回字符串中指定的子字符串的起始位置。搜索特定字符串时,使用 System.String 类的方法。搜索字符串中的特定模式时,使用 Regex 类。有关更多信息和示例,请参见 [521b3f6d-f869-42e1-93e5-158c54a6895d]

静态方法与实例方法

定义正则表达式模式之后,可以使用以下两种方式之一将其提供给正则表达式引擎。

  • 实例化表示正则表达式的 Regex 对象。若要执行此操作,应将正则表达式模式传递给 Regex 构造函数。Regex 对象是不可变的;当您使用正则表达式实例化 Regex 对象时,将无法更改该对象的正则表达式。

  • static(在 Visual Basic 中为 SharedRegex 方法同时提供正则表达式和要搜索的文本。这使您无需显式创建 Regex 对象即可使用正则表达式。

所有 Regex 模式标识方法均同时包括静态重载和实例重载。

正则表达式引擎必须编译一个特定模式,然后才可以使用此模式。因为 Regex 对象是不可变的,所以在调用 Regex 类构造函数时(或在调用静态方法时),只执行一次此过程。为了避免重复编译单个正则表达式,正则表达式引擎将缓存在静态方法调用中所使用的已编译正则表达式。因此,正则表达式模式匹配方法为静态方法和实例方法提供了同等的性能。

但是,由正则表达式引擎实现的缓存系统在以下两种情况下可能对性能产生不利影响:

  • 当使用大量的正则表达式进行静态方法调用时。默认情况下,正则表达式引擎将缓存 15 个最近使用的静态正则表达式。如果应用程序使用的静态正则表达式超过 15 个,则必须重新编译某些正则表达式。为了防止执行此类重新编译,您可以将 Regex.CacheSize 属性增加到适当的值。

  • 当应用程序使用先前已编译的正则表达式实例化新的 Regex 对象时。例如,下面的代码定义一个正则表达式,以定位某个文本流的各个行中重复的单词。虽然本示例使用一个正则表达式,但它将实例化一个新的 Regex 对象来处理每行文本。这将导致在每次循环迭代时都重新编译此正则表达式。

    
    string[] inputs = { "This this is a typo.", 
                        "They said that that man would come." };
    string pattern = @"\b(\w+)\s\1\b";
    foreach (string input in inputs)
    {
       Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          outputBlock.Text += String.Format("{0} ({1} matches):", input, matches.Count) + "\n";
          foreach (Match match in matches)
             outputBlock.Text += "   " + match.Value + "\n";
       }
    }
    
    
    

    若要防止重新编译,此应用程序应实例化一个 Regex 对象,该对象供需要它的所有代码访问,如以下重写示例所示。

    
    string[] inputs = { "This this is a typo.", 
                        "They said that that man would come." };
    string pattern = @"\b(\w+)\s\1\b";
    Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
    
    foreach (string input in inputs)
    {
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          outputBlock.Text += String.Format("{0} ({1} matches):", input, matches.Count) + "\n";
          foreach (Match match in matches)
             outputBlock.Text += "   " + match.Value + "\n";
       }
    }
    
    
    

执行正则表达式操作

无论您决定是实例化一个 Regex 对象并调用其方法,还是调用静态方法,Regex 类都将提供以下模式匹配功能:

  • 验证匹配。您可以调用 IsMatch 方法以确定是否存在匹配。

  • 检索单个匹配。您可以调用 Match 方法来检索 Match 对象,该对象表示字符串或字符串一部分中的第一个匹配项。后续匹配项可以通过调用 Match.NextMatch 方法进行检索。

  • 检索所有匹配。您可以调用 Matches 方法来检索 System.Text.RegularExpressions.MatchCollection 对象,该对象表示在字符串或字符串一部分中找到的所有匹配项。

  • 替换匹配的文本。您可以调用 Replace 方法来替换匹配的文本。此替换文本还可通过正则表达式来定义。此外,某些 Replace 方法包括一个 MatchEvaluator 参数,该参数使您能够以编程方式定义替换文本。

  • 创建字符串数组,该数组是由输入字符串的各个部分构成。您可以调用 Split 方法,在正则表达式定义的位置拆分输入字符串。

除了其匹配模式方法之外,Regex 类还包括几种特殊用途的方法:

  • Escape 方法可以对任何在正则表达式或输入字符串中可能被解释为正则表达式运算符的字符进行转义。

  • Unescape 方法移除这些转义字符。

下面的示例使用正则表达式检查字符串中重复出现的词。正则表达式 \b(?<word>\w+)\s+(\k<word>)\b 可按下表中的方式解释。

模式

说明

\b

从单词边界开始匹配。

(?<word>\w+)

匹配一个或多个单词字符(最多可到单词边界)。将此捕获组命名为 word

\s+

匹配一个或多个空白字符。

(\k<word>)

匹配名为 word 的捕获组。

\b

与字边界匹配。

说明注意:

有关如何编译和运行此示例代码的信息,请参见生成具有静态 Windows Phone TextBlock 控件的示例


using System;
using System.Text.RegularExpressions;

public class Example
{

   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {

      // Define a regular expression for repeated words.
      Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
                           RegexOptions.IgnoreCase);

      // Define a test string.        
      string text = "The the quick brown fox  fox jumped over the lazy dog dog.";

      // Find matches.
      MatchCollection matches = rx.Matches(text);

      // Report the number of matches found.
      outputBlock.Text += String.Format("{0} matches found in:\n   {1}",
                        matches.Count,
                        text) + "\n";

      // Report on each match.
      foreach (Match match in matches)
      {
         GroupCollection groups = match.Groups;
         outputBlock.Text += String.Format("'{0}' repeated at positions {1} and {2}",
                           groups["word"].Value,
                           groups[0].Index,
                           groups[1].Index) + "\n";
      }

   }

}
// The example produces the following output:
//       3 matches found in:
//          The the quick brown fox  fox jumped over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54


下面的示例演示如何使用正则表达式来检查字符串是表示货币值还是具有表示货币值的正确格式。在这种情况下,将从用户的当前区域性的 NumberFormatInfo.CurrencyDecimalSeparatorCurrencyDecimalDigitsNumberFormatInfo.CurrencySymbolNumberFormatInfo.NegativeSignNumberFormatInfo.PositiveSign 属性中动态生成正则表达式。如果系统的当前区域性为 en-US,则所生成的正则表达式为 ^\w*[\+-]?\w?\$?\w?(\d*\.?\d{2}?){1}$。此正则表达式可按下表中所示进行解释。

模式

说明

^

在字符串的开头处开始。

\s*

匹配零个或多个空白字符。

[\+-]?

匹配正号或负号的零个或一个匹配项。

\s?

匹配零个或一个空白字符。

\$?

匹配美元符号的零个或一个匹配项。

\s?

匹配零个或一个空白字符。

\d*

匹配零个或多个十进制数字。

\.?

匹配零个或一个小数点符号。

\d{2}?

匹配两位十进制数零次或一次。

(\d*\.?\d{2}?){1}

至少匹配一次由小数点符号分隔整数和小数的模式。

$

匹配字符串的末尾部分。

在这种情况下,正则表达式假定有效货币字符串不包括组分隔符,并且此字符串既没有小数数字,也没有由当前区域性的 CurrencyDecimalDigits 属性定义的小数位数。

说明注意:

有关如何编译和运行此示例代码的信息,请参见生成具有静态 Windows Phone TextBlock 控件的示例


using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      // Get the current NumberFormatInfo object to build the regular 
      // expression pattern dynamically.
      NumberFormatInfo nfi = NumberFormatInfo.CurrentInfo;

      // Define the regular expression pattern.
      string pattern;
      pattern = @"^\s*[";
      // Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + @"]?\s?";
      // Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + @"?\s?";
      // Add integral digits to the pattern.
      pattern += @"(\d*";
      // Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?";
      // Add the fractional digits.
      pattern += @"\d{";
      // Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "}?){1}$";

      Regex rgx = new Regex(pattern);

      // Define some test strings.
      string[] tests = { "-42", "19.99", "0.001", "100 USD", 
                         ".34", "0.34", "1,052.21", "$10.62", 
                         "+1.43", "-$0.23" };

      // Check each test string against the regular expression.
      foreach (string test in tests)
      {
         if (rgx.IsMatch(test))
            outputBlock.Text += String.Format("{0} is a currency value.", test) + "\n";
         else
            outputBlock.Text += String.Format("{0} is not a currency value.", test) + "\n";
      }
   }
}
// The example displays the following output:
//       -42 is a currency value.
//       19.99 is a currency value.
//       0.001 is not a currency value.
//       100 USD is not a currency value.
//       .34 is a currency value.
//       0.34 is a currency value.
//       1,052.21 is not a currency value.
//       $10.62 is a currency value.
//       +1.43 is a currency value.
//       -$0.23 is a currency value.


因为本示例中的正则表达式是动态生成的,所以在设计时我们不知道正则表达式引擎是否可能将当前区域性的货币符号、小数符号或正号及负号错误解释为正则表达式语言运算符。若要防止任何解释错误,本示例将每个动态生成的字符串传递到 Escape 方法。

Windows Phone OS

受以下版本支持: 8.0, 7.1, 7.0

Windows Phone

Regex 类是不可变(只读)的,并且具有固有的线程安全性。可以在任何线程上创建 Regex 对象,并在线程间共享。匹配方法可以从任何线程调用,并且从不更改任何全局状态。但是,由 Regex 方法返回的结果对象(MatchMatchCollection)应在单个线程上使用。尽管其中许多对象是逻辑上不可变的,但这些对象的实现可以延迟一些结果的计算以提高性能;因此,调用方必须序列化对这些对象的访问。

显示: