RegexMatchTimeoutException Classe

Définition

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

Propriétés

Méthodes

Événements

Implémentations d’interfaces explicites

S’applique à

Voir aussi

• Rétroaction dans les expressions régulières
• Bonnes pratiques pour les expressions régulières dans .NET