.NET 中規則運算式的最佳做法

.NET 中的規則運算式引擎是一項強大而功能完整的工具，會依據模式比對而非比較與比對常值文字的方式處理文字。 在大部分情況下，它會快速且有效率地執行模式比對。 不過，在某些情況下，規則運算式引擎速度可能變得緩慢。 而只有鮮少情況下，它甚至可能在處理相對小的輸入卻耗費數小時甚至數天時停止回應。

本文說明一些開發人員可以採用的最佳做法，確保其規則運算式達到最佳效能。

考慮輸入來源

一般而言，規則運算式可以接受兩種類型的輸入：受限制或未受限制。 受限制的輸入是來自已知或可靠來源，並且遵循預先定義格式的文字。 未受限制的輸入是來自不可靠來源 (例如 Web 使用者) 的文字，且可能未遵循預先定義或預期的格式。

通常撰寫規則運算式模式的目的在於比對有效輸入。 也就是說，開發人員會檢查要比對的文字，然後撰寫比對該文字的規則運算式模式。 接著開發人員會利用多個有效的輸入項目進行測試，藉此判斷此模式是否需要更正或進一步詳述。 當模式符合所有假設的有效輸入時，即宣告準備好實際執行，並且可以納入已發行的應用程式中。 這種方式使得規則運算式模式相當適合比對限制的輸入， 不過卻不適合比對未受限制的輸入。

若要比對未受限制的輸入，規則運算式必須能夠有效率地處理三種文字：

• 符合規則運算式模式的文字。
• 不符合規則運算式模式的文字。
• 幾乎符合規則運算式模式的文字。

最後一種文字對於專為處理受限制輸入的規則運算式而言尤其繁瑣。 如果該規則運算式也依賴大量回溯，則規則運算式引擎可能耗費相當長的時間 (有些情況需要許多小時或許多天) 處理看似無關緊要的文字。

例如，像是驗證電子郵件地址別名的規則運算式，這種規則運算式相當常用卻也較為繁瑣。 規則運算式 ^[0-9A-Z]([-.\w]*[0-9A-Z])*$ 主要用來處理一般視為有效的電子郵件地址。 有效的電子郵件地址包含英數字元，後面接著零個或多個字元，而這些字元可以是英數字、句號或連字號。 規則運算式的結尾必須是英數字元。 不過，如下面的範例所示，雖然這個規則運算式可輕鬆處理有效的輸入，但是當它處理幾乎有效的輸入時就沒有效率了。

using System;
using System.Diagnostics;
using System.Text.RegularExpressions;

public class DesignExample
{
    public static void Main()
    {
        Stopwatch sw;
        string[] addresses = { "AAAAAAAAAAA@contoso.com",
                             "AAAAAAAAAAaaaaaaaaaa!@contoso.com" };
        // The following regular expression should not actually be used to
        // validate an email address.
        string pattern = @"^[0-9A-Z]([-.\w]*[0-9A-Z])*$";
        string input;

        foreach (var address in addresses)
        {
            string mailBox = address.Substring(0, address.IndexOf("@"));
            int index = 0;
            for (int ctr = mailBox.Length - 1; ctr >= 0; ctr--)
            {
                index++;

                input = mailBox.Substring(ctr, index);
                sw = Stopwatch.StartNew();
                Match m = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
                sw.Stop();
                if (m.Success)
                    Console.WriteLine("{0,2}. Matched '{1,25}' in {2}",
                                      index, m.Value, sw.Elapsed);
                else
                    Console.WriteLine("{0,2}. Failed  '{1,25}' in {2}",
                                      index, input, sw.Elapsed);
            }
            Console.WriteLine();
        }
    }
}

// The example displays output similar to the following:
//     1. Matched '                        A' in 00:00:00.0007122
//     2. Matched '                       AA' in 00:00:00.0000282
//     3. Matched '                      AAA' in 00:00:00.0000042
//     4. Matched '                     AAAA' in 00:00:00.0000038
//     5. Matched '                    AAAAA' in 00:00:00.0000042
//     6. Matched '                   AAAAAA' in 00:00:00.0000042
//     7. Matched '                  AAAAAAA' in 00:00:00.0000042
//     8. Matched '                 AAAAAAAA' in 00:00:00.0000087
//     9. Matched '                AAAAAAAAA' in 00:00:00.0000045
//    10. Matched '               AAAAAAAAAA' in 00:00:00.0000045
//    11. Matched '              AAAAAAAAAAA' in 00:00:00.0000045
//
//     1. Failed  '                        !' in 00:00:00.0000447
//     2. Failed  '                       a!' in 00:00:00.0000071
//     3. Failed  '                      aa!' in 00:00:00.0000071
//     4. Failed  '                     aaa!' in 00:00:00.0000061
//     5. Failed  '                    aaaa!' in 00:00:00.0000081
//     6. Failed  '                   aaaaa!' in 00:00:00.0000126
//     7. Failed  '                  aaaaaa!' in 00:00:00.0000359
//     8. Failed  '                 aaaaaaa!' in 00:00:00.0000414
//     9. Failed  '                aaaaaaaa!' in 00:00:00.0000758
//    10. Failed  '               aaaaaaaaa!' in 00:00:00.0001462
//    11. Failed  '              aaaaaaaaaa!' in 00:00:00.0002885
//    12. Failed  '             Aaaaaaaaaaa!' in 00:00:00.0005780
//    13. Failed  '            AAaaaaaaaaaa!' in 00:00:00.0011628
//    14. Failed  '           AAAaaaaaaaaaa!' in 00:00:00.0022851
//    15. Failed  '          AAAAaaaaaaaaaa!' in 00:00:00.0045864
//    16. Failed  '         AAAAAaaaaaaaaaa!' in 00:00:00.0093168
//    17. Failed  '        AAAAAAaaaaaaaaaa!' in 00:00:00.0185993
//    18. Failed  '       AAAAAAAaaaaaaaaaa!' in 00:00:00.0366723
//    19. Failed  '      AAAAAAAAaaaaaaaaaa!' in 00:00:00.1370108
//    20. Failed  '     AAAAAAAAAaaaaaaaaaa!' in 00:00:00.1553966
//    21. Failed  '    AAAAAAAAAAaaaaaaaaaa!' in 00:00:00.3223372

