RegexMatchTimeoutException RegexMatchTimeoutException RegexMatchTimeoutException RegexMatchTimeoutException Class

Definição

A exceção que é gerada quando o tempo de execução de um método de correspondência de padrão de expressão regular excede o intervalo de tempo limite.The exception that is thrown when the execution time of a regular expression pattern-matching method exceeds its time-out interval.

public ref class RegexMatchTimeoutException : TimeoutException
[System.Serializable]
public class RegexMatchTimeoutException : TimeoutException
type RegexMatchTimeoutException = class
    inherit TimeoutException
    interface ISerializable
Public Class RegexMatchTimeoutException
Inherits TimeoutException
Herança
Atributos
Implementações

Exemplos

O exemplo a seguir ilustra duas abordagens possíveis para manipular RegexMatchTimeoutException a exceção.The following example illustrates two possible approaches to handling the RegexMatchTimeoutException exception. Uma constante cujo valor é dois segundos define o intervalo de tempo limite máximo.A constant whose value is two seconds defines the maximum time-out interval. Inicialmente Regex.IsMatch(String, String, RegexOptions, TimeSpan) , o método é chamado com um intervalo de tempo limite de um segundo.The Regex.IsMatch(String, String, RegexOptions, TimeSpan) method is initially called with a time-out interval of one second. Cada RegexMatchTimeoutException exceção faz com que o intervalo de tempo limite seja aumentado em um segundo e resulte em outra chamada Regex.IsMatch para o método se o intervalo de tempo limite atual for menor do que o intervalo de tempo limite máximo.Each RegexMatchTimeoutException exception causes the time-out interval to be increased by one second and results in another call to the Regex.IsMatch method if the current time-out interval is less than the maximum time-out interval. No entanto, se o intervalo de tempo limite atual exceder o intervalo máximo de tempo limite, o manipulador de exceção gravará informações no log de eventos e abandonará o processamento da expressão regular.However, if the current time-out interval exceeds the maximum time-out interval, the exception handler writes information to the event log and abandons the processing of the regular expression.

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;
using System.Text.RegularExpressions;
using System.Threading;

public class Example
{
   const int MaxTimeoutInSeconds = 2;
   
   public static void Main()
   {
      TimeSpan timeout = new TimeSpan(0, 0, 1);
      string input = "aaaaaaaaaaaaaaaaaaaaaa>";
      if (ValidateInput(input, timeout))
         // Perform some operation with valid input string.
         Console.WriteLine("'{0}' is a valid string.", input); 
   } 

   private static bool ValidateInput(string input, TimeSpan timeout)
   {
      string pattern = "(a+)+$";      
      try {
         return Regex.IsMatch(input, pattern, 
                              RegexOptions.IgnoreCase, timeout);
      }
      catch (RegexMatchTimeoutException e) {
         // Increase the timeout interval and retry.
         timeout = timeout.Add(new TimeSpan(0, 0, 1));
         Console.WriteLine("Changing the timeout interval to {0}", 
                           timeout); 
         if (timeout.TotalSeconds <= MaxTimeoutInSeconds) {
            // Pause for a short period.
            Thread.Sleep(250);
            return ValidateInput(input, timeout);
         }   
         else {
            Console.WriteLine("Timeout interval of {0} exceeded.", 
                              timeout);
            // Write to event log named RegexTimeouts
            try {
               if (! EventLog.SourceExists("RegexTimeouts"))
                  EventLog.CreateEventSource("RegexTimeouts", "RegexTimeouts");

               EventLog log = new EventLog("RegexTimeouts");
               log.Source = "RegexTimeouts";
               string msg = String.Format("Timeout after {0} matching '{1}' with '{2}.",
                                          e.MatchTimeout, e.Input, e.Pattern);
               log.WriteEntry(msg, EventLogEntryType.Error);
            }
            // Do nothing to handle the exceptions.
            catch (SecurityException) { }
            catch (InvalidOperationException) { }
            catch (Win32Exception) { }
            return false;
         }   
      }
   }
}
// The example writes to the event log and also displays the following output:
//       Changing the timeout interval to 00:00:02
//       Changing the timeout interval to 00:00:03
//       Timeout interval of 00:00:03 exceeded.
Imports System.ComponentModel
Imports System.Diagnostics
Imports System.Security
Imports System.Text.RegularExpressions
Imports System.Threading

