Regex 建構函式

參考

定義

命名空間:: System.Text.RegularExpressions

組件:: System.Text.RegularExpressions.dll

組件:: System.dll

組件:: netstandard.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

初始化 Regex 類別的新實例。

多載

Regex()	初始化 Regex 類別的新實例。
Regex(String)	初始化指定正則表示式之 Regex 類別的新實例。
Regex(SerializationInfo, StreamingContext)	已淘汰. 使用串行化數據，初始化 Regex 類別的新實例。
Regex(String, RegexOptions)	使用修改模式的選項，初始化指定正則表達式之 Regex 類別的新實例。
Regex(String, RegexOptions, TimeSpan)	使用修改模式的選項，以及指定模式比對方法在逾時之前嘗試比對的時間長度的選項，初始化指定指定正則表達式 Regex 類別的新實例。

Regex()

來源:: Regex.cs

來源:: Regex.cs

來源:: Regex.cs

初始化 Regex 類別的新實例。

protected:
 Regex();

protected Regex ();

Protected Sub New ()

備註

請注意，此建構函式受到保護;它只能由衍生自 Regex 類別的類別呼叫。

適用於

Regex(String)

來源:: Regex.cs

來源:: Regex.cs

來源:: Regex.cs

初始化指定正則表示式之 Regex 類別的新實例。

public:
 Regex(System::String ^ pattern);

public Regex (string pattern);

new System.Text.RegularExpressions.Regex : string -> System.Text.RegularExpressions.Regex

Public Sub New (pattern As String)

參數

pattern: String

要比對的正則表達式模式。

例外狀況

ArgumentException

發生正則表達式剖析錯誤。

ArgumentNullException

pattern null。

範例

下列範例說明如何使用這個建構函式來具現化正則表達式，該正則表達式符合以字母 “a” 或 “t” 開頭的任何單字。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex defaultRegex = new Regex(pattern);
      // Get matches of pattern in text
      matches = defaultRegex.Matches(text);
      Console.WriteLine("Parsing '{0}'", text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//       Parsing 'The threaded application ate up the thread pool as it executed.'
//       0. threaded
//       1. application
//       2. ate
//       3. the
//       4. thread
//       5. as

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim defaultRegex As New Regex(pattern)
      ' Get matches of pattern in text
      matches = defaultRegex.Matches(text)
      Console.WriteLine("Parsing '{0}'", text)
      ' Iterate matches
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Parsing 'The threaded application ate up the thread pool as it executed.'
'       0. threaded
'       1. application
'       2. ate
'       3. the
'       4. thread
'       5. as

請注意，正則表達式模式無法比對文字開頭的「The」一詞，因為比較預設會區分大小寫。如需不區分大小寫比較的範例，請參閱 Regex(String, RegexOptions) 建構函式。

備註

警告

使用 System.Text.RegularExpressions 來處理不受信任的輸入時，請傳遞逾時值，以防止惡意使用者造成拒絕服務攻擊。逾時值會指定模式比對方法在逾時之前應該嘗試尋找相符項目的時間長度。

pattern 參數是由正則表達式語言專案所組成，這些元素會以符號方式描述要比對的字串。如需正則表達式的詳細資訊，請參閱 .NET 正則表示式和正則表達式語言 - 快速參考主題。

呼叫 Regex(String) 建構函式相當於呼叫具有 options 自變數 None 值的 Regex(String, RegexOptions) 建構函式。

Regex 物件是不可變的，這表示它只能用於您在建立時定義的比對模式。不過，它可以使用任何次數，而不需重新編譯。

此建構函式會具現化正則表達式物件，此物件會嘗試比對定義於 pattern中的任何字母字元進行區分大小寫的比對。對於不區分大小寫的比對，請使用 Regex.Regex(String, RegexOptions) 建構函式。

給呼叫者的注意事項

此建構函式會建立 Regex 物件，該物件會使用建立應用程式域的預設逾時值。如果尚未為應用程式域定義逾時值，Regex 物件會使用值 InfiniteMatchTimeout，以防止作業逾時。建立 Regex 對象的建議建構函式是 Regex(String, RegexOptions, TimeSpan)，可讓您設定超時時間間隔。

另請參閱

正則表示式語言專案

適用於

Regex(SerializationInfo, StreamingContext)

來源:: Regex.cs

來源:: Regex.cs

來源:: Regex.cs

警告

This API supports obsolete formatter-based serialization. It should not be called or extended by application code.

使用串行化數據，初始化 Regex 類別的新實例。

protected:
 Regex(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);

protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);

[System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);

new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex

[<System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex

Protected Sub New (info As SerializationInfo, context As StreamingContext)

參數

info: SerializationInfo

物件，其中包含串行化模式和 RegexOptions 資訊。

context: StreamingContext

這個串行化的目的地。（不使用此參數，請指定 null。

屬性: ObsoleteAttribute

例外狀況

ArgumentException

發生正則表達式剖析錯誤。

ArgumentNullException

info 包含的模式是 null。

ArgumentOutOfRangeException

info 包含無效的 RegexOptions 旗標。

適用於

Regex(String, RegexOptions)

來源:: Regex.cs

來源:: Regex.cs

來源:: Regex.cs

使用修改模式的選項，初始化指定正則表達式之 Regex 類別的新實例。

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options);