Imports System.Diagnostics
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim sw As Stopwatch
        Dim addresses() As String = {"AAAAAAAAAAA@contoso.com",
                                   "AAAAAAAAAAaaaaaaaaaa!@contoso.com"}
        ' The following regular expression should not actually be used to 
        ' validate an email address.
        Dim pattern As String = "^[0-9A-Z]([-.\w]*[0-9A-Z])*$"
        Dim input As String

        For Each address In addresses
            Dim mailBox As String = address.Substring(0, address.IndexOf("@"))
            Dim index As Integer = 0
            For ctr As Integer = mailBox.Length - 1 To 0 Step -1
                index += 1
                input = mailBox.Substring(ctr, index)
                sw = Stopwatch.StartNew()
                Dim m As Match = Regex.Match(input, pattern, RegexOptions.IgnoreCase)
                sw.Stop()
                if m.Success Then
                    Console.WriteLine("{0,2}. Matched '{1,25}' in {2}",
                                      index, m.Value, sw.Elapsed)
                Else
                    Console.WriteLine("{0,2}. Failed  '{1,25}' in {2}",
                                      index, input, sw.Elapsed)
                End If
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays output similar to the following:
'     1. Matched '                        A' in 00:00:00.0007122
'     2. Matched '                       AA' in 00:00:00.0000282
'     3. Matched '                      AAA' in 00:00:00.0000042
'     4. Matched '                     AAAA' in 00:00:00.0000038
'     5. Matched '                    AAAAA' in 00:00:00.0000042
'     6. Matched '                   AAAAAA' in 00:00:00.0000042
'     7. Matched '                  AAAAAAA' in 00:00:00.0000042
'     8. Matched '                 AAAAAAAA' in 00:00:00.0000087
'     9. Matched '                AAAAAAAAA' in 00:00:00.0000045
'    10. Matched '               AAAAAAAAAA' in 00:00:00.0000045
'    11. Matched '              AAAAAAAAAAA' in 00:00:00.0000045
'    
'     1. Failed  '                        !' in 00:00:00.0000447
'     2. Failed  '                       a!' in 00:00:00.0000071
'     3. Failed  '                      aa!' in 00:00:00.0000071
'     4. Failed  '                     aaa!' in 00:00:00.0000061
'     5. Failed  '                    aaaa!' in 00:00:00.0000081
'     6. Failed  '                   aaaaa!' in 00:00:00.0000126
'     7. Failed  '                  aaaaaa!' in 00:00:00.0000359
'     8. Failed  '                 aaaaaaa!' in 00:00:00.0000414
'     9. Failed  '                aaaaaaaa!' in 00:00:00.0000758
'    10. Failed  '               aaaaaaaaa!' in 00:00:00.0001462
'    11. Failed  '              aaaaaaaaaa!' in 00:00:00.0002885
'    12. Failed  '             Aaaaaaaaaaa!' in 00:00:00.0005780
'    13. Failed  '            AAaaaaaaaaaa!' in 00:00:00.0011628
'    14. Failed  '           AAAaaaaaaaaaa!' in 00:00:00.0022851
'    15. Failed  '          AAAAaaaaaaaaaa!' in 00:00:00.0045864
'    16. Failed  '         AAAAAaaaaaaaaaa!' in 00:00:00.0093168
'    17. Failed  '        AAAAAAaaaaaaaaaa!' in 00:00:00.0185993
'    18. Failed  '       AAAAAAAaaaaaaaaaa!' in 00:00:00.0366723
'    19. Failed  '      AAAAAAAAaaaaaaaaaa!' in 00:00:00.1370108
'    20. Failed  '     AAAAAAAAAaaaaaaaaaa!' in 00:00:00.1553966
'    21. Failed  '    AAAAAAAAAAaaaaaaaaaa!' in 00:00:00.3223372

如上述範例的輸出所示，規則運算式引擎會以大致相同的時間間隔處理有效的電子郵件別名 (無論其長度為何)。 但另一方面，當幾乎有效的電子郵件地址包含超過五個字元時，字串中額外的每個字元其處理時間約為兩倍。 因此，幾乎有效的 28 個字元字串需要超過一小時的處理時間，而幾乎有效的 33 個字元字串則需要將近一天來處理。

由於這個規則運算式單純是考量所要比對輸入的格式而開發，因此並未考慮不符合模式的輸入。 而這個疏忽就會讓幾乎符合規則運算式模式的未受限制輸入大幅降低效能。

若要解決這個問題，您可以執行下列操作：

• 開發模式時，您應考慮回溯可能對規則運算式引擎的效能造成的影響，尤其是規則運算式的設計為處理未受限制的輸入。 如需詳細資訊，請參閱控制回溯一節。

• 使用無效、幾乎有效及有效的輸入徹底測試您的規則運算式。 您可以使用 Rex 來隨機產生特定規則運算式的輸入。 Rex 是出自 Microsoft Research 的規則運算式探索工具。

適當處理物件具現化

System.Text.RegularExpressions.Regex 類別是 .NET 的規則運算式物件模型的核心，其代表規則運算式引擎。 使用 Regex 引擎的方式經常是影響規則運算式效能最重要的一項因素。 定義規則運算式的工作與結合規則運算式引擎和規則運算式模式息息相關。 無論是傳遞規則運算式模式給 Regex 物件的建構函式，藉此將該物件具現化，或是將規則運算式模式及要分析的字串傳遞給靜態方法，藉此呼叫該方法，該耦合流程都會很昂貴。

您可以結合規則運算式引擎與特定規則運算式模式，然後使用引擎透過數種方式比對文字：

• 您可以呼叫靜態模式比對方法，例如 Regex.Match(String, String)。 這種方法不需要具現化規則運算式物件。

• 您可以具現化 Regex 物件，並呼叫解譯的規則運算式的執行個體模式比對方法，這是將規則運算式引擎繫結至規則運算式模式的預設方法。 這個方法會在 Regex 物件具現化，但是沒有包含 options 旗標的 Compiled 引數時得出結果。

• 您可以具現化 Regex 物件，並且呼叫來源產生之規則運算式的執行個體模式比對方法。 在大部分情況下，建議使用此技術。 若要這樣做，請將 GeneratedRegexAttribute 屬性放置在傳回 Regex 的部分方法上。

• 您可以具現化 Regex 物件，並且呼叫編譯之規則運算式的執行個體模式比對方法。 當 Regex 物件具現化且包含 options 旗標的 Compiled 引數時，規則運算式物件就會表示編譯的模式。

您呼叫規則運算式比對方法的特殊方式可能會影響應用程式的效能。 下列各節會討論何時使用靜態方法呼叫、來源產生的規則運算式、解譯的規則運算式以及編譯的規則運算式來改善應用程式的效能。

靜態規則運算式

建議您使用靜態規則運算式方法來替代使用相同的規則運算式重複具現化規則運算式物件。 與規則運算式物件所使用的規則運算式模式不同的是，規則運算式引擎會在內部快取作業程式碼 (opcodes) 或是從靜態方法呼叫中所使用模式編譯的通用中間語言 (CIL)。

例如，事件處理常式經常會呼叫另一個方法來驗證使用者輸入。 下列程式碼中會反映這個範例，其中 Button 控制項的 Click 事件會用來呼叫名為 IsValidCurrency 的方法，該方法會檢查使用者是否已輸入貨幣符號且後面至少有一個十進位數字。

public void OKButton_Click(object sender, EventArgs e)
{
   if (! String.IsNullOrEmpty(sourceCurrency.Text))
      if (RegexLib.IsValidCurrency(sourceCurrency.Text))
         PerformConversion();
      else
         status.Text = "The source currency value is invalid.";
}

Public Sub OKButton_Click(sender As Object, e As EventArgs) _
           Handles OKButton.Click

    If Not String.IsNullOrEmpty(sourceCurrency.Text) Then
        If RegexLib.IsValidCurrency(sourceCurrency.Text) Then
            PerformConversion()
        Else
            status.Text = "The source currency value is invalid."
        End If
    End If
End Sub

下列範例示範沒有效率的 IsValidCurrency 方法實作：

using System;
using System.Text.RegularExpressions;

public class RegexLib
{
   public static bool IsValidCurrency(string currencyValue)
   {
      string pattern = @"\p{Sc}+\s*\d+";
      Regex currencyRegex = new Regex(pattern);
      return currencyRegex.IsMatch(currencyValue);
   }
}

Imports System.Text.RegularExpressions

Public Module RegexLib
    Public Function IsValidCurrency(currencyValue As String) As Boolean
        Dim pattern As String = "\p{Sc}+\s*\d+"
        Dim currencyRegex As New Regex(pattern)
        Return currencyRegex.IsMatch(currencyValue)
    End Function
End Module

建議用呼叫靜態 Regex.IsMatch(String, String) 方法取代上述沒有效率的程式碼。 這個方法就不必在每次您想要呼叫模式比對方法時具現化 Regex 物件，並且可讓規則運算式引擎從其快取擷取編譯版的規則運算式。

using System;
using System.Text.RegularExpressions;

public class RegexLib2
{
   public static bool IsValidCurrency(string currencyValue)
   {
      string pattern = @"\p{Sc}+\s*\d+";
      return Regex.IsMatch(currencyValue, pattern);
   }
}

Imports System.Text.RegularExpressions

Public Module RegexLib
    Public Function IsValidCurrency(currencyValue As String) As Boolean
        Dim pattern As String = "\p{Sc}+\s*\d+"
        Return Regex.IsMatch(currencyValue, pattern)
    End Function
End Module

根據預設，會快取 15 個最近使用的靜態規則運算式模式。 針對需要大量快取之靜態規則運算式的應用程式，快取的大小可以透過設定 Regex.CacheSize 屬性加以調整。

這個範例中使用的規則運算式 \p{Sc}+\s*\d+ 會驗證輸入字串是否具有貨幣符號和至少一個十進位數字。 模式的定義方式如下表所示：

解譯與來源產生與編譯的規則運算式

未透過指定 Compiled 選項繫結程序至規則運算式引擎的規則運算式模式會加以解譯。 具現化規則運算式物件時，規則運算式引擎會將規則運算式轉換成一組作業程式碼。 呼叫執行個體方法時，作業程式碼會轉換成 CIL 並且由 JIT 編譯器執行。 同樣地，當呼叫靜態規則運算式方法而快取中找不到規則運算式時，規則運算式引擎會將規則運算式轉換成一組作業程式碼，並且將它們儲存到快取中。 然後引擎會將這些作業程式碼轉換成 CIL，JIT 編譯器就可以執行這些作業程式碼。 解譯的規則運算式會藉由放慢執行時間來縮短啟動時間。 由於此程序，在少數方法呼叫中使用規則運算式時，或是雖然不知道規則運算式方法呼叫的確實數目，但是期望數目很少時，最適合使用解譯的規則運算式。 隨著方法呼叫的數目增加，放慢執行速度就會壓縮掉縮短啟動時間所獲得的效能。

透過指定 Compiled 選項繫結程序至規則運算式引擎的規則運算式模式會加以編譯。 因此，當具現化規則運算式物件，或是當呼叫靜態規則運算式方法而快取中找不到規則運算式時，規則運算式引擎會將規則運算式轉換成一組中繼的作業程式碼。 這些代碼接著會轉換成 CIL。 呼叫方法時，JIT 編譯器會執行 CIL。 與解譯的規則運算式相反的是，編譯的規則運算式會延長啟動時間，但加快執行個別模式比對方法的速度。 因此，編譯規則運算式所獲得的效能優勢會與呼叫的規則運算式方法數目成比例。

