RegexCompilationInfo.MatchTimeout Proprietà

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

Valore della proprietà

Intervallo di tempo massimo predefinito che può trascorrere in un'operazione di corrispondenza dei criteri prima che venga generata un'eccezione RegexMatchTimeoutException o InfiniteMatchTimeout se i timeout sono disabilitati.

Esempio

Nell'esempio seguente viene definita una singola espressione regolare compilata denominata DuplicateChars che identifica due o più occorrenze dello stesso carattere in una stringa di input. L'espressione regolare compilata ha un timeout predefinito di 2 secondi. Quando si esegue l'esempio, viene creata una libreria di classi denominata RegexLib.dll che contiene l'espressione regolare compilata.

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

Il modello di espressione regolare (\w)\1+ è definito come mostrato nella tabella seguente.

Nell'esempio seguente viene utilizzata l'espressione DuplicatedChars regolare per identificare i caratteri duplicati in una matrice di stringhe. Quando chiama il DuplicatedChars costruttore, cambia l'intervallo di timeout a 5 secondi.

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

Commenti

La MatchTimeout proprietà definisce l'intervallo di timeout predefinito per l'espressione regolare compilata. Questo valore rappresenta la quantità approssimativa di tempo in cui un'espressione regolare compilata eseguirà una singola operazione di corrispondenza prima del timeout dell'operazione e il motore delle espressioni regolari genera un'eccezione RegexMatchTimeoutException durante il controllo di intervallo successivo.

È possibile assegnare un valore di timeout predefinito a un RegexCompilationInfo oggetto in uno dei modi seguenti:

• Chiamando il AppDomain.SetData metodo e fornendo la rappresentazione di stringa di un TimeSpan valore per la proprietà "REGEX_DEFAULT_MATCH_TIMEOUT".

• Chiamando il RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan) costruttore e fornendo un valore per il matchTimeout parametro .

• Impostando il valore di questa proprietà.

Per impostare un intervallo di timeout ragionevole, considerare i fattori seguenti:

• Lunghezza e complessità del criterio di espressione regolare. Le espressioni regolari più lunghe e complesse richiedono più tempo rispetto a quelle più brevi e più semplici.

• Carico previsto del computer. L'elaborazione richiede più tempo sui sistemi con un utilizzo elevato della CPU e della memoria.

Vedi anche

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