RegexCompilationInfo.MatchTimeout Egenskap

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

Egenskapsvärde

Det maximala standardtidsintervallet som kan förflutit i en mönstermatchningsåtgärd innan en RegexMatchTimeoutException utlöses eller InfiniteMatchTimeout om tidsgränser inaktiveras.

Exempel

I följande exempel definieras ett enda kompilerat reguljärt uttryck med namnet DuplicateChars som identifierar två eller flera förekomster av samma tecken i en indatasträng. Det kompilerade reguljära uttrycket har en standardtid på 2 sekunder. När du kör exemplet skapas ett klassbibliotek med namnet RegexLib.dll som innehåller det kompilerade reguljära uttrycket.

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

Mönster för (\w)\1+ reguljära uttryck definieras enligt följande tabell.

I följande exempel används det DuplicatedChars reguljära uttrycket för att identifiera dubbletttecken i en strängmatris. När konstruktorn anropas DuplicatedChars ändras tidsgränsintervallet till 0,5 sekunder.

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

Kommentarer

Egenskapen MatchTimeout definierar standardintervallet för timeout för det kompilerade reguljära uttrycket. Det här värdet representerar den ungefärliga tid som ett kompilerat reguljärt uttryck ska köra en enda matchningsåtgärd innan åtgärden överskrider tidsgränsen och motorn för reguljära uttryck utlöser ett RegexMatchTimeoutException undantag under nästa tidskontroll.

Du kan tilldela ett standardvärde för timeout till ett RegexCompilationInfo objekt på något av följande sätt:

• Genom att anropa AppDomain.SetData metoden och ange strängrepresentationen av ett TimeSpan värde för egenskapen "REGEX_DEFAULT_MATCH_TIMEOUT".

• Genom att anropa RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan) konstruktorn och ange ett värde för parametern matchTimeout .

• Genom att ange värdet för den här egenskapen.

Tänk på följande faktorer för att ange ett rimligt tidsgränsintervall:

• Längden och komplexiteten i det reguljära uttrycksmönstret. Längre och mer komplexa reguljära uttryck kräver mer tid än kortare och enklare uttryck.

• Den förväntade datorbelastningen. Bearbetningen tar längre tid på system med hög processor- och minnesanvändning.

Se även

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