RegexCompilationInfo.MatchTimeout Eigenschaft

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

Eigenschaftswert

Das standardmäßige maximale Zeitintervall, das in einem Mustervergleichsvorgang verstreichen kann, bevor eine RegexMatchTimeoutException-Ausnahme ausgelöst wird, oder InfiniteMatchTimeout, wenn Timeouts deaktiviert sind.

Beispiele

Im folgenden Beispiel wird ein einzelner kompilierter regulärer Ausdruck namens DuplicateChars definiert, der zwei oder mehr Vorkommen desselben Zeichens in einer Eingabezeichenfolge identifiziert. Der kompilierte reguläre Ausdruck weist ein Standardtimeout von 2 Sekunden auf. Wenn Sie das Beispiel ausführen, wird eine Klassenbibliothek namens RegexLib.dll erstellt, die den kompilierten regulären Ausdruck enthält.

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

Das Muster für reguläre Ausdrücke (\w)\1+ wird entsprechend der folgenden Tabelle definiert:

Im folgenden Beispiel wird der DuplicatedChars reguläre Ausdruck verwendet, um doppelte Zeichen in einem Zeichenfolgenarray zu identifizieren. Wenn der DuplicatedChars Konstruktor aufgerufen wird, ändert er das Timeoutintervall in 5 Sekunden.

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

Hinweise

Die MatchTimeout -Eigenschaft definiert das Standardtimeoutintervall für den kompilierten regulären Ausdruck. Dieser Wert stellt die ungefähre Zeitspanne dar, die ein kompilierter regulärer Ausdruck einen einzelnen Abgleichsvorgang ausführt, bevor das Timeout des Vorgangs auftritt und die Engine für reguläre Ausdrücke während der nächsten Zeitsteuerung eine RegexMatchTimeoutException Ausnahme auslöst.

Sie können einem RegexCompilationInfo Objekt auf folgende Weise einen Standardtimeoutwert zuweisen:

• Indem Sie die AppDomain.SetData -Methode aufrufen und die Zeichenfolgendarstellung eines TimeSpan Werts für die Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT" bereitstellen.

• Durch Aufrufen des RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan) Konstruktors und Bereitstellen eines Werts für den matchTimeout Parameter.

• Durch Festlegen des Werts dieser Eigenschaft.

Berücksichtigen Sie die folgenden Faktoren, um ein angemessenes Timeoutintervall festzulegen:

• Die Länge und Komplexität des Musters für reguläre Ausdrücke. Längere und komplexere reguläre Ausdrücke erfordern mehr Zeit als kürzere und einfachere Ausdrücke.

• Die erwartete Computerlast. Die Verarbeitung nimmt auf Systemen mit hoher CPU- und Arbeitsspeicherauslastung mehr Zeit in Anspruch.

Gilt für:

Weitere Informationen

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