透過使用 GeneratedRegexAttribute 屬性修飾 Regex 傳回方法繫結至規則運算式引擎的規則運算式模式是來源產生的。 插入編譯器的來源產生器會以 C# 程式碼的形式發出自訂 Regex 衍生實作，其邏輯類似於 RegexOptions.Compiled 在 CIL 中發出的邏輯。 如此可獲得 RegexOptions.Compiled 在輸送量效能上的所有優勢 (事實上更多) 以及 Regex.CompileToAssembly 在啟動時的優勢，但又沒有 CompileToAssembly 那麼複雜。 發出的來源是專案的一部分，這表示也可以輕易地檢視來源和偵錯。

總而言之，我們建議您：

• 當您相對不頻繁地使用特定規則運算式呼叫規則運算式方法時，請使用解譯的正規表示式。
• 如果您在 C# 中使用 Regex 以及編譯時已知的參數，並且相對頻繁地使用特定的規則運算式，則請使用來源產生的規則運算式。
• 當您相對頻繁地使用特定規則運算式呼叫規則運算式方法並使用 .NET 6 或更早版本時，請使用編譯的規則運算式。

難以確定解譯的規則運算式較慢的執行速度會超過縮短啟動時間所產生效益的確切閾值。 也難以確定來源產生或編譯的規則運算式較慢的啟動時間會超過其較快的執行速度所產生效益的閾值。 這些閥值會取決於各種不同的因素，包括規則運算式及其處理之特定資料的複雜度。 若要確定哪些規則運算式能為您的特殊應用程式案例提供最佳效能，您可以使用 Stopwatch 類別來比較兩者的執行時間。

以下範例比較了編譯規則運算式、來源生成的規則運算式以及解釋型規則運算式，在讀取 William D. Guthrie大憲章及其他演說前 10 句和所有句子時的效能。 如範例的輸出所示，僅對規則運算式比對方法進行 10 次呼叫時，解譯或來源產生的規則運算式可提供比編譯的規則運算式更佳的效能。 但是進行大量呼叫 (此案例中為超過 13,000 次) 時，編譯的規則運算式會提供較佳的效能。

const string Pattern = @"\b(\w+((\r?\n)|,?\s))*\w+[.?:;!]";

static readonly HttpClient s_client = new();

[GeneratedRegex(Pattern, RegexOptions.Singleline)]
private static partial Regex GeneratedRegex();

public async static Task RunIt()
{
    Stopwatch sw;
    Match match;
    int ctr;

    string text =
            await s_client.GetStringAsync("https://www.gutenberg.org/cache/epub/64197/pg64197.txt");

    // Read first ten sentences with interpreted regex.
    Console.WriteLine("10 Sentences with Interpreted Regex:");
    sw = Stopwatch.StartNew();
    Regex int10 = new(Pattern, RegexOptions.Singleline);
    match = int10.Match(text);
    for (ctr = 0; ctr <= 9; ctr++)
    {
        if (match.Success)
            // Do nothing with the match except get the next match.
            match = match.NextMatch();
        else
            break;
    }
    sw.Stop();
    Console.WriteLine("   {0} matches in {1}", ctr, sw.Elapsed);

    // Read first ten sentences with compiled regex.
    Console.WriteLine("10 Sentences with Compiled Regex:");
    sw = Stopwatch.StartNew();
    Regex comp10 = new Regex(Pattern,
                 RegexOptions.Singleline | RegexOptions.Compiled);
    match = comp10.Match(text);
    for (ctr = 0; ctr <= 9; ctr++)
    {
        if (match.Success)
            // Do nothing with the match except get the next match.
            match = match.NextMatch();
        else
            break;
    }
    sw.Stop();
    Console.WriteLine("   {0} matches in {1}", ctr, sw.Elapsed);

    // Read first ten sentences with source-generated regex.
    Console.WriteLine("10 Sentences with Source-generated Regex:");
    sw = Stopwatch.StartNew();

    match = GeneratedRegex().Match(text);
    for (ctr = 0; ctr <= 9; ctr++)
    {
        if (match.Success)
            // Do nothing with the match except get the next match.
            match = match.NextMatch();
        else
            break;
    }
    sw.Stop();
    Console.WriteLine("   {0} matches in {1}", ctr, sw.Elapsed);

    // Read all sentences with interpreted regex.
    Console.WriteLine("All Sentences with Interpreted Regex:");
    sw = Stopwatch.StartNew();
    Regex intAll = new(Pattern, RegexOptions.Singleline);
    match = intAll.Match(text);
    int matches = 0;
    while (match.Success)
    {
        matches++;
        // Do nothing with the match except get the next match.
        match = match.NextMatch();
    }
    sw.Stop();
    Console.WriteLine("   {0:N0} matches in {1}", matches, sw.Elapsed);

    // Read all sentences with compiled regex.
    Console.WriteLine("All Sentences with Compiled Regex:");
    sw = Stopwatch.StartNew();
    Regex compAll = new(Pattern,
                    RegexOptions.Singleline | RegexOptions.Compiled);
    match = compAll.Match(text);
    matches = 0;
    while (match.Success)
    {
        matches++;
        // Do nothing with the match except get the next match.
        match = match.NextMatch();
    }
    sw.Stop();
    Console.WriteLine("   {0:N0} matches in {1}", matches, sw.Elapsed);

    // Read all sentences with source-generated regex.
    Console.WriteLine("All Sentences with Source-generated Regex:");
    sw = Stopwatch.StartNew();
    match = GeneratedRegex().Match(text);
    matches = 0;
    while (match.Success)
    {
        matches++;
        // Do nothing with the match except get the next match.
        match = match.NextMatch();
    }
    sw.Stop();
    Console.WriteLine("   {0:N0} matches in {1}", matches, sw.Elapsed);

    return;
}
/* The example displays output similar to the following:

   10 Sentences with Interpreted Regex:
       10 matches in 00:00:00.0104920
   10 Sentences with Compiled Regex:
       10 matches in 00:00:00.0234604
   10 Sentences with Source-generated Regex:
       10 matches in 00:00:00.0060982
   All Sentences with Interpreted Regex:
       3,427 matches in 00:00:00.1745455
   All Sentences with Compiled Regex:
       3,427 matches in 00:00:00.0575488
   All Sentences with Source-generated Regex:
       3,427 matches in 00:00:00.2698670
*/

