.NET Framework 中的正則表達(dá)式引擎由 Regex 類表示。 正則表達(dá)式引擎負(fù)責(zé)分析和編譯正則表達(dá)式，并執(zhí)行用于將正則表達(dá)式模式與輸入字符串相匹配的操作。 此引擎是 .NET Framework 正則表達(dá)式對象模型中的主要組件。

可以通過以下兩種方式之一使用正則表達(dá)式引擎：

• 通過調(diào)用 Regex 類的靜態(tài)方法。 方法參數(shù)包含輸入字符串和正則表達(dá)式模式。 正則表達(dá)式引擎會緩存靜態(tài)方法調(diào)用中使用的正則表達(dá)式，這樣一來，重復(fù)調(diào)用使用同一正則表達(dá)式的靜態(tài)正則表達(dá)式方法將提供相對良好的性能。

• 通過實(shí)例化 Regex 對象，采用的方式是將一個(gè)正則表達(dá)式傳遞給類構(gòu)造函數(shù)。 在此情況下，Regex 對象是不可變的（只讀），它表示一個(gè)與單個(gè)正則表達(dá)式緊密耦合的正則表達(dá)式引擎。 由于未對 Regex 實(shí)例使用的正則表達(dá)式進(jìn)行緩存，因此不應(yīng)使用同一正則表達(dá)式實(shí)例化 Regex 對象多次。

可以調(diào)用 Regex 類的方法來執(zhí)行下列操作：

• 確定字符串是否與正則表達(dá)式模式匹配。

• 提取單個(gè)匹配項(xiàng)或第一個(gè)匹配項(xiàng)。

• 提取所有匹配項(xiàng)。

• 替換匹配的子字符串。

• 將單個(gè)字符串拆分成一個(gè)字符串?dāng)?shù)組。

以下各部分對這些操作進(jìn)行了描述。

匹配正則表達(dá)式模式

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] values = { "111-22-3333", "111-2-3333"};
      string pattern = @"^\d{3}-\d{2}-\d{4}$";
      foreach (string value in values) {
         if (Regex.IsMatch(value, pattern))
            Console.WriteLine("{0} is a valid SSN.", value);
         else   
            Console.WriteLine("{0}: Invalid", value);
      }
   }
}
// The example displays the following output:
//       111-22-3333 is a valid SSN.
//       111-2-3333: Invalid

提取單個(gè)匹配項(xiàng)或第一個(gè)匹配項(xiàng)

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a a farm that that raises dairy cattle."; 
      string pattern = @"\b(\w+)\W+(\1)\b";
      Match match = Regex.Match(input, pattern);
      while (match.Success)
      {
         Console.WriteLine("Duplicate '{0}' found at position {1}.",  
                           match.Groups[1].Value, match.Groups[2].Index);
         match = match.NextMatch();
      }                       
   }
}
// The example displays the following output:
//       Duplicate 'a' found at position 10.
//       Duplicate 'that' found at position 22.

提取所有匹配項(xiàng)

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a a farm that that raises dairy cattle."; 
      string pattern = @"\b(\w+)\W+(\1)\b";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Duplicate '{0}' found at position {1}.",  
                           match.Groups[1].Value, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'a' found at position 10.
//       Duplicate 'that' found at position 22.

替換匹配的子字符串

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\d+\.\d{2}\b";
      string replacement = "$$$&"; 
      string input = "Total Cost: 103.64";
      Console.WriteLine(Regex.Replace(input, pattern, replacement));     
   }
}
// The example displays the following output:
//       Total Cost: $103.64

將單個(gè)字符串拆分成一個(gè)字符串?dāng)?shù)組

Regex.Split 方法在由正則表達(dá)式匹配項(xiàng)定義的位置拆分輸入字符串。 例如，下面的代碼將編號列表中的項(xiàng)置于字符串?dāng)?shù)組中。

VB

C#

C++

F#

JScript

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea";
      string pattern = @"\b\d{1,2}\.\s";
      foreach (string item in Regex.Split(input, pattern))
      {
         if (! String.IsNullOrEmpty(item))
            Console.WriteLine(item);
      }      
   }
}
// The example displays the following output:
//       Eggs
//       Bread
//       Milk
//       Coffee
//       Tea

正則表達(dá)式模式 \b\d{1,2}\. \s is interpreted as shown in the following table.

