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 Musterabgleichsvorgang vor dem RegexMatchTimeoutException Auslösen verstrichen werden kann, oder InfiniteMatchTimeout wenn Timeouts deaktiviert sind.

Beispiele

Im folgenden Beispiel wird ein einzelner kompilierter regulärer Ausdruck definiert DuplicateChars , der zwei oder mehr Vorkommen desselben Zeichens in einer Eingabezeichenfolge identifiziert. Der kompilierte reguläre Ausdruck weist einen Standardtimeout von 2 Sekunden auf. Wenn Sie das Beispiel ausführen, wird eine Klassenbibliothek mit dem Namen 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 (\w)\1+ für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt 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, wird das Timeoutintervall in 0,5 Sekunden geändert.

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 der Vorgang timeout auftritt, und das Modul für reguläre Ausdrücke löst während der nächsten Zeitüberprüfung eine RegexMatchTimeoutException Ausnahme aus.

Sie können einem RegexCompilationInfo Objekt auf eine der folgenden Arten einen Standardtimeoutwert zuweisen:

• Durch Aufrufen der AppDomain.SetData Methode und Bereitstellen der Zeichenfolgendarstellung eines TimeSpan Werts für die Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT".

• 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.

Um ein angemessenes Timeoutintervall festzulegen, berücksichtigen Sie die folgenden Faktoren:

• 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 benötigt mehr Zeit auf Systemen mit hoher CPU- und Arbeitsspeicherauslastung.

Weitere Informationen

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