範例中所使用規則運算式模式 \b(\w+((\r?\n)|,?\s))*\w+[.?:;!] 的定義方式如下表所示：

控制回溯

通常規則運算式引擎會使用線性迴歸逐一處理輸入字串，並且與規則運算式模式比較。 不過，當規則運算式模式中使用不定數的數量詞 (例如 *、+ 和 ?) 時，規則運算式引擎可能會放棄一部分成功的部分符合結果，並且返回之前儲存的狀態，以便搜尋與整個模式完全相符的結果。 這個程序稱為「回溯」(Backtracking)。

支援回溯能讓規則運算式更強大且更靈活， 同時還能讓規則運算式開發人員負責掌控規則運算式引擎的作業。 由於開發人員經常忽略這個責任而誤用回溯或大量使用回溯，因而時常是造成規則運算式效能低落的最重要原因。 在最糟的情況下，輸入字串中每個超出字元的執行時間可能會倍增。 事實上，藉由過度使用回溯，如果輸入幾乎符合規則運算式模式，就很容易建立無窮迴圈的程式設計對等項目。 規則運算式引擎可能需要數小時或甚至數天才能處理相對簡短的輸入字串。

儘管回溯並不是比對的要件，應用程式常常會因為使用回溯而影響效能。 例如，規則運算式 \b\p{Lu}\w*\b 會比對所有開頭為大寫字元的文字，如下表所示：

由於字緣與文字字元不同，也不是文字字元的子集，因此規則運算式引擎不可能在比對文字字元時跨越字緣。 因此，針對這個規則運算式，回溯可能對任何相符項目的整體成功永遠不會有任何助益。 它可能只會降低效能，因為會強制規則運算式引擎在符合文字字元的每個成功初步比對時儲存其狀態。

如果您判斷不需要回溯，則您可以透過幾種方式加以停用：

• 藉由設定 RegexOptions.NonBacktracking 選項 (在 .NET 7 中引進)。 如需詳細資訊，請參閱非回溯模式。

• 藉由使用 (?>subexpression) 語言元素，也稱為不可部分完成的群組。 下列範例會使用兩個規則運算式剖析輸入字串。 首先，\b\p{Lu}\w*\b 會仰賴回溯。 第二，\b\p{Lu}(?>\w*)\b 會停用回溯。 如範例的輸出所示，兩者會產生相同的結果：

  using System;
  using System.Text.RegularExpressions;
  
  public class BackTrack2Example
  {
      public static void Main()
      {
          string input = "This this word Sentence name Capital";
          string pattern = @"\b\p{Lu}\w*\b";
          foreach (Match match in Regex.Matches(input, pattern))
              Console.WriteLine(match.Value);
  
          Console.WriteLine();
  
          pattern = @"\b\p{Lu}(?>\w*)\b";
          foreach (Match match in Regex.Matches(input, pattern))
              Console.WriteLine(match.Value);
      }
  }
  // The example displays the following output:
  //       This
  //       Sentence
  //       Capital
  //
  //       This
  //       Sentence
  //       Capital
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim input As String = "This this word Sentence name Capital"
          Dim pattern As String = "\b\p{Lu}\w*\b"
          For Each match As Match In Regex.Matches(input, pattern)
              Console.WriteLine(match.Value)
          Next
          Console.WriteLine()
  
          pattern = "\b\p{Lu}(?>\w*)\b"
          For Each match As Match In Regex.Matches(input, pattern)
              Console.WriteLine(match.Value)
          Next
      End Sub
  End Module
  ' The example displays the following output:
  '       This
  '       Sentence
  '       Capital
  '       
  '       This
  '       Sentence
  '       Capital
  

在許多情況下，回溯是比對規則運算式模式與輸入文字時所必要。 不過，大量回溯可能嚴重降低效能，並且製造應用程式停止回應的印象。 尤其是當數量詞為巢狀，而且符合外部子運算式的文字是符合內部子運算式之文字的子集時，就會發生這個問題。

例如，規則運算式模式 ^[0-9A-Z]([-.\w]*[0-9A-Z])*\$$ 的目的在於比對至少包含一個英數字元的零件編號。 任何額外的字元都可能包含英數字元、連字號、底線或句號，不過最後一個字元必須是英數字。 $ 符號則結束零件編號。 在某些情況下，這個規則運算式模式可能顯現出不佳的效能，因為數量詞為巢狀，而且子運算式 [0-9A-Z] 是子運算式 [-.\w]* 的子集。

在這類情況下，您可以移除巢狀數量詞，並且將外部子運算式取代為零寬度的右合樣或左合樣判斷提示，藉此最佳化規則運算式的效能。 右合樣和左合樣判斷提示是錨點。 它們不會移動輸入字串中的指標，而是向右或向左合樣，以檢查是否符合指定的條件。 例如，零件編號規則運算式可以重寫為 ^[0-9A-Z][-.\w]*(?<=[0-9A-Z])\$$。 這個規則運算式模式的定義方式如下表所示：

下列範例說明如何使用這個規則運算式比對包含可能零件編號的陣列：

using System;
using System.Text.RegularExpressions;

public class BackTrack4Example
{
    public static void Main()
    {
        string pattern = @"^[0-9A-Z][-.\w]*(?<=[0-9A-Z])\$$";
        string[] partNos = { "A1C$", "A4", "A4$", "A1603D$", "A1603D#" };

        foreach (var input in partNos)
        {
            Match match = Regex.Match(input, pattern);
            if (match.Success)
                Console.WriteLine(match.Value);
            else
                Console.WriteLine("Match not found.");
        }
    }
}
// The example displays the following output:
//       A1C$
//       Match not found.
//       A4$
//       A1603D$
//       Match not found.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^[0-9A-Z][-.\w]*(?<=[0-9A-Z])\$$"
        Dim partNos() As String = {"A1C$", "A4", "A4$", "A1603D$",
                                    "A1603D#"}

        For Each input As String In partNos
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then
                Console.WriteLine(match.Value)
            Else
                Console.WriteLine("Match not found.")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       A1C$
