Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Costruttore Regex (String, RegexOptions, TimeSpan)

.NET Framework (current version)
 

Data di pubblicazione: ottobre 2016

Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata, con le opzioni che modificano il criterio e un valore che specifica per quanto tempo un metodo di criteri di ricerca deve provare a trovare una corrispondenza prima del timeout.

Spazio dei nomi:   System.Text.RegularExpressions
Assembly:  System (in System.dll)

public Regex(
	string pattern,
	RegexOptions options,
	TimeSpan matchTimeout
)

Parametri

pattern
Type: System.String

Criterio di espressione regolare di cui trovare la corrispondenza.

options
Type: System.Text.RegularExpressions.RegexOptions

Combinazione bit per bit dei valori di enumerazione che modificano l'espressione regolare.

matchTimeout
Type: System.TimeSpan

Intervallo di timeout o Regex.InfiniteMatchTimeout per indicare che per il metodo non è previsto un timeout.

Exception Condition
ArgumentException

Si è verificato un errore di analisi dell'espressione regolare.

ArgumentNullException

pattern è null.

ArgumentOutOfRangeException

options non è un valore valido di RegexOptions.

-oppure-

matchTimeout è negativo, zero o maggiore di circa 24 giorni.

Il pattern parametro consiste di elementi di linguaggio di espressioni regolari che descrivono la stringa da confrontare. Per ulteriori informazioni sulle espressioni regolari, vedere il Espressioni regolari di .NET Framework e Linguaggio di espressioni regolari - Riferimento rapido argomenti.

Oggetto Regex oggetto non è modificabile, il che significa che può essere utilizzato solo per il criterio di corrispondenza definiti quando si crea. Tuttavia, può essere utilizzato qualsiasi numero di volte senza alcuna ricompilazione.

Il matchTimeout parametro specifica quanto tempo una corrispondenza metodo tentare di trovare una corrispondenza prima del timeout. Se viene trovata alcuna corrispondenza in tale intervallo di tempo, il metodo corrispondenza genera un RegexMatchTimeoutException (eccezione). matchTimeout esegue l'override di qualsiasi valore di timeout predefinito definito per il dominio applicazione in cui il Regex viene creato l'oggetto. I metodi di istanza corrispondenza che osservano il matchTimeoutintervallo di timeout includono quanto segue:

L'impostazione di un intervallo di timeout impedisce le espressioni regolari che si basano su un backtracking eccessivo venga visualizzato il blocco quando elaborano un input che contiene corrispondenze. Per altre informazioni, vedere Procedure consigliate per le espressioni regolari in .NET Framework e Backtracking nelle espressioni regolari. Per impostare un intervallo di timeout ragionevole, considerare quanto segue:

  • La lunghezza e complessità del modello di espressione regolare. Le espressioni regolari più lunga e più complesse richiedono più tempo rispetto a quelli più breve e semplice.

  • Il carico di lavoro previsto. L'elaborazione richiede più tempo nei sistemi che dispongono di un utilizzo elevato della CPU e memoria.

Note per i chiamanti:

Si consiglia di impostare il matchTimeout parametro su un valore appropriato, ad esempio due secondi. Se si disabilita i timeout specificando Regex.InfiniteMatchTimeout, il motore delle espressioni regolari offre prestazioni leggermente migliori. Tuttavia, è necessario disabilitare i timeout solo nelle condizioni seguenti:

  • Quando l'input elaborato da un'espressione regolare è derivato da un'origine conosciuta e attendibile o è costituita da testo statico. È escluso il testo che è stato in modo dinamico l'input dagli utenti.

  • Quando è stato testato completamente il criterio di espressione regolare per garantire che gestisce in modo efficiente corrisponde, mancate corrispondenze e più vicino corrisponde.

  • Quando il criterio di espressione regolare non contiene language elementi che potrebbero causare l'utilizzo eccessivo del backtracking durante l'elaborazione di una corrispondenza più vicino.

Nell'esempio seguente viene chiamato il Regex(String, RegexOptions, TimeSpan) costruttore per creare un'istanza di un Regex con un valore di timeout di un secondo oggetto. Il modello di espressione regolare (a+)+$, che corrisponde a uno o più sequenze di uno o più caratteri "a" alla fine di una riga, è soggetto all'utilizzo eccessivo del backtracking. Se un RegexMatchTimeoutException viene generato, l'esempio aumenta il valore di timeout fino al valore massimo di tre secondi. In caso contrario, ignora il tentativo di corrispondere al modello.

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;
using System.Text.RegularExpressions;
using System.Threading; 

public class Example
{
   const int MaxTimeoutInSeconds = 3;

   public static void Main()
   {
      string pattern = @"(a+)+$";    // DO NOT REUSE THIS PATTERN.
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1));       
      Stopwatch sw = null;

      string[] inputs= { "aa", "aaaa>", 
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                         "aaaaaaaaaaaaaaaaaaaaaa>",
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" };

      foreach (var inputValue in inputs) {
         Console.WriteLine("Processing {0}", inputValue);
         bool timedOut = false;
         do { 
            try {
               sw = Stopwatch.StartNew();
               // Display the result.
               if (rgx.IsMatch(inputValue)) {
                  sw.Stop();
                  Console.WriteLine(@"Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed); 
               }
               else {
                  sw.Stop();
                  Console.WriteLine(@"'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed);
               }
            }
            catch (RegexMatchTimeoutException e) {   
               sw.Stop();
               // Display the elapsed time until the exception.
               Console.WriteLine(@"Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed);
               Thread.Sleep(1500);       // Pause for 1.5 seconds.

               // Increase the timeout interval and retry.
               TimeSpan timeout = e.MatchTimeout.Add(TimeSpan.FromSeconds(1));
               if (timeout.TotalSeconds > MaxTimeoutInSeconds) {
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds);
                  timedOut = false;
               }
               else {               
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout); 
                  rgx = new Regex(pattern, RegexOptions.IgnoreCase, timeout);
                  timedOut = true;
               }
            }
         } while (timedOut);
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following :
//    Processing aa
//    Valid: 'aa' (00.0000779 seconds)
//    
//    Processing aaaa>
//    'aaaa>' is not a valid string. (00.00005 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
//    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
//    Changing the timeout interval to 00:00:02
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
//    Changing the timeout interval to 00:00:03
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
//    Maximum timeout interval of 3 seconds exceeded.
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
//    Maximum timeout interval of 3 seconds exceeded.

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 4.5
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Windows Phone Silverlight
Disponibile da 8.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: