Regex 類別

定義

表示不變的規則運算式 (Regular Expression)。

public ref class Regex
public ref class Regex : System::Runtime::Serialization::ISerializable
public class Regex
public class Regex : System.Runtime.Serialization.ISerializable
[System.Serializable]
public class Regex : System.Runtime.Serialization.ISerializable
type Regex = class
type Regex = class
    interface ISerializable
[<System.Serializable>]
type Regex = class
    interface ISerializable
Public Class Regex
Public Class Regex
Implements ISerializable
繼承
Regex
衍生
屬性
實作

範例

下列範例會使用正則運算式來檢查字串中是否有重複出現的單字。 正則運算式 \b(?<word>\w+)\s+(\k<word>)\b 可以解譯如下表所示。

模式 描述
\b 在字邊界開始比對。
(?<word>\w+) 比對一或多個文字字元到字界限。 將此擷取的群組 word 命名為 。
\s+ 比對一或多個空白字元。
(\k<word>) 比對名為 word 的擷取群組。
\b 比對字邊界。
#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
   // Define a regular expression for repeated words.
   Regex^ rx = gcnew Regex( "\\b(?<word>\\w+)\\s+(\\k<word>)\\b",static_cast<RegexOptions>(RegexOptions::Compiled | RegexOptions::IgnoreCase) );

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

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

   // Report the number of matches found.
   Console::WriteLine( "{0} matches found.", matches->Count );

   // Report on each match.
   for each (Match^ match in matches)
   {
      String^ word = match->Groups["word"]->Value;
      int index = match->Index;
      Console::WriteLine("{0} repeated at position {1}", word, index);   
   }
}
using System;
using System.Text.RegularExpressions;

public class Test
{
    public static void Main ()
    {
        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

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

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

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}",
                          matches.Count,
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",
                              groups["word"].Value,
                              groups[0].Index,
                              groups[1].Index);
        }
    }
}

// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 49 and 53
Imports System.Text.RegularExpressions

Public Module Test

    Public Sub Main()
        ' Define a regular expression for repeated words.
        Dim rx As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches.
        Dim matches As MatchCollection = rx.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
    End Sub
End Module
' The example produces the following output to the console:
'       3 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'The' repeated at positions 0 and 4
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 49 and 53

下列範例說明如何使用正則運算式來檢查字串是否代表貨幣值,或具有正確的格式來表示貨幣值。 在此情況下,正則運算式是從使用者目前文化特性的 NumberFormatInfo.CurrencyDecimalSeparatorCurrencyDecimalDigitsNumberFormatInfo.CurrencySymbolNumberFormatInfo.NegativeSignNumberFormatInfo.PositiveSign 屬性動態建置。 如果系統的目前文化特性是 en-US,則產生的正則運算式為 ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$ 。 此正則運算式可以解譯,如下表所示。

模式 描述
^ 從字串開頭開始。
\s* 比對零個以上的空白字元。
[\+-]? 比對零或一次出現正負號或負號。
\s? 比對零個或一個空白字元。
\$? 比對零或一次出現貨幣符號。
\s? 比對零個或一個空白字元。
\d* 比對零個或多個十進位數字。
\.? 比對零或一個小數點符號。
\d{2}? 比對兩個十進位數零或一次。
(\d*\.?\d{2}?){1} 比對以小數點符號分隔的整數和小數位數模式至少一次。
$ 比對字串結尾。

在此情況下,正則運算式會假設有效的貨幣字串不包含群組分隔符號符號,而且沒有小數位數或目前文化特性 CurrencyDecimalDigits 的 屬性所定義的小數位數。

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

public class Example
{
   public static void Main()
   {
      // 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))
            Console.WriteLine("{0} is a currency value.", test);
         else
            Console.WriteLine("{0} is not a currency value.", test);
      }
   }
}
// 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.
Imports System.Globalization
Imports System.Text.RegularExpressions