new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Regex

Public Sub New (pattern As String, options As RegexOptions)

參數

pattern: String

要比對的正則表達式模式。

options: RegexOptions

修改正則表達式之列舉值的位元組合。

例外狀況

ArgumentException

發生正則表達式剖析錯誤。

ArgumentNullException

pattern null。

ArgumentOutOfRangeException

options 包含無效的旗標。

範例

下列範例說明如何使用這個建構函式來具現化正則表達式，該正則表達式符合以字母 “a” 或 “t” 開頭的任何單字。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.Compiled;
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex optionRegex = new Regex(pattern, options);
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString());
      // Get matches of pattern in text
      matches = optionRegex.Matches(text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//    Parsing 'The threaded application ate up the thread pool as it executed.'
//        with options IgnoreCase, Compiled:
//    0. The
//    1. threaded
//    2. application
//    3. ate
//    4. the
//    5. thread
//    6. as

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.Compiled
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim optionRegex As New Regex(pattern, options)
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString())
      ' Get matches of pattern in text
      matches = optionRegex.Matches(text)
      ' Iterate matches   
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    Parsing 'The threaded application ate up the thread pool as it executed.'
'       with options IgnoreCase, Compiled:
'    0. The
'    1. threaded
'    2. application
'    3. ate
'    4. the
'    5. thread
'    6. as

請注意，比對集合包含開始文字的「The」一詞，因為 options 參數已定義不區分大小寫的比較。

備註

警告

Regex 物件是不可變的，這表示它只能用於您在建立時定義的比對參數。不過，它可以使用任何次數，而不需重新編譯。

給呼叫者的注意事項

另請參閱

正則表示式語言專案

適用於

Regex(String, RegexOptions, TimeSpan)

來源:: Regex.cs

來源:: Regex.cs

來源:: Regex.cs

使用修改模式的選項，以及指定模式比對方法在逾時之前嘗試比對的時間長度的選項，初始化指定指定正則表達式 Regex 類別的新實例。

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Regex

Public Sub New (pattern As String, options As RegexOptions, matchTimeout As TimeSpan)

參數

pattern: String

要比對的正則表達式模式。

options: RegexOptions

修改正則表達式之列舉值的位元組合。

matchTimeout: TimeSpan

超時時間間隔，或 InfiniteMatchTimeout，表示方法不應該逾時。

例外狀況

ArgumentException

發生正則表達式剖析錯誤。

ArgumentNullException

pattern null。

ArgumentOutOfRangeException

options 不是有效的 RegexOptions 值。

-或-

matchTimeout 為負數、零或大於大約 24 天。

範例

下列範例會呼叫 Regex(String, RegexOptions, TimeSpan) 建構函式，以具現化具有一秒逾時值的 Regex 物件。正則表達式模式 (a+)+$，其符合行尾一或多個“a” 字元的一或多個序列，受限於過度回溯。如果擲回 RegexMatchTimeoutException，此範例會將逾時值增加為三秒的最大值。否則，它會放棄比對模式的嘗試。

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;
using System.Text.RegularExpressions;
using System.Threading; 

public class Example
{
   const int MaxTimeoutInSeconds = 3;

