Regex Costruttori

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.

Inizializza una nuova istanza della classe Regex.

Overload

Regex()	Inizializza una nuova istanza della classe Regex.
Regex(String)	Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata.
Regex(SerializationInfo, StreamingContext)	Obsoleti. Inizializza una nuova istanza della classe Regex utilizzando dati serializzati.
Regex(String, RegexOptions)	Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata, con opzioni che modificano il criterio.
Regex(String, RegexOptions, TimeSpan)	Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata, con opzioni che modificano il criterio e un valore che specifica per quanto tempo un metodo di corrispondenza dei criteri deve tentare una corrispondenza prima del timeout.

Regex()

Origine:: Regex.cs

Origine:: Regex.cs

Origine:: Regex.cs

Inizializza una nuova istanza della classe Regex.

protected:
 Regex();

protected Regex ();

Protected Sub New ()

Commenti

Si noti che questo costruttore è protetto; può essere chiamato solo da classi derivate dalla classe Regex.

Si applica a

Regex(String)

Origine:: Regex.cs

Origine:: Regex.cs

Origine:: Regex.cs

Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata.

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

Modello di espressione regolare da trovare in corrispondenza.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

pattern è null.

Esempio

Nell'esempio seguente viene illustrato come usare questo costruttore per creare un'istanza di un'espressione regolare corrispondente a qualsiasi parola che inizia con le lettere "a" o "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. Per un esempio di confronto senza distinzione tra maiuscole e minuscole, vedere il costruttore Regex(String, RegexOptions).

Commenti

Avvertimento

Quando si usa System.Text.RegularExpressions per elaborare l'input non attendibile, passare un valore di timeout per impedire agli utenti malintenzionati di causare un attacco Denial of Service . Un valore di timeout specifica per quanto tempo un metodo di corrispondenza dei criteri deve tentare di trovare una corrispondenza prima del timeout.

Il parametro pattern è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere gli argomenti espressioni regolari .NET e linguaggio di espressioni regolari - Riferimento rapido.

La chiamata al costruttore Regex(String) equivale a chiamare il costruttore Regex(String, RegexOptions) con un valore di None per l'argomento options.

Un oggetto Regex non è modificabile, il che significa che può essere usato solo per il modello di corrispondenza definito durante la creazione. Tuttavia, può essere usato un numero qualsiasi di volte senza essere ricompilato.

Questo costruttore crea un'istanza di un oggetto espressione regolare che tenta una corrispondenza con distinzione tra maiuscole e minuscole di tutti i caratteri alfabetici definiti in pattern. Per una corrispondenza senza distinzione tra maiuscole e minuscole, usare il costruttore Regex.Regex(String, RegexOptions).

Note per i chiamanti

Questo costruttore crea un oggetto Regex che usa il valore di timeout predefinito del dominio applicazione in cui viene creato. Se non è stato definito un valore di timeout per il dominio applicazione, l'oggetto Regex utilizza il valore InfiniteMatchTimeout, che impedisce il timeout dell'operazione. Il costruttore consigliato per la creazione di un oggetto Regex è Regex(String, RegexOptions, TimeSpan), che consente di impostare l'intervallo di timeout.

Vedi anche

elementi del linguaggio delle espressioni regolari

Si applica a

Regex(SerializationInfo, StreamingContext)

Origine:: Regex.cs

Origine:: Regex.cs

Origine:: Regex.cs

Attenzione

This API supports obsolete formatter-based serialization. It should not be called or extended by application code.

Inizializza una nuova istanza della classe Regex utilizzando dati serializzati.

protected:
 Regex(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);

protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);