模式	說明
\b	在單詞邊界處開始匹配。
\d{1,2}	匹配一個(gè)或兩個(gè)十進(jìn)制數(shù)字。
\.	匹配句點(diǎn)。
\s	與空白字符匹配。

Regex 方法返回作為正則表達(dá)式對象模型的一部分的兩個(gè)對象：MatchCollection 對象和 Match 對象。

Match 集合

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
       MatchCollection matches;
       List<string> results = new List<string>();
       List<int> matchposition = new List<int>();

       // Create a new Regex object and define the regular expression.
       Regex r = new Regex("abc");
       // Use the Matches method to find all matches in the input string.
       matches = r.Matches("123abc4abcd");
       // Enumerate the collection to retrieve all matches and positions.
       foreach (Match match in matches)
       {
          // Add the match string to the string array.
           results.Add(match.Value);
           // Record the character position where the match was found.
           matchposition.Add(match.Index);
       }
       // List the results.
       for (int ctr = 0; ctr < results.Count; ctr++)
         Console.WriteLine("'{0}' found at position {1}.", 
                           results[ctr], matchposition[ctr]);  
   }
}
// The example displays the following output:
//       'abc' found at position 3.
//       'abc' found at position 7.

Match 類

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\d+(,\d{3})*\.\d{2}\b";
      string input = "16.32\n194.03\n1,903,672.08"; 

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Result("$$ $&"));
   }
}
// The example displays the following output:
//       $ 16.32
//       $ 194.03
//       $ 1,903,672.08

Match.Groups 屬性返回一個(gè) GroupCollection 對象，該對象包含多個(gè) Group 對象，這些對象表示單個(gè)匹配項(xiàng)中的捕獲的組。 集合中的第一個(gè) Group 對象（位于索引 0 處）表示整個(gè)匹配項(xiàng)。 此對象后面的每個(gè)對象均表示一個(gè)捕獲組的結(jié)果。

可以使用 GroupCollection.Item 屬性檢索集合中的各個(gè) Group 對象。 可以在集合中按未命名組的序號位置來檢索未命名組，也可以按命名組的名稱或序號位置來檢索命名組。 未命名捕獲將首先在集合中顯示，并將按照未命名捕獲在正則表達(dá)式模式中出現(xiàn)的順序從左至右對它們進(jìn)行索引。 在對未命名捕獲進(jìn)行索引后，將按照命名捕獲在正則表達(dá)式模式中出現(xiàn)的順序從左至右對它們進(jìn)行索引。

GroupCollection.Item 屬性是集合的索引器（在 C# 中）和集合對象的默認(rèn)屬性（在 Visual Basic 中）。 這表示可以按索引（對于命名組，可以按名稱）訪問各個(gè) Group 對象，如下所示：

Group group = match.Groups[ctr];         

下面的示例定義一個(gè)正則表達(dá)式，該表達(dá)式使用分組構(gòu)造捕獲日期的年、月和日部分。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)\s(\d{1,2}),\s(\d{4})\b";
      string input = "Born: July 28, 1989";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
         for (int ctr = 0; ctr <  match.Groups.Count; ctr++)
            Console.WriteLine("Group {0}: {1}", ctr, match.Groups[ctr].Value);
    }
}
// The example displays the following output:
//       Group 0: July 28, 1989
//       Group 1: July
//       Group 2: 28
//       Group 3: 1989

正則表達(dá)式模式 \b(\w+)\s(\d{1,2}),\s(\d{4})\b 的定義如下表所示。

返回頁首

Group 類表示來自單個(gè)捕獲組的結(jié)果。 表示正則表達(dá)式中定義的捕獲組的組對象由 Match.Groups 屬性所返回的 GroupCollection 對象的 Item 屬性返回。 Item 屬性是索引器（在 C# 中）和 Group 類的默認(rèn)屬性（在 Visual Basic 中）。 也可以使用 foreach 或 ForEach 構(gòu)造循環(huán)訪問集合來檢索各個(gè)成員。 有關(guān)示例，請參見上一部分。

下面的示例使用嵌套的分組構(gòu)造來將子字符串捕獲到組中。 正則表達(dá)式模式 (a(b))c 將匹配字符串“abc”。 它會將子字符串“ab”分配給第一個(gè)捕獲組，并將子字符串“b”分配給第二個(gè)捕獲組。

List<int> matchposition = new List<int>();
List<string> results = new List<string>();
// Define substrings abc, ab, b.
Regex r = new Regex("(a(b))c"); 
Match m = r.Match("abdabc");
for (int i = 0; m.Groups[i].Value != ""; i++) 
{
   // Add groups to string array.
   results.Add(m.Groups[i].Value); 
   // Record character position.
   matchposition.Add(m.Groups[i].Index); 
}

// Display the capture groups.
for (int ctr = 0; ctr < results.Count; ctr++)
   Console.WriteLine("{0} at position {1}", 
                     results[ctr], matchposition[ctr]);
// The example displays the following output:
//       abc at position 3
//       ab at position 3
//       b at position 4

下面的示例使用命名的分組構(gòu)造，從包含“DATANAME:VALUE”格式的數(shù)據(jù)的字符串中捕獲子字符串，正則表達(dá)式通過冒號 (:) 拆分?jǐn)?shù)據(jù)。

Regex r = new Regex("^(?<name>\\w+):(?<value>\\w+)");
Match m = r.Match("Section1:119900");
Console.WriteLine(m.Groups["name"].Value);
Console.WriteLine(m.Groups["value"].Value);
// The example displays the following output:
//       Section1
//       119900

正則表達(dá)式模式 ^(?<name>\w+):(?<value>\w+) 的定義如下表所示。

Group 類的屬性提供有關(guān)捕獲的組的信息：Group.Value 屬性包含捕獲的子字符串，Group.Index 屬性指示輸入文本中捕獲的組的起始位置，Group.Length 屬性包含捕獲的文本的長度，Group.Success 屬性指示子字符串是否與捕獲組所定義的模式匹配。

通過對組應(yīng)用限定符（有關(guān)更多信息，請參見限定符），可以按兩種方式修改一個(gè)捕獲組對應(yīng)一個(gè)捕獲這樣的關(guān)系：

• 如果對組應(yīng)用 * 或 *? 限定符（將指定零個(gè)或多個(gè)匹配項(xiàng)），則捕獲組在輸入字符串中可能沒有匹配項(xiàng)。 在沒有捕獲的文本時(shí)，將如下表所示設(shè)置 Group 對象的屬性。

  組屬性	值
  Success	false
  Value	String.Empty
  Length	0

  下面的示例進(jìn)行了這方面的演示。 在正則表達(dá)式模式 aaa(bbb)*ccc 中，可以匹配第一個(gè)捕獲組（子字符串“bbb”）零次或多次。 由于輸入字符串“aaaccc”與此模式匹配，因此該捕獲組沒有匹配項(xiàng)。

  
  

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = "aaa(bbb)*ccc";
        string input = "aaaccc";
        Match match = Regex.Match(input, pattern);
        Console.WriteLine("Match value: {0}", match.Value);
        if (match.Groups[1].Success)
           Console.WriteLine("Group 1 value: {0}", match.Groups[1].Value);
        else
           Console.WriteLine("The first capturing group has no match.");
     }
  }
  // The example displays the following output:
  //       Match value: aaaccc
  //       The first capturing group has no match.
  
  
  

• 限定符可以匹配由捕獲組定義的模式的多個(gè)匹配項(xiàng)。 在此情況下，Group 對象的 Value 和 Length 屬性僅包含有關(guān)最后捕獲的子字符串的信息。 例如，下面的正則表達(dá)式匹配以句點(diǎn)結(jié)束的單個(gè)句子。 此表達(dá)式使用兩個(gè)分組構(gòu)造：第一個(gè)分組構(gòu)造捕獲各個(gè)單詞以及空白字符；第二個(gè)分組構(gòu)造捕獲各個(gè)單詞。 如示例中的輸出所示，雖然正則表達(dá)式成功捕獲整個(gè)句子，但第二個(gè)捕獲組僅捕獲了最后一個(gè)單詞。

  
  

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = @"\b((\w+)\s?)+\.";
        string input = "This is a sentence. This is another sentence.";
        Match match = Regex.Match(input, pattern);
        if (match.Success)
        {
           Console.WriteLine("Match: " + match.Value);
           Console.WriteLine("Group 2: " + match.Groups[2].Value);
        }   
     }
  }
  // The example displays the following output:
  //       Match: This is a sentence.
  //       Group 2: sentence
  
  
  

返回頁首

Group 對象僅包含有關(guān)最后一個(gè)捕獲的信息。 但仍可從 Group.Captures 屬性返回的 CaptureCollection 對象中獲取由捕獲組生成的整個(gè)捕獲集。 集合中的每個(gè)成員均為一個(gè)表示由該捕獲組生成的捕獲的 Capture 對象，這些對象按被捕獲的順序排列（因而也就是遵循在輸入字符串中按從左至右匹配捕獲的字符串的順序）。 可以通過以下兩種方式之一來檢索集合中的各個(gè) Capture 對象：

