RegexMatchTimeoutException Classe

Définition

Exception levée quand la durée d'exécution impartie pour une méthode de correspondance d'expression régulière est dépassée.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
Héritage
RegexMatchTimeoutException
Attributs
Implémente

Exemples

L’exemple suivant illustre deux approches possibles pour gérer l’exception RegexMatchTimeoutException.The following example illustrates two possible approaches to handling the RegexMatchTimeoutException exception. Une constante dont la valeur est deux secondes définit l’intervalle de délai d’attente maximal.A constant whose value is two seconds defines the maximum time-out interval. La méthode Regex.IsMatch(String, String, RegexOptions, TimeSpan) est initialement appelée avec un intervalle de délai d’attente d’une seconde.The Regex.IsMatch(String, String, RegexOptions, TimeSpan) method is initially called with a time-out interval of one second. Chaque RegexMatchTimeoutException exception provoque l’augmentation de l’intervalle de délai d’attente d’une seconde et entraîne un autre appel à la méthode Regex.IsMatch si l’intervalle de délai d’attente actuel est inférieur à l’intervalle de délai d’attente maximal.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. Toutefois, si l’intervalle de délai d’attente actuel dépasse l’intervalle de délai d’attente maximal, le gestionnaire d’exceptions écrit des informations dans le journal des événements et abandonne le traitement de l’expression régulière.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.

Remarques

La présence d’une exception de RegexMatchTimeoutException indique généralement l’une des conditions suivantes :The presence of a RegexMatchTimeoutException exception generally indicates one of the following conditions:

  • Le moteur d’expression régulière effectue une rétroaction excessive, car il tente de faire correspondre le texte d’entrée au modèle d’expression régulière.The regular expression engine is backtracking excessively as it attempts to match the input text to the regular expression pattern.

  • L’intervalle de délai d’attente a été défini sur une valeur trop faible, particulièrement en raison d’une charge élevée de l’ordinateur.The time-out interval has been set too low, especially given high machine load.

La façon dont un gestionnaire d’exceptions gère une exception dépend de la cause de l’exception :The way in which an exception handler handles an exception depends on the cause of the exception:

  • Si le délai d’attente résulte d’une rétroaction excessive, votre gestionnaire d’exceptions doit abandonner la tentative de mise en correspondance de l’entrée et informer l’utilisateur qu’un délai d’attente a été dépassé dans la méthode de mise en correspondance de modèle d’expression régulière.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. Si possible, des informations sur le modèle d’expression régulière, qui sont disponibles à partir de la propriété Pattern, et l’entrée qui a provoqué une rétroaction excessive, qui est disponible à partir de la propriété Input, doivent être journalisées afin que le problème puisse être étudié et que le modèle d’expression régulière soit modifié.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. Les délais d’attente dus à une rétroaction excessive sont toujours reproductibles.Time-outs due to excessive backtracking are always reproducible.

  • Si le délai d’expiration résultant de la définition du seuil de délai d’attente est trop faible, vous pouvez augmenter l’intervalle de délai d’attente et réessayer l’opération de correspondance.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. L’intervalle de délai d’attente actuel est disponible à partir de la propriété MatchTimeout.The current time-out interval is available from the MatchTimeout property. Quand une exception RegexMatchTimeoutException est levée, le moteur d’expression régulière conserve son état afin que tous les appels futurs retournent le même résultat, comme si l’exception ne s’était pas produite.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. Le modèle recommandé consiste à attendre un bref intervalle de temps aléatoire après la levée de l’exception avant d’appeler à nouveau la méthode correspondante.The recommended pattern is to wait for a brief, random time interval after the exception is thrown before calling the matching method again. Cela peut être répété plusieurs fois.This can be repeated several times. Toutefois, le nombre de répétitions doit être faible si le délai d’expiration est dû à une rétroaction excessive.However, the number of repetitions should be small in case the time-out is caused by excessive backtracking.

