Regex Costruttori

Definizione

Inizializza una nuova istanza della classe Regex.Initializes a new instance of the Regex class.

Overload

Regex()

Inizializza una nuova istanza della classe Regex.Initializes a new instance of the Regex class.

Regex(String)

Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata.Initializes a new instance of the Regex class for the specified regular expression.

Regex(SerializationInfo, StreamingContext)

Inizializza una nuova istanza della classe Regex usando i dati serializzati.Initializes a new instance of the Regex class by using serialized data.

Regex(String, RegexOptions)

Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata, con opzioni che modificano il criterio.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern.

Regex(String, RegexOptions, TimeSpan)

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.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern and a value that specifies how long a pattern matching method should attempt a match before it times out.

Regex()

Inizializza una nuova istanza della classe Regex.Initializes a new instance of the Regex class.

protected:
 Regex();
protected Regex ();
Protected Sub New ()

Commenti

Si noti che questo costruttore è protetto. può essere chiamato solo dalle classi derivate dalla Regex classe.Note that this constructor is protected; it can only be called by classes derived from the Regex class.

Si applica a

Regex(String)

Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata.Initializes a new instance of the Regex class for the specified regular expression.

public:
 Regex(System::String ^ pattern);
public Regex (string pattern);
new System.Text.RegularExpressions.Regex : string -> System.Text.RegularExpressions.Regex
Public Sub New (pattern As String)

Parametri

pattern
String

Criterio di espressione regolare di cui trovare la corrispondenza.The regular expression pattern to match.

Eccezioni

Si è verificato un errore di analisi dell'espressione regolare.A regular expression parsing error occurred.

pattern è null.pattern is null.

Esempio

Nell'esempio seguente viene illustrato come utilizzare questo costruttore per creare un'istanza di un'espressione regolare corrispondente a qualsiasi parola che inizia con le lettere "a" o "t".The following example illustrates how to use this constructor to instantiate a regular expression that matches any word that begins with the letters "a" or "t".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex defaultRegex = new Regex(pattern);
      // Get matches of pattern in text
      matches = defaultRegex.Matches(text);
      Console.WriteLine("Parsing '{0}'", text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//       Parsing 'The threaded application ate up the thread pool as it executed.'
//       0. threaded
//       1. application
//       2. ate
//       3. the
//       4. thread
//       5. as
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim defaultRegex As New Regex(pattern)
      ' Get matches of pattern in text
      matches = defaultRegex.Matches(text)
      Console.WriteLine("Parsing '{0}'", text)
      ' Iterate matches
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Parsing 'The threaded application ate up the thread pool as it executed.'
'       0. threaded
'       1. application
'       2. ate
'       3. the
'       4. thread
'       5. as

Si noti che il criterio di espressione regolare non può corrispondere alla parola "The" all'inizio del testo, perché per impostazione predefinita i confronti fanno distinzione tra maiuscole e minuscole.Note that the regular expression pattern cannot match the word "The" at the beginning of the text, because comparisons are case-sensitive by default. Per un esempio di confronto senza distinzione tra maiuscole e minuscole, vedere il Regex(String, RegexOptions) costruttore.For an example of case-insensitive comparison, see the Regex(String, RegexOptions) constructor.

Commenti

Il pattern parametro è costituito da elementi del linguaggio di espressioni regolari che descrivono simbolicamente la stringa di cui trovare la corrispondenza.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per ulteriori informazioni sulle espressioni regolari, vedere gli argomenti .NET Framework espressioni regolari e linguaggio di espressioni regolari -riferimento rapido .For more information about regular expressions, see the .NET Framework Regular Expressions and Regular Expression Language - Quick Reference topics.

Chiamare il Regex(String) costruttore equivale a chiamare il Regex(String, RegexOptions) costruttore con un valore None per l' options argomento.Calling the Regex(String) constructor is equivalent to calling the Regex(String, RegexOptions) constructor with a value of None for the options argument.

Un Regex oggetto non è modificabile, il che significa che può essere usato solo per il modello di corrispondenza definito al momento della creazione.A Regex object is immutable, which means that it can be used only for the match pattern you define when you create it. Tuttavia, può essere utilizzato un numero qualsiasi di volte senza essere ricompilato.However, it can be used any number of times without being recompiled.

Questo costruttore crea un'istanza di un oggetto di espressione regolare che tenta una corrispondenza con distinzione tra maiuscole e minuscole di qualsiasi carattere alfabetico definito in pattern .This constructor instantiates a regular expression object that attempts a case-sensitive match of any alphabetical characters defined in pattern. Per una corrispondenza senza distinzione tra maiuscole e minuscole, utilizzare il Regex.Regex(String, RegexOptions) costruttore.For a case-insensitive match, use the Regex.Regex(String, RegexOptions) constructor.

Note per i chiamanti

Questo costruttore crea un Regex oggetto che utilizza il valore di timeout predefinito del dominio dell'applicazione in cui viene creato.This constructor creates a Regex object that uses the default time-out value of the application domain in which it is created. Se non è stato definito un valore di timeout per il dominio dell'applicazione, l' Regex oggetto usa il valore InfiniteMatchTimeout che impedisce il timeout dell'operazione. Il costruttore consigliato per la creazione di un Regex oggetto è Regex(String, RegexOptions, TimeSpan) , che consente di impostare l'intervallo di timeout.If a time-out value has not been defined for the application domain, the Regex object uses the value InfiniteMatchTimeout, which prevents the operation from timing out. The recommended constructor for creating a Regex object is Regex(String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Vedi anche

Si applica a

Regex(SerializationInfo, StreamingContext)

Inizializza una nuova istanza della classe Regex usando i dati serializzati.Initializes a new instance of the Regex class by using serialized data.

protected:
 Regex(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);
protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex
Protected Sub New (info As SerializationInfo, context As StreamingContext)

Parametri

info
SerializationInfo

Oggetto in cui sono contenuti un modello serializzato e le informazioni relative a RegexOptions.The object that contains a serialized pattern and RegexOptions information.

context
StreamingContext

Destinazione per questa serializzazione.The destination for this serialization. Questo parametro non viene usato; specificare null.(This parameter is not used; specify null.)

Eccezioni

Si è verificato un errore di analisi dell'espressione regolare.A regular expression parsing error occurred.

Il criterio contenuto nel parametro info è null.The pattern that info contains is null.

Il parametro info contiene un flag RegexOptions non valido.info contains an invalid RegexOptions flag.

Si applica a

Regex(String, RegexOptions)

Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata, con opzioni che modificano il criterio.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern.

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options);
new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Regex
Public Sub New (pattern As String, options As RegexOptions)

