RegexCompilationInfo.MatchTimeout 属性

定义

命名空间:

System.Text.RegularExpressions

程序集:

System.Text.RegularExpressions.dll

Source:

RegexCompilationInfo.cs

获取或设置正则表达式的默认超时间隔。

public:
 property TimeSpan MatchTimeout { TimeSpan get(); void set(TimeSpan value); };

public TimeSpan MatchTimeout { get; set; }

member this.MatchTimeout : TimeSpan with get, set

Public Property MatchTimeout As TimeSpan

属性值

TimeSpan

在样式对的操作可经过的默认最长时间间隔时间，在 RegexMatchTimeoutException 引发之前或 InfiniteMatchTimeout ，如果挂起被禁用。

示例

以下示例定义一个名为 DuplicateChars 的单个编译正则表达式，该正则表达式标识输入字符串中同一字符的两个或更多个匹配项。 编译的正则表达式的默认超时为 2 秒。 执行该示例时，它会创建一个名为 RegexLib.dll 的类库，其中包含编译的正则表达式。

using System;
using System.Reflection;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
        // Match two or more occurrences of the same character.
        string pattern = @"(\w)\1+";
        
        // Use case-insensitive matching. 
        var rci = new RegexCompilationInfo(pattern, RegexOptions.IgnoreCase,
                                           "DuplicateChars", "CustomRegexes", 
                                           true, TimeSpan.FromSeconds(2));

        // Define an assembly to contain the compiled regular expression.
        var an = new AssemblyName();
        an.Name = "RegexLib";
        RegexCompilationInfo[] rciList = { rci };

        // Compile the regular expression and create the assembly.
        Regex.CompileToAssembly(rciList, an);
   }
}

Imports System.Reflection
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
        ' Match two or more occurrences of the same character.
        Dim pattern As String = "(\w)\1+"
        
        ' Use case-insensitive matching. 
        Dim rci As New RegexCompilationInfo(pattern, RegexOptions.IgnoreCase,
                                            "DuplicateChars", "CustomRegexes", 
                                            True, TimeSpan.FromSeconds(2))

        ' Define an assembly to contain the compiled regular expression.
        Dim an As New AssemblyName()
        an.Name = "RegexLib"
        Dim rciList As RegexCompilationInfo() = New RegexCompilationInfo() { rci }

        ' Compile the regular expression and create the assembly.
        Regex.CompileToAssembly(rciList, an)
   End Sub
End Module

正则表达式模式 (\w)\1+ 的定义如下表所示。

模式	说明
(\w)	匹配任意单词字符，并将其分配给第一个捕获组。
\1+	匹配第一个捕获组的值的一个或多个匹配项。

以下示例使用 DuplicatedChars 正则表达式来标识字符串数组中的重复字符。 调用 DuplicatedChars 构造函数时，它会将超时间隔更改为 0.5 秒。

using CustomRegexes;
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      var rgx = new DuplicateChars(TimeSpan.FromSeconds(.5));
      
      string[] values = { "Greeeeeat", "seed", "deed", "beam", 
                          "loop", "Aardvark" };
      // Display regex information.
      Console.WriteLine("Regular Expression Pattern: {0}", rgx);
      Console.WriteLine("Regex timeout value: {0} seconds\n", 
                        rgx.MatchTimeout.TotalSeconds);
      
      // Display matching information.
      foreach (var value in values) {
         Match m = rgx.Match(value);
         if (m.Success)
            Console.WriteLine("'{0}' found in '{1}' at positions {2}-{3}",
                              m.Value, value, m.Index, m.Index + m.Length - 1);
         else
            Console.WriteLine("No match found in '{0}'", value);
      }                                                         
   }
}
// The example displays the following output:
//       Regular Expression Pattern: (\w)\1+
//       Regex timeout value: 0.5 seconds
//       
//       //eeeee// found in //Greeeeeat// at positions 2-6
//       //ee// found in //seed// at positions 1-2
//       //ee// found in //deed// at positions 1-2
//       No match found in //beam//
//       //oo// found in //loop// at positions 1-2
//       //Aa// found in //Aardvark// at positions 0-1

Imports CustomRegexes
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim rgx As New DuplicateChars(TimeSpan.FromSeconds(.5))
      
      Dim values() As String = { "Greeeeeat", "seed", "deed", "beam", 
                                 "loop", "Aardvark" }
      ' Display regex information.
      Console.WriteLine("Regular Expression Pattern: {0}", rgx)
      Console.WriteLine("Regex timeout value: {0} seconds", 
                        rgx.MatchTimeout.TotalSeconds)
      Console.WriteLine()
      
      ' Display matching information.
      For Each value In values
         Dim m As Match = rgx.Match(value)
         If m.Success Then
            Console.WriteLine("'{0}' found in '{1}' at positions {2}-{3}",
                              m.Value, value, m.Index, m.Index + m.Length - 1)
         Else
            Console.WriteLine("No match found in '{0}'", value)
         End If   
      Next                                                         
   End Sub
End Module
' The example displays the following output:
'       Regular Expression Pattern: (\w)\1+
'       Regex timeout value: 0.5 seconds
'       
'       'eeeee' found in 'Greeeeeat' at positions 2-6
'       'ee' found in 'seed' at positions 1-2
'       'ee' found in 'deed' at positions 1-2
'       No match found in 'beam'
'       'oo' found in 'loop' at positions 1-2
'       'Aa' found in 'Aardvark' at positions 0-1

注解

属性 MatchTimeout 定义已编译正则表达式的默认超时间隔。 此值表示编译的正则表达式在操作超时和正则表达式引擎在其下一次RegexMatchTimeoutException计时检查引发异常之前执行单个匹配操作的大致时间量。

重要

建议始终为已编译的正则表达式设置默认超时值。 正则表达式库的使用者可以通过将表示新超时间隔的值传递给 TimeSpan 编译的正则表达式的类构造函数来替代该超时值。

可以通过以下任一 RegexCompilationInfo 方式为对象分配默认超时值：

• 通过调用 AppDomain.SetData 方法并为“REGEX_DEFAULT_MATCH_TIMEOUT”属性提供值的字符串表示形式 TimeSpan 。

• 通过调用 RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan) 构造函数并为 参数提供值 matchTimeout 。

• 通过设置此属性的值。

若要设置合理的超时间隔，请考虑以下因素：

• 正则表达式模式的长度和复杂性。 与更短和更简单的正则表达式相比，更长和更复杂的正则表达式需要更长的时间。

• 预期的计算机负载。 在 CPU 和内存利用率较高的系统上，处理会花费更多时间。

另请参阅

• RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan)