RegexMatchTimeoutException Classe

Riferimento

Definizione

Spazio dei nomi:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Eccezione generata quando il tempo di esecuzione di un metodo dei criteri di ricerca di espressioni regolari supera l'intervallo di timeout.

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

Ereditarietà: Object

Exception

TimeoutException
RegexMatchTimeoutException

Ereditarietà: Object

Exception

SystemException

TimeoutException
RegexMatchTimeoutException

Attributi: SerializableAttribute

Implementazioni: ISerializable

Esempio

Nell'esempio seguente vengono illustrati due possibili approcci per gestire l'eccezione RegexMatchTimeoutException . Costante il cui valore è di due secondi definisce l'intervallo massimo di timeout. Il Regex.IsMatch(String, String, RegexOptions, TimeSpan) metodo viene inizialmente chiamato con un intervallo di timeout di un secondo. Ogni RegexMatchTimeoutException eccezione causa l'aumento dell'intervallo di timeout di un secondo e genera un'altra chiamata al Regex.IsMatch metodo se l'intervallo di timeout corrente è minore dell'intervallo di timeout massimo. Tuttavia, se l'intervallo di timeout corrente supera l'intervallo di timeout massimo, il gestore eccezioni scrive le informazioni nel registro eventi e abbandona l'elaborazione dell'espressione regolare.

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.

Commenti

La presenza di un'eccezione RegexMatchTimeoutException indica in genere una delle condizioni seguenti:

Il motore di espressioni regolari esegue il backtracking eccessivamente quando tenta di corrispondere al testo di input al modello di espressione regolare.
L'intervallo di timeout è stato impostato troppo basso, soprattutto dato il carico elevato del computer.

Il modo in cui un gestore di eccezioni gestisce un'eccezione dipende dalla causa dell'eccezione:

Se il timeout risulta da un backtracking eccessivo, il gestore delle eccezioni deve abbandonare il tentativo di corrispondere all'input e informare l'utente che si è verificato un timeout nel metodo di corrispondenza dei criteri di espressione regolare. Se possibile, è necessario registrare informazioni sul modello di espressione regolare, disponibile dalla Pattern proprietà e sull'input che ha causato un backtracking eccessivo, disponibile dalla Input proprietà, in modo che il problema possa essere analizzato e il modello di espressione regolare modificato. I timeout a causa di un backtracking eccessivo sono sempre riproducibili.
Se il timeout risulta dall'impostazione della soglia di timeout troppo bassa, è possibile aumentare l'intervallo di timeout e riprovare l'operazione di corrispondenza. L'intervallo MatchTimeout di timeout corrente è disponibile dalla proprietà. Quando viene generata un'eccezione RegexMatchTimeoutException , il motore di espressioni regolari mantiene lo stato in modo che eventuali chiamate future restituiscono lo stesso risultato, come se l'eccezione non si verificasse. Il modello consigliato consiste nell'attendere un breve intervallo di tempo casuale dopo che l'eccezione viene generata prima di chiamare nuovamente il metodo corrispondente. Questo può essere ripetuto più volte. Tuttavia, il numero di ripetizioni deve essere piccolo nel caso in cui il timeout sia causato da un backtracking eccessivo.

L'esempio nella sezione successiva illustra entrambe le tecniche per la gestione di un RegexMatchTimeoutExceptionoggetto .

Costruttori

RegexMatchTimeoutException()	Inizializza una nuova istanza della classe RegexMatchTimeoutException con un messaggio fornito dal sistema.
RegexMatchTimeoutException(SerializationInfo, StreamingContext)	Inizializza una nuova istanza della classe RegexMatchTimeoutException con dati serializzati.
RegexMatchTimeoutException(String)	Inizializza una nuova istanza della classe RegexMatchTimeoutException con la stringa di messaggio specificata.
RegexMatchTimeoutException(String, Exception)	Inizializza una nuova istanza della classe RegexMatchTimeoutException con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente.
RegexMatchTimeoutException(String, String, TimeSpan)	Inizializza una nuova istanza della classe RegexMatchTimeoutException con le informazioni sul modello di espressione regolare, il testo di input e l'intervallo di timeout.

Proprietà

Data	Ottiene una raccolta di coppie chiave/valore che forniscono informazioni definite dall'utente aggiuntive sull'eccezione. (Ereditato da Exception)
HelpLink	Ottiene o imposta un collegamento al file della Guida associato all'eccezione. (Ereditato da Exception)
HResult	Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica. (Ereditato da Exception)
InnerException	Ottiene l'istanza di Exception che ha causato l'eccezione corrente. (Ereditato da Exception)
Input	Ottiene il testo di input che il motore delle espressioni regolari stava elaborando quando si è verificato il timeout.
MatchTimeout	Ottiene l'intervallo di timeout per una corrispondenza di espressione regolare.
Message	Ottiene un messaggio che descrive l'eccezione corrente. (Ereditato da Exception)
Pattern	Ottiene il modello di espressione regolare utilizzato nell'operazione di confronto nel momento in cui si è verificato il timeout.
Source	Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore. (Ereditato da Exception)
StackTrace	Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate. (Ereditato da Exception)
TargetSite	Ottiene il metodo che genera l'eccezione corrente. (Ereditato da Exception)

Metodi

Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetBaseException()	Quando ne viene eseguito l'override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive. (Ereditato da Exception)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetObjectData(SerializationInfo, StreamingContext)	Quando ne viene eseguito l'override in una classe derivata, imposta il controllo SerializationInfo con le informazioni sull'eccezione. (Ereditato da Exception)
GetType()	Ottiene il tipo di runtime dell'istanza corrente. (Ereditato da Exception)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Crea e restituisce una rappresentazione di stringa dell'eccezione corrente. (Ereditato da Exception)

Eventi

SerializeObjectState

Obsoleti.

Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione.

(Ereditato da Exception)

Implementazioni dell'interfaccia esplicita

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Popola un oggetto SerializationInfo con i dati necessari per serializzare un oggetto RegexMatchTimeoutException.

Si applica a

Condividi tramite