   public static void Main()
   {
      string pattern = @"(a+)+$";    // DO NOT REUSE THIS PATTERN.
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1));       
      Stopwatch sw = null;
      
      string[] inputs= { "aa", "aaaa>", 
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                         "aaaaaaaaaaaaaaaaaaaaaa>",
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" };
                                 
      foreach (var inputValue in inputs) {
         Console.WriteLine("Processing {0}", inputValue);
         bool timedOut = false;
         do { 
            try {
               sw = Stopwatch.StartNew();
               // Display the result.
               if (rgx.IsMatch(inputValue)) {
                  sw.Stop();
                  Console.WriteLine(@"Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed); 
               }
               else {
                  sw.Stop();
                  Console.WriteLine(@"'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed);
               }
            }
            catch (RegexMatchTimeoutException e) {   
               sw.Stop();
               // Display the elapsed time until the exception.
               Console.WriteLine(@"Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed);
               Thread.Sleep(1500);       // Pause for 1.5 seconds.

               // Increase the timeout interval and retry.
               TimeSpan timeout = e.MatchTimeout.Add(TimeSpan.FromSeconds(1));
               if (timeout.TotalSeconds > MaxTimeoutInSeconds) {
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds);
                  timedOut = false;
               }
               else {               
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout); 
                  rgx = new Regex(pattern, RegexOptions.IgnoreCase, timeout);
                  timedOut = true;
               }
            }
         } while (timedOut);
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following :
//    Processing aa
//    Valid: 'aa' (00.0000779 seconds)
//    
//    Processing aaaa>
//    'aaaa>' is not a valid string. (00.00005 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
//    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
//    Changing the timeout interval to 00:00:02
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
//    Changing the timeout interval to 00:00:03
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
//    Maximum timeout interval of 3 seconds exceeded.
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
//    Maximum timeout interval of 3 seconds exceeded.

Imports System.ComponentModel
Imports System.Diagnostics
Imports System.Security
Imports System.Text.RegularExpressions
Imports System.Threading 

Module Example
   Const MaxTimeoutInSeconds As Integer = 3
   
   Public Sub Main()
      Dim pattern As String = "(a+)+$"    ' DO NOT REUSE THIS PATTERN.
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1))       
      Dim sw As Stopwatch = Nothing
      
      Dim inputs() As String = { "aa", "aaaa>", 
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                                 "aaaaaaaaaaaaaaaaaaaaaa>",
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" }
                                 
      For Each inputValue In inputs
         Console.WriteLine("Processing {0}", inputValue)
         Dim timedOut As Boolean = False
         Do 
            Try
               sw = Stopwatch.StartNew()
               ' Display the result.
               If rgx.IsMatch(inputValue) Then
                  sw.Stop()
                  Console.WriteLine("Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed) 
               Else
                  sw.Stop()
                  Console.WriteLine("'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed)
               End If
            Catch e As RegexMatchTimeoutException   
               sw.Stop()
               ' Display the elapsed time until the exception.
               Console.WriteLine("Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed)
               Thread.Sleep(1500)       ' Pause for 1.5 seconds.

               ' Increase the timeout interval and retry.
               Dim timeout As TimeSpan = e.MatchTimeout.Add(TimeSpan.FromSeconds(1))
               If timeout.TotalSeconds > MaxTimeoutInSeconds Then
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds)
                  timedOut = False
               Else                
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout) 
                  rgx = New Regex(pattern, RegexOptions.IgnoreCase, timeout)
                  timedOut = True
               End If
            End Try
         Loop While timedOut
         Console.WriteLine()
      Next   
   End Sub 
End Module
' The example displays output like the following:
'    Processing aa
'    Valid: 'aa' (00.0000779 seconds)
'    
'    Processing aaaa>
'    'aaaa>' is not a valid string. (00.00005 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
'    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
'    Changing the timeout interval to 00:00:02
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
'    Changing the timeout interval to 00:00:03
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
'    Maximum timeout interval of 3 seconds exceeded.
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
'    Maximum timeout interval of 3 seconds exceeded.

備註

Regex 物件是不可變的，這表示它只能用於您在建立時定義的比對模式。不過，它可以使用任何次數，而不需重新編譯。

matchTimeout 參數會指定模式比對方法在逾時之前應該嘗試尋找相符項目的時間長度。如果該時間間隔中找不到相符專案，模式比對方法會擲回 RegexMatchTimeoutException 例外狀況。 matchTimeout 會覆寫為建立 Regex 物件的應用程式域所定義的任何預設逾時值。觀察 matchTimeout 超時時間間隔的實例模式比對方法包括下列各項：

設定超時時間間隔可防止依賴過度回溯的正則表達式在處理包含接近相符項目的輸入時停止回應。如需詳細資訊，請參閱正則表示式的最佳做法和回溯。若要設定合理的超時時間間隔，請考慮下列因素：

正則表達式模式的長度和複雜度。較長且更複雜的正則表達式需要比較短且更簡單的正則表示式更長的時間。
預期的機器負載。在 CPU 和記憶體使用率高的系統上，處理需要更多時間。

給呼叫者的注意事項

我們建議您將 matchTimeout 參數設定為適當的值，例如兩秒。如果您藉由指定 InfiniteMatchTimeout來停用逾時，正則表達式引擎會提供稍微更好的效能。不過，您應該只在下列情況下停用逾時：

正則表達式所處理的輸入衍生自已知且受信任的來源，或包含靜態文字時。這會排除使用者動態輸入的文字。
當正則表達式模式經過徹底測試，以確保其有效率地處理相符專案、不相符專案和接近相符專案時。
當正則表達式模式不包含任何已知在處理接近相符專案時造成過度回溯的語言元素。

另請參閱

正則表達式中的回溯
正則表示式語言專案

適用於

共用方式為

Regex 建構函式

定義

多載

Regex()

備註

適用於

Regex(String)

參數

例外狀況

範例

備註

給呼叫者的注意事項

另請參閱

適用於

Regex(SerializationInfo, StreamingContext)

參數

例外狀況

適用於

Regex(String, RegexOptions)

參數

例外狀況

範例

備註

給呼叫者的注意事項

另請參閱

適用於

Regex(String, RegexOptions, TimeSpan)

參數

例外狀況

範例

備註

給呼叫者的注意事項

另請參閱

適用於

意見反應

其他資源