RegexCompilationInfo.MatchTimeout Proprietà

  • Riferimento

Definizione

Spazio dei nomi:
System.Text.RegularExpressions
Assembly:
System.Text.RegularExpressions.dll
Assembly:
System.dll
Origine:
RegexCompilationInfo.cs
Origine:
RegexCompilationInfo.cs
Origine:
RegexCompilationInfo.cs

Ottiene o imposta l'intervallo di timeout predefinito dell'espressione regolare.

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à

TimeSpan

L'intervallo di tempo massimo predefinito che può trascorrere in un'operazione di corrispondenza dei modelli prima che RegexMatchTimeoutException venga generato 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 contenente 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 criterio di ricerca di espressioni regolari (\w)\1+ è definito nel modo illustrato nella tabella seguente.

Modello Descrizione
(\w) Trova la corrispondenza con qualsiasi carattere di parola e la assegna al primo gruppo di acquisizione.
\1+ Trova la corrispondenza con una o più occorrenze del valore del primo gruppo acquisito.

Nell'esempio seguente viene utilizzata l'espressione DuplicatedChars regolare per identificare i caratteri duplicati in una matrice di stringhe. Quando chiama il DuplicatedChars costruttore, imposta l'intervallo di timeout su 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 temporale successivo.

Importante

È consigliabile impostare sempre un valore di timeout predefinito per un'espressione regolare compilata. I consumer della libreria di espressioni regolari possono eseguire l'override di tale valore di timeout passando un TimeSpan valore che rappresenta il nuovo intervallo di timeout al costruttore di classe dell'espressione regolare compilata.

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

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 più complesse richiedono più tempo rispetto a quelle più brevi e più semplici.

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

Si applica a

Vedi anche