Public Module Example
   Public Sub Main()
      ' Get the current NumberFormatInfo object to build the regular 
      ' expression pattern dynamically.
      Dim nfi As NumberFormatInfo = NumberFormatInfo.CurrentInfo

      ' Define the regular expression pattern.
      Dim pattern As String 
      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}$"
      
      Dim rgx As New Regex(pattern)

      ' Define some test strings.
      Dim tests() As String = {"-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.
      For Each test As String In tests
         If rgx.IsMatch(test) Then
            Console.WriteLine("{0} is a currency value.", test)
         Else
            Console.WriteLine("{0} is not a currency value.", test)
         End If
      Next
   End Sub
End Module
' 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 方法。

備註

類別 Regex 代表.NET Framework的正則運算式引擎。 它可以用來快速剖析大量的文字來尋找特定的字元模式;以擷取、編輯、取代或刪除文字子字串;和 ,將擷取的字串加入至集合以產生報表。

注意

如果您的主要興趣是藉由判斷字串是否符合特定模式來驗證字串,您可以使用 類別 System.Configuration.RegexStringValidator

若要使用正則運算式,您可以使用正則 運算式語言 - 快速參考中所述的語法,定義您想要在文字資料流程中識別的模式。 接下來,您可以選擇性地具現化 Regex 物件。 最後,您可以呼叫執行某些作業的方法,例如取代符合正則運算式模式的文字,或識別模式比對。

注意

如需一些常見的正則運算式模式,請參閱 正則運算式範例。 也有一些正則運算式模式的線上程式庫,例如 Regular-Expressions.info

如需使用 Regex 類別的詳細資訊,請參閱本主題中的下列各節:

如需規則運算式語言的詳細資訊,請參閱規則運算式語言 - 快速參考,或下載並列印下列其中一本小手冊:

Word (.docx) 格式的快速參考
PDF (.pdf) 格式的快速參考

Regex 與字串方法

類別 System.String 包含數個搜尋和比較方法,可用來執行與文字的模式比對。 例如, String.ContainsString.EndsWithString.StartsWith 方法會判斷字串實例是否包含指定的子字串;而 String.IndexOfString.LastIndexOf String.IndexOfAnyString.LastIndexOfAny 方法會傳回字串中指定子字串的起始位置。 當您搜尋特定字串時, System.String 請使用 類別的方法。 Regex當您在字串中搜尋特定模式時,請使用 類別。 如需詳細資訊和範例,請參閱 .NET 正則運算式

回到備註

靜態與實例方法

定義正則運算式模式之後,您可以使用下列兩種方式之一將它提供給正則運算式引擎:

  • 藉由具現化 Regex 代表正則運算式的 物件。 若要這樣做,請將正則運算式模式傳遞至建 Regex 構函式。 Regex物件是不可變的;當您使用正則運算式具現化 Regex 物件時,就無法變更該物件的正則運算式。

  • 藉由提供正則運算式和文字,以在 Visual Basic) Regex 方法中搜尋 static (Shared 。 這可讓您在不明確建立 Regex 物件的情況下使用正則運算式。

所有 Regex 模式識別方法都包含靜態和實例多載。

正則運算式引擎必須先編譯特定模式,才能使用模式。 因為 Regex 物件是不可變的,所以這是呼叫類別建構函式或靜態方法時 Regex 所發生的一次性程式。 為了消除重複編譯單一正則運算式的需求,正則運算式引擎會快取靜態方法呼叫中使用的已編譯正則運算式。 因此,正則運算式模式比對方法可為靜態和實例方法提供可比較的效能。

重要

在 .NET Framework 1.0 和 1.1 版中,會快取所有編譯的正則運算式,不論是用於實例還是靜態方法呼叫。 從 .NET Framework 2.0 開始,只會快取靜態方法呼叫中使用的正則運算式。

不過,在下列兩種情況下,快取可能會對效能造成負面影響:

  • 當您搭配大量正則運算式使用靜態方法呼叫時。 根據預設,正則運算式引擎會快取最近使用的 15 個靜態正則運算式。 如果您的應用程式使用超過 15 個靜態正則運算式,則必須重新編譯一些正則運算式。 若要防止此重新編譯,您可以增加 Regex.CacheSize 屬性。

  • 當您使用先前已編譯的正則運算式具現化新 Regex 物件時。 例如,下列程式碼會定義正則運算式,以在文字資料流程中尋找重複的字組。 雖然此範例使用單一正則運算式,但它會具現化新的 Regex 物件來處理每一行文字。 這會導致使用迴圈的每個反復專案重新編譯正則運算式。

    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();
    
    Dim sr As New StreamReader(filename)
    Dim input As String
    Dim pattern As String = "\b(\w+)\s\1\b"
    Do While sr.Peek() >= 0
       input = sr.ReadLine()
       Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
       Dim matches As MatchCollection = rgx.Matches(input)
       If matches.Count > 0 Then
          Console.WriteLine("{0} ({1} matches):", input, matches.Count)
          For Each match As Match In matches
             Console.WriteLine("   " + match.Value)
          Next   
       End If
    Loop
    sr.Close()
    

    若要防止重新編譯,您應該具現化可供所有需要它的程式碼存取的單 Regex 一物件,如下列重寫範例所示。

    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
    
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();
    
    Dim sr As New StreamReader(filename)
    Dim input As String
    Dim pattern As String = "\b(\w+)\s\1\b"
    Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
    Do While sr.Peek() >= 0
       input = sr.ReadLine()
       Dim matches As MatchCollection = rgx.Matches(input)
       If matches.Count > 0 Then
          Console.WriteLine("{0} ({1} matches):", input, matches.Count)
          For Each match As Match In matches
             Console.WriteLine("   " + match.Value)
          Next   
       End If
    Loop
    sr.Close()
    

回到備註

執行正則運算式作業

不論您決定具現化 Regex 物件並呼叫其方法或呼叫靜態方法,類別 Regex 都提供下列模式比對功能:

  • 相符專案的驗證。 您可以呼叫 IsMatch 方法來判斷是否存在相符專案。

  • 擷取單一相符專案。 您可以呼叫 Match 方法來擷取 Match 物件,此物件代表字串或字串中的第一個相符專案。 呼叫 方法即可擷取 Match.NextMatch 後續相符專案。

  • 擷取所有相符專案。 您可以呼叫 Matches 方法來擷取 System.Text.RegularExpressions.MatchCollection 物件,此物件代表在字串或字串的一部分中找到的所有相符專案。

  • 取代相符的文字。 您可以呼叫 Replace 方法來取代相符的文字。 取代文字也可以由正則運算式定義。 此外,某些 Replace 方法也包含 MatchEvaluator 參數,可讓您以程式設計方式定義取代文字。

  • 建立從輸入字串部分構成的字串陣列。 您可以呼叫 Split 方法,在正則運算式所定義的位置分割輸入字串。

除了其模式比對方法之外,類別 Regex 還包含數個特殊用途方法:

  • 方法 Escape 會逸出任何可解譯為正則運算式或輸入字串中正則運算式運算子的字元。

  • 方法 Unescape 會移除這些逸出字元。

  • 方法 CompileToAssembly 會建立包含預先定義正則運算式的元件。 .NET Framework包含命名空間中 System.Web.RegularExpressions 這些特殊用途元件的範例。

回到備註

定義Time-Out值

.NET 支援功能完整的正則運算式語言,可提供模式比對的大幅強大功能和彈性。 不過,電源和彈性會產生成本:效能不佳的風險。 執行不佳的正則運算式很容易建立。 在某些情況下,依賴過度回溯的正則運算式作業在處理接近正則運算式模式的文字時,可能會停止回應。 如需 .NET 正則運算式引擎的詳細資訊,請參閱 正則運算式行為的詳細資料。 如需過多回溯的詳細資訊,請參閱 回溯

從 .NET Framework 4.5 開始,您可以定義正則運算式比對的逾時間隔,以限制過度回溯。 根據正則運算式模式和輸入文字,執行時間可能會超過指定的逾時間隔,但不會花費比指定逾時間隔更多的時間回溯。 如果正則運算式引擎逾時,它會擲回例外狀況 RegexMatchTimeoutException 。 在大部分情況下,這可防止正則運算式引擎藉由嘗試比對幾乎符合正則運算式模式的文字來浪費處理能力。 不過,也可能表示逾時間隔設定太低,或目前的機器負載造成整體效能降低。

處理例外狀況的方式取決於例外狀況的原因。 如果例外狀況是因為逾時間隔設定太低或因為機器負載過長而發生,您可以增加逾時間隔,然後重試比對作業。 如果因為正則運算式依賴過多回溯而發生例外狀況,您可以假設相符專案不存在,而且您可以選擇性地記錄可協助您修改正則運算式模式的資訊。

當您具現化正則運算式物件時, Regex(String, RegexOptions, TimeSpan) 可以呼叫建構函式來設定逾時間隔。 針對靜態方法,您可以呼叫具有 matchTimeout 參數之相符方法的多載來設定逾時間隔。 如果您未明確設定逾時值,預設逾時值會決定如下:

  • 如果存在,則使用整個應用程式的逾時值。 這可以是套用至具現化物件的應用程式域 Regex 或進行靜態方法呼叫的任何逾時值。 您可以呼叫 AppDomain.SetData 方法,將值的字串表示 TimeSpan 指派給 「REGEX_DEFAULT_MATCH_TIMEOUT」 屬性,以設定整個應用程式的逾時值。

  • 使用 值 InfiniteMatchTimeout ,如果未設定整個應用程式的逾時值,則為 。

重要

建議您在所有正則運算式模式比對作業中設定逾時值。 如需詳細資訊,請參閱 正則運算式的最佳做法

回到備註

建構函式

Regex()

初始化 Regex 類別的新執行個體。

Regex(SerializationInfo, StreamingContext)

使用序列化的資料,初始化 Regex 類別的新執行個體。

Regex(String)

為指定的規則運算式初始化 Regex 類別的新執行個體。

Regex(String, RegexOptions)

使用會修改模式的選項,為指定的規則運算式初始化 Regex 類別的新執行個體。

Regex(String, RegexOptions, TimeSpan)

針對指定的規則運算式,使用修改模式的選項,以及指定在逾時前模式比對方法應該嘗試比對的時間長度的值,初始化 Regex 類別的新執行個體。

欄位

capnames

CompileToAssembly 方法所產生的 Regex 物件使用。

caps

CompileToAssembly 方法所產生的 Regex 物件使用。

capsize

CompileToAssembly 方法所產生的 Regex 物件使用。

capslist

CompileToAssembly 方法所產生的 Regex 物件使用。

factory

CompileToAssembly 方法所產生的 Regex 物件使用。

InfiniteMatchTimeout

指定模式比對作業不應逾時。

internalMatchTimeout

在作業逾時之前可在模式比對作業中流逝的最長時間。

pattern

CompileToAssembly 方法所產生的 Regex 物件使用。

roptions

CompileToAssembly 方法所產生的 Regex 物件使用。

屬性

CacheSize

取得或設定在已編譯規則運算式目前靜態快取中項目的最大數目。

CapNames

取得或設定字典,對應具名擷取群組及其索引值。

Caps

取得或設定字典,對應編號的擷取群組及其索引值。

MatchTimeout

取得目前執行個體的逾時間隔。

Options

取得傳入 Regex 建構函式的選項。

RightToLeft

取得值,指出規則運算式是否由右至左搜尋。

方法

CompileToAssembly(RegexCompilationInfo[], AssemblyName)
已過時。

將一個或多個指定的 Regex 物件編譯為具名組件。

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])
已過時。