'       Match not found.
'       A4$
'       A1603D$
'       Match not found.

.NET 中的規則運算式語言包括下列語言項目，可讓您用來消除巢狀數量詞。 如需詳細資訊，請參閱分組建構。

使用逾時值

如果您的規則運算式會處理幾乎符合規則運算式模式的輸入，它經常會依賴大量回溯，如此就會大幅影響其效能。 除了仔細考量使用回溯以及對幾乎符合的輸入進行規則運算式測試之外，務必要設定逾時值，以確保將大量回溯 (如發生的話) 的影響降至最低。

規則運算式逾時間隔會定義規則運算式引擎在逾時前，將尋找單一相符項目的一段時間。根據規則運算式模式和輸入文字，執行時間可能會超過指定的逾時間隔，但不會花費比指定的逾時間隔更多的時間回溯。 預設的逾時間隔是 Regex.InfiniteMatchTimeout，這表示規則運算式不會逾時。您可以依照下述方式覆寫這個值並定義逾時間隔：

• 呼叫 Regex(String, RegexOptions, TimeSpan) 建構函式，以提供具現化 Regex 物件時的逾時值。

• 呼叫靜態模式比對方法，例如，包含 matchTimeout 參數的 Regex.Match(String, String, RegexOptions, TimeSpan) 或 Regex.Replace(String, String, String, RegexOptions, TimeSpan)。

• 使用 AppDomain.CurrentDomain.SetData("REGEX_DEFAULT_MATCH_TIMEOUT", TimeSpan.FromMilliseconds(100)); 之類的程式碼設定整個處理程序或整個應用程式網域範圍的值。

如果您已定義逾時間隔，但是在該間隔結束時未找到相符項目，則規則運算式方法會擲回 RegexMatchTimeoutException 例外狀況。 在例外處理常式中，您可以選擇以較長的逾時間隔重試比對、放棄比對嘗試並假設沒有相符項目，或是放棄比對嘗試並記錄例外狀況資訊供未來進行分析。

下列範例將定義 GetWordData 方法，該方法會具現化逾時間隔為 350 毫秒的規則運算式，以計算文字文件中的字數和一個字的平均字元數。 如果比對作業逾時，則逾時間隔將增加 350 毫秒，並且重新具現化 Regex 物件。 如果新的逾時間隔超過一秒，則方法會重新擲回例外狀況至呼叫端。

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

public class TimeoutExample
{
    public static void Main()
    {
        RegexUtilities util = new RegexUtilities();
        string title = "Doyle - The Hound of the Baskervilles.txt";
        try
        {
            var info = util.GetWordData(title);
            Console.WriteLine("Words:               {0:N0}", info.Item1);
            Console.WriteLine("Average Word Length: {0:N2} characters", info.Item2);
        }
        catch (IOException e)
        {
            Console.WriteLine("IOException reading file '{0}'", title);
            Console.WriteLine(e.Message);
        }
        catch (RegexMatchTimeoutException e)
        {
            Console.WriteLine("The operation timed out after {0:N0} milliseconds",
                              e.MatchTimeout.TotalMilliseconds);
        }
    }
}

public class RegexUtilities
{
    public Tuple<int, double> GetWordData(string filename)
    {
        const int MAX_TIMEOUT = 1000;   // Maximum timeout interval in milliseconds.
        const int INCREMENT = 350;      // Milliseconds increment of timeout.

        List<string> exclusions = new List<string>(new string[] { "a", "an", "the" });
        int[] wordLengths = new int[29];        // Allocate an array of more than ample size.
        string input = null;
        StreamReader sr = null;
        try
        {
            sr = new StreamReader(filename);
            input = sr.ReadToEnd();
        }
        catch (FileNotFoundException e)
        {
            string msg = String.Format("Unable to find the file '{0}'", filename);
            throw new IOException(msg, e);
        }
        catch (IOException e)
        {
            throw new IOException(e.Message, e);
        }
        finally
        {
            if (sr != null) sr.Close();
        }

        int timeoutInterval = INCREMENT;
        bool init = false;
        Regex rgx = null;
        Match m = null;
        int indexPos = 0;
        do
        {
            try
            {
                if (!init)
                {
                    rgx = new Regex(@"\b\w+\b", RegexOptions.None,
                                    TimeSpan.FromMilliseconds(timeoutInterval));
                    m = rgx.Match(input, indexPos);
                    init = true;
                }
                else
                {
                    m = m.NextMatch();
                }
                if (m.Success)
                {
                    if (!exclusions.Contains(m.Value.ToLower()))
                        wordLengths[m.Value.Length]++;

                    indexPos += m.Length + 1;
                }
            }
            catch (RegexMatchTimeoutException e)
            {
                if (e.MatchTimeout.TotalMilliseconds < MAX_TIMEOUT)
                {
                    timeoutInterval += INCREMENT;
                    init = false;
                }
                else
                {
                    // Rethrow the exception.
                    throw;
                }
            }
        } while (m.Success);

        // If regex completed successfully, calculate number of words and average length.
        int nWords = 0;
        long totalLength = 0;

        for (int ctr = wordLengths.GetLowerBound(0); ctr <= wordLengths.GetUpperBound(0); ctr++)
        {
            nWords += wordLengths[ctr];
            totalLength += ctr * wordLengths[ctr];
        }
        return new Tuple<int, double>(nWords, totalLength / nWords);
    }
}

Imports System.Collections.Generic
Imports System.IO
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim util As New RegexUtilities()
        Dim title As String = "Doyle - The Hound of the Baskervilles.txt"
        Try
            Dim info = util.GetWordData(title)
            Console.WriteLine("Words:               {0:N0}", info.Item1)
            Console.WriteLine("Average Word Length: {0:N2} characters", info.Item2)
        Catch e As IOException
            Console.WriteLine("IOException reading file '{0}'", title)
            Console.WriteLine(e.Message)
        Catch e As RegexMatchTimeoutException
            Console.WriteLine("The operation timed out after {0:N0} milliseconds",
                              e.MatchTimeout.TotalMilliseconds)
        End Try
    End Sub
