Regex Costruttori
Definizione
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 usando i 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 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. |
Regex()
Regex(String)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- 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.RegexPublic Sub New (pattern As String)Parametri
- pattern
- String
Criterio di espressione regolare di cui trovare la corrispondenza.
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
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 modello di espressione regolare non può corrispondere alla parola "The" all'inizio del testo, perché i confronti sono distinzione tra maiuscole e minuscole per impostazione predefinita. Per un esempio di confronto senza distinzione tra maiuscole e minuscole, vedere il Regex(String, RegexOptions) costruttore.
Commenti
Il pattern parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da corrispondere. Per altre informazioni sulle espressioni regolari, vedere gli argomenti .NET Regular Expressions e Regular Expression Language - Guida introduttiva .
La chiamata al costruttore equivale a chiamare il Regex(String)Regex(String, RegexOptions) costruttore con un valore di None per l'argomento options .
Un Regex oggetto è non modificabile, che significa che può essere usato solo per il modello di corrispondenza definito quando lo si crea. Tuttavia, può essere usato qualsiasi numero 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 qualsiasi carattere alfabetico definito in pattern. Per una corrispondenza senza distinzione tra maiuscole e minuscole, usare il Regex.Regex(String, RegexOptions) costruttore.
Note per i chiamanti
Questo costruttore crea un Regex oggetto che usa il valore di timeout predefinito del dominio dell'applicazione in cui viene creato. Se un valore di timeout non è stato definito per il dominio dell'applicazione, l'oggetto Regex 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.
Vedi anche
Si applica a
Regex(SerializationInfo, StreamingContext)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- 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 usando i 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.RegexProtected 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.
- context
- StreamingContext
Destinazione per questa serializzazione. Questo parametro non viene usato; specificare null.
- Attributi
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
Il criterio contenuto nel parametro info è null.
Il parametro info contiene un flag RegexOptions non valido.
Si applica a
Regex(String, RegexOptions)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- 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.RegexPublic Sub New (pattern As String, options As RegexOptions)Parametri
- pattern
- String
Criterio di espressione regolare di cui trovare la corrispondenza.
- options
- RegexOptions
Combinazione bit per bit dei valori di enumerazione che modificano l'espressione regolare.
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
pattern è null.
Il parametro 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 options parametro ha definito confronti senza distinzione tra maiuscole e minuscole.
Commenti
Il pattern parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da corrispondere. Per altre informazioni sulle espressioni regolari, vedere gli argomenti .NET Regular Expressions e Regular Expression Language - Guida introduttiva .
Un Regex oggetto è non modificabile, che significa che può essere usato solo per i parametri di corrispondenza definiti quando lo si crea. Tuttavia, può essere usato qualsiasi numero di volte senza essere ricompilato.
Note per i chiamanti
Questo costruttore crea un Regex oggetto che usa il valore di timeout predefinito del dominio dell'applicazione in cui viene creato. Se un valore di timeout non è stato definito per il dominio dell'applicazione, l'oggetto Regex 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.
Vedi anche
Si applica a
Regex(String, RegexOptions, TimeSpan)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
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.
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.RegexPublic Sub New (pattern As String, options As RegexOptions, matchTimeout As TimeSpan)Parametri
- pattern
- String
Criterio di espressione regolare di cui trovare la 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 per il metodo non è previsto un timeout.
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
pattern è null.
options non è un valore valido di RegexOptions.
-oppure-
matchTimeout è negativo, zero o maggiore di circa 24 giorni.
Esempio
Nell'esempio seguente viene chiamato il costruttore per creare un'istanza Regex(String, RegexOptions, TimeSpan) di un Regex oggetto con un valore di timeout di un secondo. 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 viene generato un RegexMatchTimeoutException oggetto, l'esempio aumenta il valore di timeout fino al valore massimo di tre secondi. In caso contrario, abbandona 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.
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 delle espressioni regolari che descrivono simbolicamente la stringa da corrispondere. Per altre informazioni sulle espressioni regolari, vedere gli argomenti .NET Regular Expressions e Regular Expression Language - Guida introduttiva .
Un Regex oggetto è non modificabile, il che significa che può essere usato solo per il modello di corrispondenza definito quando lo si crea. Tuttavia, può essere usato qualsiasi numero di volte senza essere ricompilato.
Il matchTimeout parametro specifica la durata di un metodo di corrispondenza dei modelli che deve cercare di trovare una corrispondenza prima del timeout. Se non viene trovata alcuna corrispondenza nell'intervallo di tempo, il metodo di corrispondenza dei modelli genera un'eccezione RegexMatchTimeoutException . matchTimeout esegue l'override di qualsiasi valore di timeout predefinito definito per il dominio dell'applicazione in cui viene creato l'oggetto Regex . I metodi di corrispondenza dei modelli di istanza che osservano l'intervallo matchTimeout di timeout includono quanto segue:
L'impostazione di un intervallo di timeout impedisce alle espressioni regolari che si basano su un backtracking eccessivo di apparire per interrompere la risposta quando elaborano l'input che contiene corrispondenze vicine. Per altre informazioni, vedere Procedure consigliate per espressioni regolari e Backtracking. Per impostare un intervallo di timeout ragionevole, considerare i fattori seguenti:
Lunghezza e complessità del modello di espressione regolare. Le espressioni regolari più lunghe e più complesse richiedono più tempo rispetto a quelle più brevi e più semplici.
Carico del computer previsto. L'elaborazione richiede più tempo nei sistemi con utilizzo elevato di CPU e memoria.
Note per i chiamanti
È consigliabile impostare il matchTimeout parametro su un valore appropriato, ad esempio due secondi. Se si disabilitano i timeout specificando InfiniteMatchTimeout, il motore di espressioni regolari offre prestazioni leggermente migliori. Tuttavia, è consigliabile disabilitare i timeout solo in base alle condizioni seguenti:
Quando l'input elaborato da un'espressione regolare deriva da un'origine nota e attendibile o è costituita da testo statico. Ciò esclude il testo che è stato immesso dinamicamente dagli utenti.
Quando il modello di espressione regolare è stato testato accuratamente per garantire che gestisca in modo efficiente corrispondenze, non corrispondenze e corrispondenze vicine.
Quando il modello 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
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per