Module Example
   Const MaxTimeoutInSeconds As Integer = 2
   
   Public Sub Main()
      Dim timeout As TimeSpan = New TimeSpan(0, 0, 1)
      
      Dim input As String = "aaaaaaaaaaaaaaaaaaaaaa>"
      If ValidateInput(input, timeout) Then
         ' Perform some operation with valid input string.
         Console.WriteLine("'{0}' is a valid string.", input) 
      End If
   End Sub 

   Private Function ValidateInput(input As String, 
                                  timeout As TimeSpan) As Boolean
      Dim pattern As String = "(a+)+$"      
      Try
         Return Regex.IsMatch(input, pattern, 
                              RegexOptions.IgnoreCase, timeout)
      Catch e As RegexMatchTimeoutException
         ' Increase the timeout interval and retry.
         timeout = timeout.Add(New TimeSpan(0, 0, 1))
         Console.WriteLine("Changing the timeout interval to {0}", 
                           timeout) 
         If timeout.TotalSeconds <= MaxTimeoutInSeconds Then
            ' Pause for a short interval.
            Thread.Sleep(250)
            Return ValidateInput(input, timeout)
         Else
            Console.WriteLine("Timeout interval of {0} exceeded.", 
                              timeout)
            ' Write to event log named RegexTimeouts
            Try
               If Not EventLog.SourceExists("RegexTimeouts") Then
                  EventLog.CreateEventSource("RegexTimeouts", "RegexTimeouts")
               End If   
               Dim log As New EventLog("RegexTimeouts")
               log.Source = "RegexTimeouts"
               Dim msg As String = String.Format("Timeout after {0} matching '{1}' with '{2}.",
                                                 e.MatchTimeout, e.Input, e.Pattern)
               log.WriteEntry(msg, EventLogEntryType.Error)
            ' Do nothing to handle the exceptions.
            Catch ex As SecurityException

            Catch ex As InvalidOperationException

            Catch ex As Win32Exception

            End Try   
            Return False
         End If   
      End Try
   End Function
End Module
' The example writes to the event log and also displays the following output:
'       Changing the timeout interval to 00:00:02
'       Changing the timeout interval to 00:00:03
'       Timeout interval of 00:00:03 exceeded.

Comentários

A presença de uma RegexMatchTimeoutException exceção geralmente indica uma das seguintes condições:The presence of a RegexMatchTimeoutException exception generally indicates one of the following conditions:

  • O mecanismo de expressão regular está inacompanhado em excesso, pois tenta corresponder o texto de entrada ao padrão de expressão regular.The regular expression engine is backtracking excessively as it attempts to match the input text to the regular expression pattern.

  • O intervalo de tempo limite foi definido com um valor muito baixo, principalmente devido à alta carga da máquina.The time-out interval has been set too low, especially given high machine load.

A maneira como um manipulador de exceção trata uma exceção depende da causa da exceção:The way in which an exception handler handles an exception depends on the cause of the exception:

  • Se o tempo limite resultar de backtracking excessivo, o manipulador de exceção deverá abandonar a tentativa de corresponder à entrada e informar ao usuário que um tempo limite ocorreu no método de correspondência de padrão de expressão regular.If the time-out results from excessive backtracking, your exception handler should abandon the attempt to match the input and inform the user that a time-out has occurred in the regular expression pattern-matching method. Se possível, informações sobre o padrão de expressão regular, que está disponível na Pattern Propriedade, e a entrada que causou o retrocesso excessivo, que está disponível Input na propriedade, devem ser registradas para que o problema possa ser investigado e o padrão de expressão regular modificado.If possible, information about the regular expression pattern, which is available from the Pattern property, and the input that caused excessive backtracking, which is available from the Input property, should be logged so that the issue can be investigated and the regular expression pattern modified. Os tempos limite devido à inmonitoração excessiva são sempre reproduzíveis.Time-outs due to excessive backtracking are always reproducible.

  • Se o tempo limite resulta da definição do limite de tempo limite muito baixo, você pode aumentar o intervalo de tempo limite e tentar novamente a operação correspondente.If the time-out results from setting the time-out threshold too low, you can increase the time-out interval and retry the matching operation. O intervalo de tempo limite atual está disponível na MatchTimeout propriedade.The current time-out interval is available from the MatchTimeout property. Quando uma RegexMatchTimeoutException exceção é lançada, o mecanismo de expressão regular mantém seu estado para que as invocações futuras retornem o mesmo resultado, como se a exceção não tivesse ocorrido.When a RegexMatchTimeoutException exception is thrown, the regular expression engine maintains its state so that any future invocations return the same result, as if the exception did not occur. O padrão recomendado é aguardar um intervalo de tempo aleatório curto depois que a exceção é lançada antes de chamar o método correspondente novamente.The recommended pattern is to wait for a brief, random time interval after the exception is thrown before calling the matching method again. Isso pode ser repetido várias vezes.This can be repeated several times. No entanto, o número de repetições deve ser pequeno no caso de o tempo limite ser causado por um retrocesso excessivo.However, the number of repetitions should be small in case the time-out is caused by excessive backtracking.