[System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
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

[<System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
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 che contiene un modello serializzato e RegexOptions informazioni.

context: StreamingContext

Destinazione di questa serializzazione. Questo parametro non viene usato; specificare null.

Attributi: ObsoleteAttribute

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

Il modello che info contiene è null.

ArgumentOutOfRangeException

info contiene un flag di RegexOptions non valido.

Si applica a

Regex(String, RegexOptions)

Origine:: Regex.cs

Origine:: Regex.cs

Origine:: Regex.cs

Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata, con opzioni che modificano il criterio.

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

Modello di espressione regolare da trovare in corrispondenza.

options: RegexOptions

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

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

pattern è null.

ArgumentOutOfRangeException

options contiene un flag non valido.

Esempio

Nell'esempio seguente viene illustrato come usare questo costruttore per creare un'istanza di un'espressione regolare corrispondente a qualsiasi parola che inizia con le lettere "a" o "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 inizia il testo perché il parametro options ha definito confronti senza distinzione tra maiuscole e minuscole.

Commenti

Avvertimento

Un oggetto Regex non è modificabile, il che significa che può essere usato solo per i parametri di corrispondenza definiti durante la creazione. Tuttavia, può essere usato un numero qualsiasi di volte senza essere ricompilato.

Note per i chiamanti

Vedi anche

elementi del linguaggio delle espressioni regolari

Si applica a

Regex(String, RegexOptions, TimeSpan)

Origine:: Regex.cs

Origine:: Regex.cs

Origine:: Regex.cs

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

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

Modello di espressione regolare da trovare in corrispondenza.

options: RegexOptions

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

matchTimeout: TimeSpan

Intervallo di timeout o InfiniteMatchTimeout per indicare che il metodo non deve scadere.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

pattern è null.

ArgumentOutOfRangeException

options non è un valore di RegexOptions valido.

-o-

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

Esempio

Nell'esempio seguente viene chiamato il costruttore Regex(String, RegexOptions, TimeSpan) per creare un'istanza di un oggetto Regex con un valore di timeout di un secondo. Il criterio di espressione regolare (a+)+$, che corrisponde a una o più sequenze di uno o più caratteri "a" alla fine di una riga, è soggetto a un backtracking eccessivo. Se viene generata una RegexMatchTimeoutException, l'esempio aumenta il valore di timeout fino al valore massimo di tre secondi. In caso contrario, abbandona il tentativo di trovare la corrispondenza con il 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.

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 parametro matchTimeout consente di specificare per quanto tempo un metodo di corrispondenza dei criteri deve tentare di trovare una corrispondenza prima del timeout. Se non viene trovata alcuna corrispondenza in tale intervallo di tempo, il metodo di ricerca genera un'eccezione RegexMatchTimeoutException. matchTimeout esegue l'override di qualsiasi valore di timeout predefinito definito per il dominio applicazione in cui viene creato l'oggetto Regex. I metodi di corrispondenza dei criteri di istanza che osservano l'intervallo di timeout matchTimeout includono quanto segue:

L'impostazione di un intervallo di timeout impedisce che le espressioni regolari che si basano su un backtracking eccessivo vengano visualizzate per interrompere la risposta quando elaborano l'input che contiene corrispondenze vicine. Per altre informazioni, vedere procedure consigliate per le espressioni regolari e backtracking. Per impostare un intervallo di timeout ragionevole, considerare i fattori seguenti:

Lunghezza e complessità del criterio di espressione regolare. Le espressioni regolari più lunghe e complesse richiedono più tempo rispetto a quelle più brevi e più semplici.
Carico previsto del computer. L'elaborazione richiede più tempo sui sistemi con un utilizzo elevato della CPU e della memoria.

Note per i chiamanti

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

Quando l'input elaborato da un'espressione regolare è derivato da un'origine nota e attendibile o è costituito da testo statico. Questo esclude il testo che è stato immesso dinamicamente dagli utenti.
Quando il criterio di espressione regolare è stato testato accuratamente per garantire che gestisca in modo efficiente corrispondenze, non corrispondenze e corrispondenze vicine.
Quando il criterio di espressione regolare non contiene elementi del linguaggio noti per causare un backtracking eccessivo durante l'elaborazione di una corrispondenza vicina.

Vedi anche

Si applica a

Condividi tramite

Regex Costruttori

Definizione

Overload

Regex()

Commenti

Si applica a

Regex(String)

Parametri

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Regex(SerializationInfo, StreamingContext)

Parametri

Eccezioni

Si applica a

Regex(String, RegexOptions)

Parametri

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Regex(String, RegexOptions, TimeSpan)

Parametri

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Commenti e suggerimenti

Risorse aggiuntive