RegexMatchTimeoutException Classe

Référence

Définition

Espace de noms:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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.

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

Héritage: Object

Exception

TimeoutException
RegexMatchTimeoutException

Héritage: Object

Exception

SystemException

TimeoutException
RegexMatchTimeoutException

Attributs: SerializableAttribute

Implémente: ISerializable

Exemples

L’exemple suivant illustre deux approches possibles pour gérer l’exception RegexMatchTimeoutException . Une constante dont la valeur est de deux secondes définit l’intervalle maximal de délai d’attente. La Regex.IsMatch(String, String, RegexOptions, TimeSpan) méthode est initialement appelée avec un intervalle de délai d’attente d’une seconde. Chaque RegexMatchTimeoutException exception entraîne l’augmentation de l’intervalle de délai d’attente d’une seconde et entraîne un autre appel à la Regex.IsMatch méthode si l’intervalle de délai d’attente actuel est inférieur à l’intervalle maximal de délai d’attente. Toutefois, si l’intervalle de délai d’attente actuel dépasse l’intervalle maximal de délai d’attente, le gestionnaire d’exceptions écrit les informations dans le journal des événements et abandonne le traitement de l’expression régulière.

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 RegexMatchTimeoutException exception indique généralement l’une des conditions suivantes :

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.
L’intervalle de délai d’attente a été défini trop bas, en particulier en raison d’une charge de machine élevée.

La façon dont un gestionnaire d’exceptions gère une exception dépend de la cause de l’exception :

Si le délai d’attente résulte d’une rétroaction excessive, votre gestionnaire d’exceptions doit abandonner la tentative de correspondance avec l’entrée et informer l’utilisateur qu’un délai d’attente s’est produit dans la méthode de correspondance de modèle d’expression régulière. Si possible, les informations sur le modèle d’expression régulière, qui est disponible à partir de la Pattern propriété , et l’entrée qui a provoqué une rétroaction excessive, qui est disponible à partir de la Input propriété , doivent être consignées afin que le problème puisse être examiné et le modèle d’expression régulière modifié. Les délais d’attente dus à une rétroaction excessive sont toujours reproductibles.
Si le délai d’attente résulte de la définition du seuil de délai d’attente trop bas, vous pouvez augmenter l’intervalle de délai d’attente et réessayer l’opération de correspondance. L’intervalle de délai d’attente actuel est disponible à partir de la MatchTimeout propriété . Lorsqu’une RegexMatchTimeoutException exception 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. Le modèle recommandé est d’attendre un bref intervalle de temps aléatoire après la levée de l’exception avant d’appeler à nouveau la méthode correspondante. Cette opération peut être répétée plusieurs fois. Toutefois, le nombre de répétitions doit être faible si le délai d’attente est dû à une rétroaction excessive.

L’exemple de la section suivante illustre les deux techniques de gestion d’un RegexMatchTimeoutException.

Constructeurs

RegexMatchTimeoutException()	Initialise une nouvelle instance de la classe RegexMatchTimeoutException avec un message système.
RegexMatchTimeoutException(SerializationInfo, StreamingContext)	Initialise une nouvelle instance de la classe RegexMatchTimeoutException avec des données sérialisées.
RegexMatchTimeoutException(String)	Initialise une nouvelle instance de la classe RegexMatchTimeoutException avec la chaîne de message spécifiée.
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.
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.

Propriétés

Data	Obtient une collection de paires clé/valeur qui fournissent des informations définies par l'utilisateur supplémentaires sur l'exception. (Hérité de Exception)
HelpLink	Obtient ou définit un lien vers le fichier d'aide associé à cette exception. (Hérité de Exception)
HResult	Obtient ou définit HRESULT, valeur numérique codée qui est assignée à une exception spécifique. (Hérité de Exception)
InnerException	Obtient l'instance Exception qui a provoqué l'exception actuelle. (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é.
MatchTimeout	Obtient l'intervalle de délai d'attente pour une correspondance d'expression régulière.
Message	Obtient un message qui décrit l'exception active. (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é.
Source	Obtient ou définit le nom de l'application ou de l'objet qui est à l'origine de l'erreur. (Hérité de Exception)
StackTrace	Obtient une représentation sous forme de chaîne des frames immédiats sur la pile des appels. (Hérité de Exception)
TargetSite	Obtient la méthode qui lève l'exception actuelle. (Hérité de Exception)

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (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. (Hérité de Exception)
GetHashCode()	Fait office de fonction de hachage par défaut. (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. (Hérité de Exception)
GetType()	Obtient le type au moment de l'exécution de l'instance actuelle. (Hérité de Exception)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Crée et retourne une chaîne représentant l'exception actuelle. (Hérité de Exception)

Événements

SerializeObjectState

Obsolète.

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.

(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.

S’applique à