O exemplo na próxima seção ilustra as duas técnicas para lidar com RegexMatchTimeoutExceptionum.The example in the next section illustrates both techniques for handling a RegexMatchTimeoutException.

Construtores

RegexMatchTimeoutException() RegexMatchTimeoutException() RegexMatchTimeoutException() RegexMatchTimeoutException()

Inicializa uma nova instância da classe RegexMatchTimeoutException com uma mensagem fornecida pelo sistema.Initializes a new instance of the RegexMatchTimeoutException class with a system-supplied message.

RegexMatchTimeoutException(SerializationInfo, StreamingContext) RegexMatchTimeoutException(SerializationInfo, StreamingContext) RegexMatchTimeoutException(SerializationInfo, StreamingContext) RegexMatchTimeoutException(SerializationInfo, StreamingContext)

Inicializa uma nova instância da classe RegexMatchTimeoutException com dados serializados.Initializes a new instance of the RegexMatchTimeoutException class with serialized data.

RegexMatchTimeoutException(String) RegexMatchTimeoutException(String) RegexMatchTimeoutException(String) RegexMatchTimeoutException(String)

Inicializa uma nova instância da classe RegexMatchTimeoutException com a cadeia de caracteres de mensagem especificada.Initializes a new instance of the RegexMatchTimeoutException class with the specified message string.

RegexMatchTimeoutException(String, Exception) RegexMatchTimeoutException(String, Exception) RegexMatchTimeoutException(String, Exception) RegexMatchTimeoutException(String, Exception)

Inicializa uma nova instância da classe RegexMatchTimeoutException com uma mensagem de erro especificada e uma referência à exceção interna que é a causa da exceção.Initializes a new instance of the RegexMatchTimeoutException class with a specified error message and a reference to the inner exception that is the cause of this exception.

RegexMatchTimeoutException(String, String, TimeSpan) RegexMatchTimeoutException(String, String, TimeSpan) RegexMatchTimeoutException(String, String, TimeSpan) RegexMatchTimeoutException(String, String, TimeSpan)

Inicializa uma nova instância da classe RegexMatchTimeoutException com informações sobre o padrão de expressão regular, o texto de entrada e o intervalo de tempo limite.Initializes a new instance of the RegexMatchTimeoutException class with information about the regular expression pattern, the input text, and the time-out interval.

Propriedades

Data Data Data Data

Obtém uma coleção de pares de chave/valor que fornecem informações adicionais definidas pelo usuário sobre a exceção.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Obtém ou define um link para o arquivo de ajuda associado a essa exceção.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Obtém ou define HRESULT, um valor numérico codificado que é atribuído a uma exceção específica.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Obtém a instância Exception que causou a exceção atual.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Input Input Input Input

Obtém o texto de entrada que o mecanismo de expressão regular estava processando quando o tempo limite ocorreu.Gets the input text that the regular expression engine was processing when the time-out occurred.

MatchTimeout MatchTimeout MatchTimeout MatchTimeout

Obtém o intervalo de tempo limite para uma correspondência de expressão regular.Gets the time-out interval for a regular expression match.

Message Message Message Message

Obtém uma mensagem que descreve a exceção atual.Gets a message that describes the current exception.

(Inherited from Exception)
Pattern Pattern Pattern Pattern

Obtém o padrão de expressão regular que era usado na operação de correspondência quando o tempo limite ocorreu.Gets the regular expression pattern that was used in the matching operation when the time-out occurred.

Source Source Source Source

Obtém ou define o nome do aplicativo ou objeto que causa o erro.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Obtém uma representação de cadeia de caracteres de quadros imediatos na pilha de chamadas.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Obtém o método que gerou a exceção atual.Gets the method that throws the current exception.

(Inherited from Exception)

Implantações explícitas de interface

ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Popula um objeto SerializationInfo com os dados necessários para serializar um objeto RegexMatchTimeoutException.Populates a SerializationInfo object with the data needed to serialize a RegexMatchTimeoutException object.

Métodos

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetBaseException() GetBaseException() GetBaseException() GetBaseException()

Quando substituído em uma classe derivada, retorna a Exception que é a causa raiz de uma ou mais exceções subsequentes.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Inherited from Exception)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

Quando substituído em uma classe derivada, define o SerializationInfo com informações sobre a exceção.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Inherited from Exception)
GetType() GetType() GetType() GetType()

Obtém o tipo de tempo de execução da instância atual.Gets the runtime type of the current instance.

(Inherited from Exception)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Cria e retorna uma representação de cadeia de caracteres da exceção atual.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Eventos

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

Ocorre quando uma exceção é serializada para criar um objeto de estado de exceção que contém dados serializados sobre a exceção.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

Aplica-se a

Veja também