將一個或多個指定的 Regex 物件編譯為具有指定之屬性的具名組件。

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)
已過時。

將一個或多個指定的 Regex 物件和指定的資源檔編譯為具有指定之屬性的具名組件。

Count(ReadOnlySpan<Char>)

搜尋輸入範圍中所有出現的正則運算式,並傳回相符專案的數目。

Count(ReadOnlySpan<Char>, String)

搜尋輸入範圍中所有出現的正則運算式,並傳回相符專案的數目。

Count(ReadOnlySpan<Char>, String, RegexOptions)

搜尋輸入範圍中所有出現的正則運算式,並傳回相符專案的數目。

Count(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

搜尋輸入範圍中所有出現的正則運算式,並傳回相符專案的數目。

Count(String)

搜尋輸入字串中所有出現的正則運算式,並傳回相符專案的數目。

Count(String, String)

搜尋輸入字串中所有出現的正則運算式,並傳回相符專案的數目。

Count(String, String, RegexOptions)

搜尋輸入字串中所有出現的正則運算式,並傳回相符專案的數目。

Count(String, String, RegexOptions, TimeSpan)

搜尋輸入字串中所有出現的正則運算式,並傳回相符專案的數目。

EnumerateMatches(ReadOnlySpan<Char>)

搜尋輸入範圍中所有出現的正則運算式,並傳回 Regex.ValueMatchEnumerator 逐一查看相符專案。

EnumerateMatches(ReadOnlySpan<Char>, String)

搜尋輸入範圍中所有出現的正則運算式,並傳回 Regex.ValueMatchEnumerator 逐一查看相符專案。

EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions)

