RegexCompilationInfo.MatchTimeout Propriedade

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

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.

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.

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.

Aplica-se a

Confira também

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