RegexCompilationInfo.MatchTimeout Propriedade

Definição

Namespace:

System.Text.RegularExpressions

Assembly:

System.Text.RegularExpressions.dll

Origem:

RegexCompilationInfo.cs

Obtém ou define o intervalo de tempo limite padrão da expressão regular.

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

Valor da propriedade

TimeSpan

O intervalo de tempo máximo padrão que pode decorrer em uma operação de correspondência de padrões antes de um RegexMatchTimeoutException ser lançado ou InfiniteMatchTimeout se os tempos limite estiverem desabilitados.

Exemplos

O exemplo a seguir define uma única expressão regular compilada chamada DuplicateChars que identifica duas ou mais ocorrências do mesmo caractere em uma cadeia de caracteres de entrada. A expressão regular compilada tem um tempo limite padrão de 2 segundos. Quando você executa o exemplo, ele cria uma biblioteca de classes chamada RegexLib.dll que contém a expressão regular compilada.

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

O padrão de expressão regular (\w)\1+ é definido conforme mostrado na tabela a seguir.

Padrão	Descrição
(\w)	Corresponder a qualquer caractere de palavra e atribuí-lo ao primeiro grupo de captura.
\1+	Corresponde a uma ou mais ocorrências do valor do primeiro grupo capturado.

O exemplo a seguir usa a DuplicatedChars expressão regular para identificar caracteres duplicados em uma matriz de cadeia de caracteres. Quando ele chama o DuplicatedChars construtor, ele altera o intervalo de tempo limite para 0,5 segundos.

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

Comentários

A MatchTimeout propriedade define o intervalo de tempo limite padrão para a expressão regular compilada. Esse valor representa a quantidade aproximada de tempo que uma expressão regular compilada executará uma única operação de correspondência antes que a operação atinja o tempo limite e o mecanismo de expressão regular gere uma RegexMatchTimeoutException exceção durante o próximo intervalo marcar.

Importante

Recomendamos que você sempre defina um valor de tempo limite padrão para uma expressão regular compilada. Os consumidores da biblioteca de expressões regulares podem substituir esse valor de tempo limite passando um TimeSpan valor que representa o novo intervalo de tempo limite para o construtor de classe da expressão regular compilada.

Você pode atribuir um valor de tempo limite padrão a um objeto de qualquer uma RegexCompilationInfo das seguintes maneiras:

• Chamando o AppDomain.SetData método e fornecendo a representação de cadeia de caracteres de um TimeSpan valor para a propriedade "REGEX_DEFAULT_MATCH_TIMEOUT".

• Chamando o RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan) construtor e fornecendo um valor para o matchTimeout parâmetro .

• Definindo o valor dessa propriedade.

Para definir um intervalo de tempo limite razoável, considere os seguintes fatores:

• O comprimento e a complexidade do padrão de expressão regular. Expressões regulares mais longas e complexas exigem mais tempo do que as mais curtas e simples.

• A carga esperada do computador. O processamento leva mais tempo em sistemas com alta utilização de CPU e memória.

Confira também

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