Parametri

pattern
String

Criterio di espressione regolare di cui trovare la corrispondenza.The regular expression pattern to match.

options
RegexOptions

Combinazione bit per bit dei valori di enumerazione che modificano l'espressione regolare.A bitwise combination of the enumeration values that modify the regular expression.

Eccezioni

Si è verificato un errore di analisi dell'espressione regolare.A regular expression parsing error occurred.

pattern è null.pattern is null.

Il parametro options contiene un flag non valido.options contains an invalid flag.

Esempio

Nell'esempio seguente viene illustrato come utilizzare questo costruttore per creare un'istanza di un'espressione regolare corrispondente a qualsiasi parola che inizia con le lettere "a" o "t".The following example illustrates how to use this constructor to instantiate a regular expression that matches any word that begins with the letters "a" or "t".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.Compiled;
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex optionRegex = new Regex(pattern, options);
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString());
      // Get matches of pattern in text
      matches = optionRegex.Matches(text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//    Parsing 'The threaded application ate up the thread pool as it executed.'
//        with options IgnoreCase, Compiled:
//    0. The
//    1. threaded
//    2. application
//    3. ate
//    4. the
//    5. thread
//    6. as
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.Compiled
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim optionRegex As New Regex(pattern, options)
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString())
      ' Get matches of pattern in text
      matches = optionRegex.Matches(text)
      ' Iterate matches   
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    Parsing 'The threaded application ate up the thread pool as it executed.'
'       with options IgnoreCase, Compiled:
'    0. The
'    1. threaded
'    2. application
'    3. ate
'    4. the
'    5. thread
'    6. as

Si noti che la raccolta di corrispondenze include la parola "The" che avvia il testo perché il options parametro ha definito confronti senza distinzione tra maiuscole e minuscole.Note that the match collection includes the word "The" that begins the text because the options parameter has defined case-insensitive comparisons.

