RegexCompilationInfo.MatchTimeout Proprietà

Definizione

Ottiene o imposta l'intervallo di timeout predefinito dell'espressione regolare.Gets or sets the regular expression's default time-out interval.

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.The default maximum time interval that can elapse in a pattern-matching operation before a RegexMatchTimeoutException is thrown, or InfiniteMatchTimeout if time-outs are disabled.

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.The following example defines a single compiled regular expression named DuplicateChars that identifies two or more occurrences of the same character in an input string. Il timeout predefinito dell'espressione regolare compilata è di 2 secondi.The compiled regular expression has a default time-out of 2 seconds. Quando si esegue l'esempio, viene creata una libreria di classi denominata RegexLib.dll che contiene l'espressione regolare compilata.When you execute the example, it creates a class library named RegexLib.dll that contains the compiled regular expression.

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.The regular expression pattern (\w)\1+ is defined as shown in the following table.

ModelloPattern DescrizioneDescription
(\w) Trova la corrispondenza di qualsiasi carattere alfanumerico e la assegna al primo gruppo di acquisizione.Match any word character and assign it to the first capturing group.
\1+ Corrisponde a una o più occorrenze del valore del primo gruppo acquisito.Match one or more occurrences of the value of the first captured group.

Nell'esempio seguente viene usata l' DuplicatedChars espressione regolare per identificare i caratteri duplicati in una matrice di stringhe.The following example uses the DuplicatedChars regular expression to identify duplicate characters in a string array. Quando chiama il DuplicatedChars costruttore, l'intervallo di timeout viene modificato in 5 secondi.When it calls the DuplicatedChars constructor, it changes the time-out interval to .5 seconds.

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.The MatchTimeout property defines the default time-out interval for the compiled regular expression. Questo valore rappresenta l'intervallo di tempo approssimativo durante il quale un'espressione regolare compilata esegue una singola operazione di corrispondenza prima del timeout dell'operazione e il motore delle espressioni regolari genera un' RegexMatchTimeoutException eccezione durante il controllo di intervallo successivo.This value represents the approximate amount of time that a compiled regular expression will execute a single matching operation before the operation times out and the regular expression engine throws a RegexMatchTimeoutException exception during its next timing check.

Importante

È consigliabile impostare sempre un valore di timeout predefinito per un'espressione regolare compilata.We recommend that you always set a default time-out value for a compiled regular expression. I consumer della libreria di espressioni regolari possono eseguire l'override del valore di timeout passando un TimeSpan valore che rappresenta il nuovo intervallo di timeout al costruttore della classe dell'espressione regolare compilata.Consumers of your regular expression library can override that time-out value by passing a TimeSpan value that represents the new time-out interval to the compiled regular expression's class constructor.

È possibile assegnare un valore di timeout predefinito a un RegexCompilationInfo oggetto in uno dei modi seguenti:You can assign a default time-out value to a RegexCompilationInfo object in any of the following ways:

Per impostare un intervallo di timeout ragionevole, considerare i fattori seguenti:To set a reasonable time-out interval, consider the following factors:

  • La lunghezza e la complessità del criterio di espressione regolare.The length and complexity of the regular expression pattern. Le espressioni regolari più lunghe e complesse richiedono più tempo rispetto a quelle più semplici e più brevi.Longer and more complex regular expressions require more time than shorter and simpler ones.

  • Il carico del computer previsto.The expected machine load. L'elaborazione impiega più tempo nei sistemi con utilizzo elevato della CPU e della memoria.Processing takes more time on systems with high CPU and memory utilization.

Si applica a

Vedi anche