End Module

Public Class RegexUtilities
    Public Function GetWordData(filename As String) As Tuple(Of Integer, Double)
        Const MAX_TIMEOUT As Integer = 1000  ' Maximum timeout interval in milliseconds.
        Const INCREMENT As Integer = 350     ' Milliseconds increment of timeout.

        Dim exclusions As New List(Of String)({"a", "an", "the"})
        Dim wordLengths(30) As Integer        ' Allocate an array of more than ample size.
        Dim input As String = Nothing
        Dim sr As StreamReader = Nothing
        Try
            sr = New StreamReader(filename)
            input = sr.ReadToEnd()
        Catch e As FileNotFoundException
            Dim msg As String = String.Format("Unable to find the file '{0}'", filename)
            Throw New IOException(msg, e)
        Catch e As IOException
            Throw New IOException(e.Message, e)
        Finally
            If sr IsNot Nothing Then sr.Close()
        End Try

        Dim timeoutInterval As Integer = INCREMENT
        Dim init As Boolean = False
        Dim rgx As Regex = Nothing
        Dim m As Match = Nothing
        Dim indexPos As Integer = 0
        Do
            Try
                If Not init Then
                    rgx = New Regex("\b\w+\b", RegexOptions.None,
                                    TimeSpan.FromMilliseconds(timeoutInterval))
                    m = rgx.Match(input, indexPos)
                    init = True
                Else
                    m = m.NextMatch()
                End If
                If m.Success Then
                    If Not exclusions.Contains(m.Value.ToLower()) Then
                        wordLengths(m.Value.Length) += 1
                    End If
                    indexPos += m.Length + 1
                End If
            Catch e As RegexMatchTimeoutException
                If e.MatchTimeout.TotalMilliseconds < MAX_TIMEOUT Then
                    timeoutInterval += INCREMENT
                    init = False
                Else
                    ' Rethrow the exception.
                    Throw
                End If
            End Try
        Loop While m.Success

        ' If regex completed successfully, calculate number of words and average length.
        Dim nWords As Integer
        Dim totalLength As Long

        For ctr As Integer = wordLengths.GetLowerBound(0) To wordLengths.GetUpperBound(0)
            nWords += wordLengths(ctr)
            totalLength += ctr * wordLengths(ctr)
        Next
        Return New Tuple(Of Integer, Double)(nWords, totalLength / nWords)
    End Function
End Class

必要時擷取

.NET 中的規則運算式支援群建置構，可讓您將規則運算式模式與一或多個子運算式設為群組。 .NET 規則運算式語言中最常用的群組建構為 (subexpression) (用於定義已編號的擷取群組) 和 (?<name>subexpression) (用於定義具名擷取群組)。 群組建構是建立反向參考和定義套用數量詞之子運算式的要件。

不過，使用這些語言項目也有其代價。 這些語言項目會造成在 Match.Groups 屬性傳回的 GroupCollection 物件中填入最近使用的未命名或具名擷取。 如果單一群建置構擷取了輸入字串中的多個子字串，則這些語言項目也會在特定擷取群組的 Group.Captures 屬性傳回的 CaptureCollection 物件中填入多個 Capture 物件。

通常，只有在規則運算式中才會使用分組建構，以便能將數量詞套用上去。 稍後不會使用這些子運算式所擷取的群組。 例如，規則運算式 \b(\w+[;,]?\s?)+[.?!] 是設計用來擷取整個句子。 下表描述這個規則運算式模式中的語言項目，及其對於 Match 物件的 Match.Groups 和 Group.Captures 集合造成的影響：

如下列範例所示，找到符合的結果時，GroupCollection 和 CaptureCollection 物件中都會填入比對所擷取的項目。 在此案例中，擷取群組 (\w+[;,]?\s?) 會存在，如此 + 數量詞就能套用至其中，這樣就能讓規則運算式模式比對句子中的每個字。 否則就會比對句子中的最後一個字。

using System;
using System.Text.RegularExpressions;

public class Group1Example
{
    public static void Main()
    {
        string input = "This is one sentence. This is another.";
        string pattern = @"\b(\w+[;,]?\s?)+[.?!]";

        foreach (Match match in Regex.Matches(input, pattern))
        {
            Console.WriteLine("Match: '{0}' at index {1}.",
                              match.Value, match.Index);
            int grpCtr = 0;
            foreach (Group grp in match.Groups)
            {
                Console.WriteLine("   Group {0}: '{1}' at index {2}.",
                                  grpCtr, grp.Value, grp.Index);
                int capCtr = 0;
                foreach (Capture cap in grp.Captures)
                {
                    Console.WriteLine("      Capture {0}: '{1}' at {2}.",
                                      capCtr, cap.Value, cap.Index);
                    capCtr++;
                }
                grpCtr++;
            }
            Console.WriteLine();
        }
    }
}
// The example displays the following output:
//       Match: 'This is one sentence.' at index 0.
//          Group 0: 'This is one sentence.' at index 0.
//             Capture 0: 'This is one sentence.' at 0.
//          Group 1: 'sentence' at index 12.
//             Capture 0: 'This ' at 0.
//             Capture 1: 'is ' at 5.
//             Capture 2: 'one ' at 8.
//             Capture 3: 'sentence' at 12.
//
//       Match: 'This is another.' at index 22.
//          Group 0: 'This is another.' at index 22.
//             Capture 0: 'This is another.' at 22.
//          Group 1: 'another' at index 30.
//             Capture 0: 'This ' at 22.
//             Capture 1: 'is ' at 27.
//             Capture 2: 'another' at 30.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "This is one sentence. This is another."
        Dim pattern As String = "\b(\w+[;,]?\s?)+[.?!]"

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Match: '{0}' at index {1}.",
                              match.Value, match.Index)
            Dim grpCtr As Integer = 0
            For Each grp As Group In match.Groups
                Console.WriteLine("   Group {0}: '{1}' at index {2}.",
                                  grpCtr, grp.Value, grp.Index)
                Dim capCtr As Integer = 0
                For Each cap As Capture In grp.Captures
                    Console.WriteLine("      Capture {0}: '{1}' at {2}.",
                                      capCtr, cap.Value, cap.Index)
                    capCtr += 1
                Next
                grpCtr += 1
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       Match: 'This is one sentence.' at index 0.
'          Group 0: 'This is one sentence.' at index 0.
'             Capture 0: 'This is one sentence.' at 0.
'          Group 1: 'sentence' at index 12.
'             Capture 0: 'This ' at 0.
'             Capture 1: 'is ' at 5.
'             Capture 2: 'one ' at 8.
'             Capture 3: 'sentence' at 12.
'       
'       Match: 'This is another.' at index 22.
'          Group 0: 'This is another.' at index 22.
'             Capture 0: 'This is another.' at 22.
'          Group 1: 'another' at index 30.
'             Capture 0: 'This ' at 22.
'             Capture 1: 'is ' at 27.
'             Capture 2: 'another' at 30.