Commenti

Il pattern parametro è costituito da elementi del linguaggio di espressioni regolari che descrivono simbolicamente la stringa di cui trovare la corrispondenza.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per ulteriori informazioni sulle espressioni regolari, vedere gli argomenti .NET Framework espressioni regolari e linguaggio di espressioni regolari -riferimento rapido .For more information about regular expressions, see the .NET Framework Regular Expressions and Regular Expression Language - Quick Reference topics.

Un Regex oggetto non è modificabile, il che significa che può essere usato solo per i parametri di corrispondenza definiti al momento della creazione.A Regex object is immutable, which means that it can be used only for the match parameters you define when you create it. Tuttavia, può essere utilizzato un numero qualsiasi di volte senza essere ricompilato.However, it can be used any number of times without being recompiled.

Note per i chiamanti

Questo costruttore crea un Regex oggetto che utilizza il valore di timeout predefinito del dominio dell'applicazione in cui viene creato.This constructor creates a Regex object that uses the default time-out value of the application domain in which it is created. Se non è stato definito un valore di timeout per il dominio dell'applicazione, l' Regex oggetto usa il valore InfiniteMatchTimeout che impedisce il timeout dell'operazione. Il costruttore consigliato per la creazione di un Regex oggetto è Regex(String, RegexOptions, TimeSpan) , che consente di impostare l'intervallo di timeout.If a time-out value has not been defined for the application domain, the Regex object uses the value InfiniteMatchTimeout, which prevents the operation from timing out. The recommended constructor for creating a Regex object is Regex(String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Vedi anche

Si applica a

Regex(String, RegexOptions, TimeSpan)

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.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern and a value that specifies how long a pattern matching method should attempt a match before it times out.

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Regex
Public Sub New (pattern As String, options As RegexOptions, matchTimeout As TimeSpan)

Parametri

pattern
String

Criterio di espressione regolare di cui trovare la corrispondenza.The regular expression pattern to match.

options
RegexOptions

Combinazione bit per bit dei valori di enumerazione che modificano l'espressione regolare.A bitwise combination of the enumeration values that modify the regular expression.

matchTimeout
TimeSpan

Intervallo di timeout o InfiniteMatchTimeout per indicare che per il metodo non è previsto un timeout.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Eccezioni

Si è verificato un errore di analisi dell'espressione regolare.A regular expression parsing error occurred.

pattern è null.pattern is null.

options non è un valore valido di RegexOptions.options is not a valid RegexOptions value.

-oppure--or- matchTimeout è negativo, zero o maggiore di circa 24 giorni.matchTimeout is negative, zero, or greater than approximately 24 days.

Esempio

Nell'esempio seguente viene chiamato il Regex(String, RegexOptions, TimeSpan) costruttore per creare un'istanza di un Regex oggetto con un valore di timeout di un secondo.The following example calls the Regex(String, RegexOptions, TimeSpan) constructor to instantiate a Regex object with a time-out value of one second. 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.The regular expression pattern (a+)+$, which matches one or more sequences of one or more "a" characters at the end of a line, is subject to excessive backtracking. Se RegexMatchTimeoutException viene generata un'eccezione, l'esempio aumenta il valore di timeout fino al valore massimo di tre secondi.If a RegexMatchTimeoutException is thrown, the example increases the time-out value up to the maximum value of three seconds. In caso contrario, abbandona il tentativo di corrispondenza con il modello.Otherwise, it abandons the attempt to match the pattern.

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.
Imports System.ComponentModel
Imports System.Diagnostics
Imports System.Security
Imports System.Text.RegularExpressions
Imports System.Threading 

Module Example
   Const MaxTimeoutInSeconds As Integer = 3
   
   Public Sub Main()
      Dim pattern As String = "(a+)+$"    ' DO NOT REUSE THIS PATTERN.
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1))       
      Dim sw As Stopwatch = Nothing
      
      Dim inputs() As String = { "aa", "aaaa>", 
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                                 "aaaaaaaaaaaaaaaaaaaaaa>",
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" }
                                 
      For Each inputValue In inputs
         Console.WriteLine("Processing {0}", inputValue)
         Dim timedOut As Boolean = False
         Do 
            Try
               sw = Stopwatch.StartNew()
               ' Display the result.
               If rgx.IsMatch(inputValue) Then
                  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)
               End If
            Catch e As RegexMatchTimeoutException   
               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.
               Dim timeout As TimeSpan = e.MatchTimeout.Add(TimeSpan.FromSeconds(1))
               If timeout.TotalSeconds > MaxTimeoutInSeconds Then
                  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
               End If
            End Try
         Loop While timedOut
         Console.WriteLine()
      Next   
   End Sub 