• 通過使用構(gòu)造循環(huán)訪問集合，如 foreach 構(gòu)造（在 C# 中）或 ForEach 構(gòu)造（在 Visual Basic 中）。

• 通過使用 CaptureCollection.Item 屬性按索引檢索特定對象。 Item 屬性是 CaptureCollection 對象的默認(rèn)屬性（在 Visual Basic 中）或索引器（在 C# 中）。

如果未對捕獲組應(yīng)用限定符，則 CaptureCollection 對象將包含一個(gè) Capture 對象，但該對象的作用不大，因?yàn)樗峁┑氖怯嘘P(guān)與其 Group 對象相同的匹配項(xiàng)的信息。 如果對一個(gè)捕獲組應(yīng)用限定符，則CaptureCollection 對象將包含該捕獲組所生成的所有捕獲，并且集合的最后一個(gè)成員將表示與 Group 對象相同的捕獲。

例如，如果使用正則表達(dá)式模式 ((a(b))c)+（其中，+ 限定符指定一個(gè)或多個(gè)匹配項(xiàng)）捕獲字符串“abcabcabc”中的匹配項(xiàng)，則每個(gè) Group 對象的 CaptureCollection 對象都將包含三個(gè)成員。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "((a(b))c)+";
      string input = "abcabcabc";

      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine("Match: '{0}' at position {1}",  
                           match.Value, match.Index);
         GroupCollection groups = match.Groups;
         for (int ctr = 0; ctr < groups.Count; ctr++) {
            Console.WriteLine("   Group {0}: '{1}' at position {2}", 
                              ctr, groups[ctr].Value, groups[ctr].Index);
            CaptureCollection captures = groups[ctr].Captures;
            for (int ctr2 = 0; ctr2 < captures.Count; ctr2++) {
               Console.WriteLine("      Capture {0}: '{1}' at position {2}", 
                                 ctr2, captures[ctr2].Value, captures[ctr2].Index);
            }                     
         }
      }
   }
}
// The example displays the following output:
//       Match: 'abcabcabc' at position 0
//          Group 0: 'abcabcabc' at position 0
//             Capture 0: 'abcabcabc' at position 0
//          Group 1: 'abc' at position 6
//             Capture 0: 'abc' at position 0
//             Capture 1: 'abc' at position 3
//             Capture 2: 'abc' at position 6
//          Group 2: 'ab' at position 6
//             Capture 0: 'ab' at position 0
//             Capture 1: 'ab' at position 3
//             Capture 2: 'ab' at position 6
//          Group 3: 'b' at position 7
//             Capture 0: 'b' at position 1
//             Capture 1: 'b' at position 4
//             Capture 2: 'b' at position 7

下面的示例使用正則表達(dá)式 (Abc)+ 來在字符串“XYZAbcAbcAbcXYZAbcAb”中查找字符串“Abc”的一個(gè)或多個(gè)連續(xù)匹配項(xiàng)。 該示例闡釋了使用 Group.Captures 屬性來返回多組捕獲的子字符串。

   int counter;
   Match m;
   CaptureCollection cc;
   GroupCollection gc;

   // Look for groupings of "Abc".
   Regex r = new Regex("(Abc)+"); 
   // Define the string to search.
   m = r.Match("XYZAbcAbcAbcXYZAbcAb"); 
   gc = m.Groups;

   // Display the number of groups.
   Console.WriteLine("Captured groups = " + gc.Count.ToString());

   // Loop through each group.
   for (int i=0; i < gc.Count; i++) 
   {
      cc = gc[i].Captures;
      counter = cc.Count;

      // Display the number of captures in this group.
      Console.WriteLine("Captures count = " + counter.ToString());

      // Loop through each capture in the group.
      for (int ii = 0; ii < counter; ii++) 
      {
         // Display the capture and its position.
         Console.WriteLine(cc[ii] + "   Starts at character " + 
              cc[ii].Index);
      }
   }
}
// The example displays the following output:
//       Captured groups = 2
//       Captures count = 1
//       AbcAbcAbc   Starts at character 3
//       Captures count = 3
//       Abc   Starts at character 3
//       Abc   Starts at character 6
//       Abc   Starts at character 9  

返回頁首