RegexMatchTimeoutException Classe

Referência

Definição

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

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.

public ref class RegexMatchTimeoutException : TimeoutException

public class RegexMatchTimeoutException : TimeoutException

[System.Serializable]
public class RegexMatchTimeoutException : TimeoutException

type RegexMatchTimeoutException = class
    inherit TimeoutException

type RegexMatchTimeoutException = class
    inherit TimeoutException
    interface ISerializable

[<System.Serializable>]
type RegexMatchTimeoutException = class
    inherit TimeoutException
    interface ISerializable

Public Class RegexMatchTimeoutException
Inherits TimeoutException

Herança: Object

Exception

TimeoutException
RegexMatchTimeoutException

Herança: Object

Exception

SystemException

TimeoutException
RegexMatchTimeoutException

Atributos: SerializableAttribute

Implementações: ISerializable

Exemplos

O exemplo a seguir ilustra duas abordagens possíveis para lidar com a RegexMatchTimeoutException exceção. Uma constante cujo valor é de dois segundos define o intervalo máximo de tempo limite. O Regex.IsMatch(String, String, RegexOptions, TimeSpan) método é inicialmente chamado com um intervalo de tempo limite de um segundo. Cada RegexMatchTimeoutException exceção faz com que o intervalo de tempo limite seja aumentado em um segundo e resulte em outra chamada para o Regex.IsMatch método se o intervalo de tempo limite atual for menor que o intervalo máximo de tempo limite. 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.

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:

O mecanismo de expressão regular está retrocedendo excessivamente enquanto tenta corresponder o texto de entrada ao padrão de expressão regular.
O intervalo de tempo limite foi definido muito baixo, especialmente considerando a alta carga do computador.

A maneira como um manipulador de exceção lida com uma exceção depende da causa da exceção:

Se o tempo limite resultar de retrocesso excessivo, seu manipulador de exceção deverá abandonar a tentativa de corresponder à entrada e informar ao usuário que ocorreu um tempo limite no método de correspondência de padrões de expressão regular. Se possível, as informações sobre o padrão de expressão regular, que está disponível na Pattern propriedade e a entrada que causou retrocesso excessivo, que está disponível na Input propriedade, devem ser registradas para que o problema possa ser investigado e o padrão de expressão regular modificado. Os tempos limite devido ao retrocesso excessivo são sempre reproduzidos.
Se o tempo limite resultar na configuração do limite de tempo limite muito baixo, você poderá aumentar o intervalo de tempo limite e repetir a operação de correspondência. O intervalo de tempo limite atual está disponível na MatchTimeout propriedade. Quando uma RegexMatchTimeoutException exceção é lançada, o mecanismo de expressão regular mantém seu estado para que quaisquer invocações futuras retornem o mesmo resultado, como se a exceção não tivesse ocorrido. O padrão recomendado é aguardar um breve intervalo de tempo aleatório após a exceção ser lançada antes de chamar o método correspondente novamente. Isso pode ser repetido várias vezes. No entanto, o número de repetições deve ser pequeno caso o tempo limite seja causado pelo retrocesso excessivo.

O exemplo na próxima seção ilustra ambas as técnicas para lidar com um RegexMatchTimeoutException.

Construtores

RegexMatchTimeoutException()	Inicializa uma nova instância da classe RegexMatchTimeoutException com uma mensagem fornecida pelo sistema.
RegexMatchTimeoutException(SerializationInfo, StreamingContext)	Inicializa uma nova instância da classe RegexMatchTimeoutException com dados serializados.
RegexMatchTimeoutException(String)	Inicializa uma nova instância da classe RegexMatchTimeoutException com a cadeia de caracteres de mensagem especificada.
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.
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.

Propriedades

Data	Obtém uma coleção de pares de chave/valor que fornecem informações definidas pelo usuário adicionais sobre a exceção. (Herdado de Exception)
HelpLink	Obtém ou define um link para o arquivo de ajuda associado a essa exceção. (Herdado de Exception)
HResult	Obtém ou define HRESULT, um valor numérico codificado que é atribuído a uma exceção específica. (Herdado de Exception)
InnerException	Obtém a instância Exception que causou a exceção atual. (Herdado de Exception)
Input	Obtém o texto de entrada que o mecanismo de expressão regular estava processando quando o tempo limite ocorreu.
MatchTimeout	Obtém o intervalo de tempo limite para uma correspondência de expressão regular.
Message	Obtém uma mensagem que descreve a exceção atual. (Herdado de Exception)
Pattern	Obtém o padrão de expressão regular que era usado na operação de correspondência quando o tempo limite ocorreu.
Source	Obtém ou define o nome do aplicativo ou objeto que causa o erro. (Herdado de Exception)
StackTrace	Obtém uma representação de cadeia de caracteres de quadros imediatos na pilha de chamadas. (Herdado de Exception)
TargetSite	Obtém o método que gerou a exceção atual. (Herdado de Exception)

Métodos

Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetBaseException()	Quando substituído em uma classe derivada, retorna a Exception que é a causa raiz de uma ou mais exceções subsequentes. (Herdado de Exception)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetObjectData(SerializationInfo, StreamingContext)	Quando substituído em uma classe derivada, define o SerializationInfo com informações sobre a exceção. (Herdado de Exception)
GetType()	Obtém o tipo de runtime da instância atual. (Herdado de Exception)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
ToString()	Cria e retorna uma representação de cadeia de caracteres da exceção atual. (Herdado de Exception)

Eventos

SerializeObjectState

Obsoleto.

Ocorre quando uma exceção é serializada para criar um objeto de estado de exceção que contém dados serializados sobre a exceção.

(Herdado de Exception)

Implantações explícitas de interface

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Popula um objeto SerializationInfo com os dados necessários para serializar um objeto RegexMatchTimeoutException.

Aplica-se a