End Module
' 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.

Commenti

Il pattern parametro è costituito da elementi del linguaggio di espressioni regolari che descrivono simbolicamente la stringa di cui trovare la corrispondenza.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per ulteriori informazioni sulle espressioni regolari, vedere gli argomenti .NET Framework espressioni regolari e linguaggio di espressioni regolari -riferimento rapido .For more information about regular expressions, see the .NET Framework Regular Expressions and Regular Expression Language - Quick Reference topics.

Un Regex oggetto non è modificabile, il che significa che può essere usato solo per il modello di corrispondenza definito al momento della creazione.A Regex object is immutable, which means that it can be used only for the match pattern that you define when you create it. Tuttavia, può essere utilizzato un numero qualsiasi di volte senza essere ricompilato.However, it can be used any number of times without being recompiled.

Il matchTimeout parametro specifica per quanto tempo un metodo di criteri di ricerca deve provare a trovare una corrispondenza prima del timeout. Se non viene trovata alcuna corrispondenza in tale intervallo di tempo, il metodo di criteri di ricerca genera un' RegexMatchTimeoutException eccezione.The matchTimeout parameter specifies how long a pattern-matching method should try to find a match before it times out. If no match is found in that time interval, the pattern-matching method throws a RegexMatchTimeoutException exception. matchTimeout esegue l'override di qualsiasi valore di timeout predefinito definito per il dominio dell'applicazione in cui Regex viene creato l'oggetto.matchTimeout overrides any default time-out value defined for the application domain in which the Regex object is created. I metodi di corrispondenza dei modelli di istanza che osservano l' matchTimeout intervallo di timeout includono quanto segue:The instance pattern-matching methods that observe the matchTimeout time-out interval include the following:

L'impostazione di un intervallo di timeout impedisce la visualizzazione di espressioni regolari basate su un backtracking eccessivo per interrompere la risposta quando elaborano un input che contiene le corrispondenze vicine.Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Per altre informazioni, vedere procedure consigliate per le espressioni regolari e il backtracking.For more information, see Best Practices for Regular Expressions and Backtracking. Per impostare un intervallo di timeout ragionevole, considerare i fattori seguenti:To set a reasonable time-out interval, consider the following factors:

  • La lunghezza e la complessità del criterio di espressione regolare.The length and complexity of the regular expression pattern. Le espressioni regolari più lunghe e complesse richiedono più tempo rispetto a quelle più semplici e più brevi.Longer and more complex regular expressions require more time than shorter and simpler ones.

  • Il carico del computer previsto.The expected machine load. L'elaborazione impiega più tempo nei sistemi con utilizzo elevato della CPU e della memoria.Processing takes more time on systems that have high CPU and memory utilization.

Note per i chiamanti

Si consiglia di impostare il matchTimeout parametro su un valore appropriato, ad esempio due secondi.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Se si disabilitano i timeout specificando InfiniteMatchTimeout , il motore delle espressioni regolari offre prestazioni leggermente migliori.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Tuttavia, è consigliabile disabilitare i timeout solo nelle condizioni seguenti:However, you should disable time-outs only under the following conditions: -Quando l'input elaborato da un'espressione regolare è derivato da un'origine nota e attendibile oppure è costituito da testo statico.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Questo esclude il testo che è stato inserito dinamicamente dagli utenti.This excludes text that has been dynamically input by users.

-Quando il modello di espressione regolare è stato testato accuratamente per assicurarsi che gestisca in modo efficiente le corrispondenze, non corrispondenze e quasi corrispondenze.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Quando il criterio di espressione regolare non contiene elementi del linguaggio noti per causare un backtracking eccessivo durante l'elaborazione di una corrispondenza vicina.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Vedi anche

Si applica a