如果您使用子運算式的目的只是要在其中套用數量詞，對於擷取的文字並不感興趣，則應該停用群組擷取。 例如，(?:subexpression) 語言元素會阻止套用該語言元素的群組擷取相符的子字串。 在下列範例中，前一個範例的規則運算式模式會變成 \b(?:\w+[;,]?\s?)+[.?!]。 如輸出所示，它會阻止規則運算式引擎填入 GroupCollection 和 CaptureCollection 集合：

using System;
using System.Text.RegularExpressions;

public class Group2Example
{
    public static void Main()
    {
        string input = "This is one sentence. This is another.";
        string pattern = @"\b(?:\w+[;,]?\s?)+[.?!]";

        foreach (Match match in Regex.Matches(input, pattern))
        {
            Console.WriteLine("Match: '{0}' at index {1}.",
                              match.Value, match.Index);
            int grpCtr = 0;
            foreach (Group grp in match.Groups)
            {
                Console.WriteLine("   Group {0}: '{1}' at index {2}.",
                                  grpCtr, grp.Value, grp.Index);
                int capCtr = 0;
                foreach (Capture cap in grp.Captures)
                {
                    Console.WriteLine("      Capture {0}: '{1}' at {2}.",
                                      capCtr, cap.Value, cap.Index);
                    capCtr++;
                }
                grpCtr++;
            }
            Console.WriteLine();
        }
    }
}
// The example displays the following output:
//       Match: 'This is one sentence.' at index 0.
//          Group 0: 'This is one sentence.' at index 0.
//             Capture 0: 'This is one sentence.' at 0.
//
//       Match: 'This is another.' at index 22.
//          Group 0: 'This is another.' at index 22.
//             Capture 0: 'This is another.' at 22.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "This is one sentence. This is another."
        Dim pattern As String = "\b(?:\w+[;,]?\s?)+[.?!]"

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Match: '{0}' at index {1}.",
                              match.Value, match.Index)
            Dim grpCtr As Integer = 0
            For Each grp As Group In match.Groups
                Console.WriteLine("   Group {0}: '{1}' at index {2}.",
                                  grpCtr, grp.Value, grp.Index)
                Dim capCtr As Integer = 0
                For Each cap As Capture In grp.Captures
                    Console.WriteLine("      Capture {0}: '{1}' at {2}.",
                                      capCtr, cap.Value, cap.Index)
                    capCtr += 1
                Next
                grpCtr += 1
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       Match: 'This is one sentence.' at index 0.
'          Group 0: 'This is one sentence.' at index 0.
'             Capture 0: 'This is one sentence.' at 0.
'       
'       Match: 'This is another.' at index 22.
'          Group 0: 'This is another.' at index 22.
'             Capture 0: 'This is another.' at 22.

您可以透過下列其中一種方式停用擷取：

• 使用 (?:subexpression) 語言元素。 這個項目會阻止在套用該項目的群組中擷取相符的子字串。 不過，它不會停用任何巢狀群組中的子字串擷取。

• 使用 ExplicitCapture 選項。 這個選項會停用規則運算式模式中的所有未命名或隱含擷取。 當您使用這個選項時，只會擷取符合 (?<name>subexpression) 語言元素所定義之具名群組的子字串。 ExplicitCapture 旗標可以傳遞至 options 類別建構函式的 Regex 參數，或是 options 靜態比對方法的 Regex 參數。

• 在 n 語言項目中使用 (?imnsx) 選項。 這個選項會從規則運算式模式中出現該項目的位置開始，停用所有未命名或隱含擷取。 在到達模式結尾或 (-n) 選項啟用未命名或隱含擷取之前，擷取都會是停用狀態。 如需詳細資訊，請參閱其他建構。

• 在 n 語言項目中使用 (?imnsx:subexpression) 選項。 這個選項會停用 subexpression 中的所有未命名或隱含擷取。 任何未命名或隱含巢狀擷取群組所進行的擷取也都會停用。

執行緒安全

Regex 類別本身為不變 (唯讀) 的安全執行緒。 也就是說，您可以在任何執行緒上建立 Regex 物件，並在執行緒之間共用；您也可以從任何執行緒呼叫比對方法，而不會變更任何全域狀態。

不過，Regex 所傳回的結果物件 (Match 和 MatchCollection) 應該在單一執行緒上使用。 雖然這當中有許多物件在邏輯上是不可變的，但它們的實作可能會延遲某些結果的計算來提升效能，因此，呼叫端必須進行序列化存取。

如果您需要在多個執行緒上共用 Regex 個結果物件，可透過呼叫這些物件的同步方法，將其轉換成安全執行緒的執行個體。 所有的規則運算式類別 (除了列舉程式以外) 都是安全執行緒，或可利用同步處理方法轉換為安全執行緒物件。

列舉程式是唯一的例外狀況。 您必須將集合列舉程式的呼叫序列化。 規則是，如果某個集合可以在多個執行緒上同時列舉，您就應該在列舉程式所周遊之集合的根物件位置，同步處理列舉程式方法。

相關文章