RegexMatchTimeoutException Klas

Definitie

public ref class RegexMatchTimeoutException : TimeoutException

public class RegexMatchTimeoutException : TimeoutException

[System.Serializable]
public class RegexMatchTimeoutException : TimeoutException

type RegexMatchTimeoutException = class
    inherit TimeoutException

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

type RegexMatchTimeoutException = class
    inherit TimeoutException
    interface ISerializable

Public Class RegexMatchTimeoutException
Inherits TimeoutException

Overname

Object

Exception

TimeoutException

RegexMatchTimeoutException

Overname

Object

Exception

SystemException

TimeoutException

RegexMatchTimeoutException

Kenmerken

SerializableAttribute

Implementeringen

ISerializable

Voorbeelden

In het volgende voorbeeld ziet u twee mogelijke benaderingen voor het afhandelen van de RegexMatchTimeoutException uitzondering. Een constante waarvan de waarde twee seconden is, definieert het maximale time-outinterval. De Regex.IsMatch(String, String, RegexOptions, TimeSpan) methode wordt in eerste instantie aangeroepen met een time-outinterval van één seconde. Elke RegexMatchTimeoutException uitzondering zorgt ervoor dat het time-outinterval met één seconde wordt verhoogd en resulteert in een andere aanroep van de Regex.IsMatch methode als het huidige time-outinterval kleiner is dan het maximale time-outinterval. Als het huidige time-outinterval echter het maximale time-outinterval overschrijdt, schrijft de uitzonderingshandler informatie naar het gebeurtenislogboek en wordt de verwerking van de reguliere expressie afgelaten.

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.

Opmerkingen

De aanwezigheid van een RegexMatchTimeoutException uitzondering geeft over het algemeen een van de volgende voorwaarden aan:

• De engine voor reguliere expressies loopt te veel terug naarmate de invoertekst wordt vergeleken met het reguliere expressiepatroon.

• Het time-outinterval is te laag ingesteld, met name gezien de hoge belasting van de machine.

De manier waarop een uitzonderingshandler een uitzondering afhandelt, is afhankelijk van de oorzaak van de uitzondering:

• Als de time-out het gevolg is van overmatige backtracking, moet de uitzonderingshandler de poging om de invoer te vinden afbreken en de gebruiker ervan op de hoogte stellen dat er een time-out is opgetreden in de reguliere methode voor patroonvergelijking van expressies. Indien mogelijk, moet informatie over het reguliere expressiepatroon, dat beschikbaar is via de Pattern eigenschap, en de invoer die overmatige backtracking heeft veroorzaakt, die beschikbaar is vanuit de Input eigenschap, worden geregistreerd, zodat het probleem kan worden onderzocht en het reguliere expressiepatroon kan worden gewijzigd. Time-outs vanwege overmatige backtracking zijn altijd reproduceerbaar.

• Als de time-outresultaten van het instellen van de time-outdrempel te laag zijn, kunt u het time-outinterval verhogen en de overeenkomende bewerking opnieuw uitvoeren. Het huidige time-outinterval is beschikbaar vanuit de MatchTimeout eigenschap. Wanneer er een RegexMatchTimeoutException uitzondering wordt gegenereerd, behoudt de engine voor reguliere expressies de status zodat toekomstige aanroepen hetzelfde resultaat retourneren, alsof de uitzondering niet is opgetreden. Het aanbevolen patroon is om te wachten op een kort, willekeurig tijdsinterval nadat de uitzondering is gegenereerd voordat de overeenkomende methode opnieuw wordt aangeroepen. Dit kan meerdere keren worden herhaald. Het aantal herhalingen moet echter klein zijn voor het geval de time-out wordt veroorzaakt door overmatige backtracking.

Het voorbeeld in de volgende sectie illustreert beide technieken voor het verwerken van een RegexMatchTimeoutException.

Zie ook

• Backtracking in reguliere expressies
• Best-procedures voor reguliere expressies in .NET