搜尋輸入範圍中所有出現的正則運算式,並傳回 Regex.ValueMatchEnumerator 逐一查看相符專案。

EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

搜尋輸入範圍中所有出現的正則運算式,並傳回 Regex.ValueMatchEnumerator 逐一查看相符專案。

Equals(Object)

判斷指定的物件是否等於目前的物件。

(繼承來源 Object)
Escape(String)

以逸出程式碼取代字元 (\、*、+、?、|、{、[、(、)、^、$、.、# 和空白字元) 的最小集合,以便逸出這些字元。 這樣會指示規則運算式引擎將這些字元解譯為常值,而非解譯為中繼字元。

Finalize()

這個成員會覆寫 Finalize(),您可以在該主題中找到更完整的文件。

在記憶體回收 (GC) 回收 Object 前,允許 Object 嘗試釋放資源並執行其他清除作業。

GetGroupNames()

傳回規則運算式的擷取群組名稱的陣列。

GetGroupNumbers()

傳回對應陣列中群組名稱的擷取群組編號的陣列。

GetHashCode()

做為預設雜湊函式。

(繼承來源 Object)
GetType()

取得目前執行個體的 Type

(繼承來源 Object)
GroupNameFromNumber(Int32)

取得對應指定群組編號的群組名稱。

GroupNumberFromName(String)

傳回對應指定群組名稱的群組編號。

InitializeReferences()

CompileToAssembly 方法所產生的 Regex 物件使用。

IsMatch(ReadOnlySpan<Char>)

指出 Regex 建構函式中指定的正則運算式是否在指定的輸入範圍中找到相符專案。

IsMatch(ReadOnlySpan<Char>, String)

指出指定的正則運算式是否在指定的輸入範圍中尋找相符專案。

IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

指出指定的正則運算式是否使用指定的比對選項,在指定的輸入範圍中尋找相符專案。

IsMatch(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

指出指定的正則運算式是否使用指定的比對選項和逾時間隔,在指定的輸入範圍中尋找相符專案。

IsMatch(String)

表示 Regex 建構函式中指定的規則運算式是否要在指定的輸入字串中尋找相符項目。

IsMatch(String, Int32)

表示 Regex 建構函式中所指定的規則運算式,是否要從字串中指定的起始位置開始,在指定的輸入字串中尋找相符項目。

IsMatch(String, String)

表示指定的規則運算式是否在指定的輸入字串中尋找相符項目。

IsMatch(String, String, RegexOptions)

表示指定的規則運算式是否使用指定的比對選項,在指定的輸入字串中尋找相符項目。

IsMatch(String, String, RegexOptions, TimeSpan)

指出指定的規則運算式是否使用指定的比對選項和逾時間隔,在指定的輸入字串中尋找相符項目。

Match(String)

在指定的輸入字串中,搜尋符合 Regex 建構函式中所指定規則運算式的第一個項目。

Match(String, Int32)

從字串中指定的開始位置開始,在輸入字串中搜尋規則運算式的第一個相符項目。

Match(String, Int32, Int32)

從指定的開始位置開始並且僅搜尋指定數目的字元,在輸入字串中搜尋規則運算式的第一個相符項目。

Match(String, String)

在指定的輸入字串中搜尋所指定規則運算式的第一個相符項目。

Match(String, String, RegexOptions)

使用指定的比對選項,在輸入字串中搜尋所指定規則運算式的第一個相符項目。

Match(String, String, RegexOptions, TimeSpan)

使用指定的比對選項和逾時間隔,在輸入字串中搜尋所指定規則運算式的第一個相符項目。

Matches(String)

在指定的輸入字串搜尋規則運算式的所有項目。

Matches(String, Int32)

自字串中指定的開始位置開始,在指定的輸入字串搜尋規則運算式的所有項目。

Matches(String, String)

在指定的輸入字串搜尋所指定規則運算式的所有相符項目。

Matches(String, String, RegexOptions)

使用指定的比對選項在指定的輸入字串中,搜尋所指定規則運算式的所有相符項目。

Matches(String, String, RegexOptions, TimeSpan)

使用指定的比對選項和逾時間隔,在指定的輸入字串中搜尋所指定規則運算式的所有相符項目。

MemberwiseClone()

建立目前 Object 的淺層複製。

(繼承來源 Object)
Replace(String, MatchEvaluator)

在指定的輸入字串中,使用由 MatchEvaluator 委派所傳回的字串,取代所有與指定之規則運算式相符的字串。

Replace(String, MatchEvaluator, Int32)

在指定的輸入字串中,使用 MatchEvaluator 委派所傳回的字串來取代符合規則運算式模式的指定最大字串數目。

Replace(String, MatchEvaluator, Int32, Int32)

在指定的輸入子字串中,使用 MatchEvaluator 委派所傳回的字串來取代符合規則運算式模式的指定最大字串數目。

Replace(String, String)

在指定的輸入字串中,使用指定的取代字串來取代符合規則運算式模式的所有字串。

Replace(String, String, Int32)

在指定的輸入字串中,使用指定的取代字串來取代符合規則運算式模式的指定最大字串數目。

Replace(String, String, Int32, Int32)

在指定的輸入子字串中,使用指定的取代字串來取代符合規則運算式模式的指定最大字串數目。

Replace(String, String, MatchEvaluator)

在指定的輸入字串中,使用由 MatchEvaluator 委派所傳回的字串,取代所有與指定之規則運算式相符的字串。

Replace(String, String, MatchEvaluator, RegexOptions)

在指定的輸入字串中,使用由 MatchEvaluator 委派所傳回的字串,取代所有與指定之規則運算式相符的字串。 指定的選項會修改符合的作業。

Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)

在指定的輸入字串中,使用 MatchEvaluator 委派所傳回的字串,取代所有與指定之規則運算式相符的子字串。 如果沒有找到相符項目,其他參數會指定修改比對作業的選項和逾時間隔。

Replace(String, String, String)

在指定的輸入字串中,使用指定的取代字串來取代符合指定之規則運算式的所有字串。

Replace(String, String, String, RegexOptions)

在指定的輸入字串中,使用指定的取代字串來取代符合指定之規則運算式的所有字串。 指定的選項會修改符合的作業。

Replace(String, String, String, RegexOptions, TimeSpan)

在指定的輸入字串中,使用指定的取代字串來取代符合指定之規則運算式的所有字串。 如果沒有找到相符項目,其他參數會指定修改比對作業的選項和逾時間隔。

Split(String)

Regex 建構函式中指定之規則運算式模式所定義的位置,將輸入字串分隔成子字串的陣列。

Split(String, Int32)

Regex 建構函式中指定的規則運算式所定義的位置,以指定的最大次數來將輸入字串分隔成子字串的陣列。

Split(String, Int32, Int32)

Regex 建構函式中指定的規則運算式所定義的位置,以指定的最大次數來將輸入字串分隔成子字串的陣列。 規則運算式模式從輸入字串中指定的字元位置開始搜尋。

Split(String, String)

在規則運算式模式所定義的位置,將輸入字串分割成子字串陣列。

Split(String, String, RegexOptions)

在指定的規則運算式模式所定義的位置,將輸入字串分割成子字串陣列。 指定的選項會修改符合的作業。

Split(String, String, RegexOptions, TimeSpan)

在指定的規則運算式模式所定義的位置,將輸入字串分割成子字串陣列。 如果沒有找到相符項目,其他參數會指定修改比對作業的選項和逾時間隔。

ToString()

傳回傳遞至 Regex 建構函式中的規則運算式模式。

Unescape(String)

轉換輸入字串中任何逸出的字元。

UseOptionC()

CompileToAssembly 方法所產生的 Regex 物件使用。

UseOptionR()

CompileToAssembly 方法所產生的 Regex 物件使用。

ValidateMatchTimeout(TimeSpan)

檢查逾時間隔是否在可接受的範圍內。

明確介面實作

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

將還原序列化目前 SerializationInfo 物件所需的資料填入 (Populate) Regex 物件。

適用於

執行緒安全性

類別 Regex 是不可變的 (唯讀) 和執行緒安全。 Regex 物件可以在任何執行緒上建立,並線上程之間共用。 如需詳細資訊,請參閱 執行緒安全

另請參閱