L’exemple de la section suivante illustre les deux techniques de gestion d’un RegexMatchTimeoutException.The example in the next section illustrates both techniques for handling a RegexMatchTimeoutException.

Constructeurs

RegexMatchTimeoutException()

Initialise une nouvelle instance de la classe RegexMatchTimeoutException avec un message fourni par le système.Initializes a new instance of the RegexMatchTimeoutException class with a system-supplied message.

RegexMatchTimeoutException(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe RegexMatchTimeoutException avec les données sérialisées.Initializes a new instance of the RegexMatchTimeoutException class with serialized data.

RegexMatchTimeoutException(String)

Initialise une nouvelle instance de la classe RegexMatchTimeoutException avec la chaîne de message spécifiée.Initializes a new instance of the RegexMatchTimeoutException class with the specified message string.

RegexMatchTimeoutException(String, Exception)

Initialise une nouvelle instance de la classe RegexMatchTimeoutException avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception.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)

Initialise une nouvelle instance de la classe RegexMatchTimeoutException avec les informations sur le modèle d'expression régulière, le texte d'entrée et l'intervalle de délai d'attente.Initializes a new instance of the RegexMatchTimeoutException class with information about the regular expression pattern, the input text, and the time-out interval.

Propriétés

Data

Obtient une collection de paires clé/valeur qui fournissent des informations supplémentaires définies par l’utilisateur sur l’exception.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Hérité de Exception)
HelpLink

Obtient ou définit un lien vers le fichier d'aide associé à cette exception.Gets or sets a link to the help file associated with this exception.

(Hérité de Exception)
HResult

Obtient ou définit HRESULT, valeur numérique codée qui est assignée à une exception spécifique.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Hérité de Exception)
InnerException

Obtient l'instance Exception qui a provoqué l'exception actuelle.Gets the Exception instance that caused the current exception.

(Hérité de Exception)
Input

Obtient le texte d'entrée que le moteur des expressions régulières traitait lorsque le délai d'attente a expiré.Gets the input text that the regular expression engine was processing when the time-out occurred.

MatchTimeout

Obtient l'intervalle de délai d'attente pour une correspondance d'expression régulière.Gets the time-out interval for a regular expression match.

Message

Obtient un message qui décrit l'exception actuelle.Gets a message that describes the current exception.

(Hérité de Exception)
Pattern

Obtient le modèle d'expression régulière utilisé dans l'opération correspondante lorsque le délai d'attente a expiré.Gets the regular expression pattern that was used in the matching operation when the time-out occurred.

Source

Obtient ou définit le nom de l'application ou de l'objet qui est à l'origine de l'erreur.Gets or sets the name of the application or the object that causes the error.

(Hérité de Exception)
StackTrace

Obtient une représentation sous forme de chaîne des frames immédiats sur la pile des appels.Gets a string representation of the immediate frames on the call stack.

(Hérité de Exception)
TargetSite

Obtient la méthode qui lève l'exception actuelle.Gets the method that throws the current exception.

(Hérité de Exception)

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetBaseException()

En cas de substitution dans une classe dérivée, retourne la Exception qui est à l'origine d'une ou de plusieurs exceptions ultérieures.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Hérité de Exception)
GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)

En cas de substitution dans une classe dérivée, définit SerializationInfo avec des informations sur l'exception.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Hérité de Exception)
GetType()

Obtient le type au moment de l'exécution de l'instance actuelle.Gets the runtime type of the current instance.

(Hérité de Exception)
MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Crée et retourne une chaîne représentant l'exception actuelle.Creates and returns a string representation of the current exception.

(Hérité de Exception)

Événements

SerializeObjectState

Se produit quand une exception est sérialisée pour créer un objet d'état d'exception qui contient des données sérialisées concernant l'exception.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Hérité de Exception)

Implémentations d’interfaces explicites

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Renseigne un objet SerializationInfo avec les données nécessaires pour sérialiser un objet RegexMatchTimeoutException.Populates a SerializationInfo object with the data needed to serialize a RegexMatchTimeoutException object.

S’applique à

Voir aussi