Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Classe Regex

Rappresenta un'espressione regolare non modificabile.

System.Object
  System.Text.RegularExpressions.Regex
    Ulteriori informazioni

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

[SerializableAttribute]
public class Regex : ISerializable

Il tipo Regex espone i seguenti membri.

  NomeDescrizione
Metodo protettoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreRegex()Inizializza una nuova istanza della classe Regex.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreRegex(String)Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata.
Metodo protettoRegex(SerializationInfo, StreamingContext)Inizializza una nuova istanza della classe Regex utilizzando dati serializzati.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreRegex(String, RegexOptions)Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata, con opzioni che modificano il criterio.
Metodo pubblicoSupportato in .NET per applicazioni Windows StoreRegex(String, RegexOptions, TimeSpan)Inizializza una nuova istanza della classe Regex per l'espressione regolare specificata, con le opzioni che modificano il modello e un valore che specifica per quanto tempo un metodo di corrispondenza dei modelli deve tentare la corrispondenza prima di scadere.
In alto

  NomeDescrizione
Proprietà pubblicaMembro staticoCacheSizeOttiene o imposta il numero massimo di voci nella cache statica corrente di espressioni regolari compilate.
Proprietà pubblicaSupportato in .NET per applicazioni Windows StoreMatchTimeoutOttiene l'intervallo di timeout dell'istanza corrente.
Proprietà pubblicaSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreOptionsOttiene le opzioni passate al costruttore Regex.
Proprietà pubblicaSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreRightToLeftOttiene un valore che indica se l'espressione regolare effettua la ricerca da destra a sinistra.
In alto

  NomeDescrizione
Metodo pubblicoMembro staticoCompileToAssembly(RegexCompilationInfo[], AssemblyName)Compila uno o più oggetti Regex specificati in un assembly denominato.
Metodo pubblicoMembro staticoCompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])Compila uno o più oggetti Regex specificati in un assembly denominato con gli attributi specificati.
Metodo pubblicoMembro staticoCompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)Compila uno o più oggetti Regex specificati e un file di risorse specificato in un assembly denominato con gli attributi specificati.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEquals(Object) Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEscapeIgnora un set minimo di caratteri (\, *, +, ?, |, {, [, (,), ^, $,., # e spazio) sostituendoli con i rispettivi codici di escape. Istruisce il motore delle espressioni regolari a interpretare questi caratteri in modo letterale anziché come metacaratteri.
Metodo protettoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreFinalize Consente a un oggetto di provare a liberare risorse ed eseguire altre operazioni di pulizia prima che l'oggetto stesso venga reclamato dalla procedura di Garbage Collection. (Ereditato da Object)
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetGroupNamesRestituisce una matrice di nomi di gruppi di acquisizione per l'espressione regolare.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetGroupNumbersRestituisce una matrice di numeri di gruppi di acquisizione che corrispondono ai nomi dei gruppi in una matrice.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetHashCode Funge da funzione hash per un particolare tipo. (Ereditato da Object)
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetType Ottiene il Type dell'istanza corrente. (Ereditato da Object)
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGroupNameFromNumberOttiene un nome di gruppo che corrisponde al numero di gruppo specificato.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGroupNumberFromNameRestituisce il numero di gruppo che corrisponde al nome di gruppo specificato.
Metodo protettoInitializeReferencesInfrastruttura. Utilizzato da un oggetto Regex generato dal metodo CompileToAssembly.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIsMatch(String)Indica se l'espressione regolare specificata nel costruttore Regex trova una corrispondenza in una stringa di input specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIsMatch(String, Int32)Indica se l'espressione regolare specificata nel costruttore Regex trova una corrispondenza nella stringa di input specificata, a partire dalla posizione iniziale specificata nella stringa.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIsMatch(String, String)Indica se l'espressione regolare specificata trova una corrispondenza nella stringa di input specificata.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIsMatch(String, String, RegexOptions)Indica se l'espressione regolare specificata trova una corrispondenza nella stringa di input specificata utilizzando le opzioni di corrispondenza specificate.
Metodo pubblicoMembro staticoSupportato in .NET per applicazioni Windows StoreIsMatch(String, String, RegexOptions, TimeSpan)Indica se l'espressione regolare specificata trova una corrispondenza nella stringa di input specificata utilizzando le opzioni di corrispondenza specificate e l'intervallo di timeout.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMatch(String)Esegue la ricerca nella stringa di input specificata della prima ricorrenza dell'espressione regolare specificata nel costruttore Regex.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMatch(String, Int32)Cerca nella stringa di input la prima occorrenza di un'espressione regolare, a partire dalla posizione iniziale specificata nella stringa.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMatch(String, String)Cerca nella stringa di input specificata la prima occorrenza dell'espressione regolare specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMatch(String, Int32, Int32)Cerca nella stringa di input la prima occorrenza di un'espressione regolare, a partire dalla posizione iniziale specificata ed eseguendo la ricerca solo del numero di caratteri specificato.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMatch(String, String, RegexOptions)Cerca nella stringa di input la prima occorrenza dell'espressione regolare specificata utilizzando le opzioni di corrispondenza specificate.
Metodo pubblicoMembro staticoSupportato in .NET per applicazioni Windows StoreMatch(String, String, RegexOptions, TimeSpan)Cerca nella stringa di input la prima occorrenza dell'espressione regolare specificata utilizzando le opzioni di corrispondenza e l'intervallo di timeout specificati.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMatches(String)Cerca nella stringa di input specificata tutte le ricorrenze di un'espressione regolare.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMatches(String, Int32)Cerca nella stringa di input specificata tutte le ricorrenze di un'espressione regolare, partendo dalla posizione iniziale specificata nella stringa.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMatches(String, String)Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare specificata.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMatches(String, String, RegexOptions)Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare specificata utilizzando le opzioni di corrispondenza specificate.
Metodo pubblicoMembro staticoSupportato in .NET per applicazioni Windows StoreMatches(String, String, RegexOptions, TimeSpan)Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare specificata utilizzando le opzioni di corrispondenza e l'intervallo di timeout specificati.
Metodo protettoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMemberwiseClone Crea una copia dei riferimenti dell'oggetto Object corrente. (Ereditato da Object)
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreReplace(String, String)In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un criterio di espressione regolare con una stringa di sostituzione specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreReplace(String, MatchEvaluator)In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa restituita da un delegato MatchEvaluator.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreReplace(String, String, Int32)In una stringa di input specificata, sostituisce un numero massimo di stringhe specificato corrispondenti a un criterio di espressione regolare con una stringa di sostituzione specificata.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreReplace(String, String, String)In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa di sostituzione specificata.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreReplace(String, String, MatchEvaluator)In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa restituita da un delegato MatchEvaluator.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreReplace(String, MatchEvaluator, Int32)In una stringa di input specificata, sostituisce un numero massimo di stringhe specificato corrispondenti a un criterio di espressione regolare con una stringa restituita da un delegato MatchEvaluator.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreReplace(String, String, Int32, Int32)In una sottostringa di input specificata, sostituisce un numero massimo di stringhe specificato corrispondenti a un criterio di espressione regolare con una stringa di sostituzione specificata.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreReplace(String, String, String, RegexOptions)In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa di sostituzione specificata. Le opzioni specificate modificano l'operazione di corrispondenza.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreReplace(String, String, MatchEvaluator, RegexOptions)In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa restituita da un delegato MatchEvaluator. Le opzioni specificate modificano l'operazione di corrispondenza.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreReplace(String, MatchEvaluator, Int32, Int32)In una sottostringa di input specificata, sostituisce un numero massimo di stringhe specificato corrispondenti a un criterio di espressione regolare con una stringa restituita da un delegato MatchEvaluator.
Metodo pubblicoMembro staticoSupportato in .NET per applicazioni Windows StoreReplace(String, String, String, RegexOptions, TimeSpan)In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa di sostituzione specificata. I parametri aggiuntivi specificano opzioni che modificano l'operazione corrispondente e un intervallo di timeout se non viene rilevata alcuna corrispondenza.
Metodo pubblicoMembro staticoSupportato in .NET per applicazioni Windows StoreReplace(String, String, MatchEvaluator, RegexOptions, TimeSpan)In una stringa di input specificata, sostituisce tutte le sottostringhe corrispondenti a un'espressione regolare specificata con una stringa restituita da un delegato MatchEvaluator. I parametri aggiuntivi specificano opzioni che modificano l'operazione corrispondente e un intervallo di timeout se non viene rilevata alcuna corrispondenza.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSplit(String)Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato nel costruttore Regex.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSplit(String, Int32)Suddivide una stringa di input per un numero massimo di volte specificato in una matrice di sottostringhe in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSplit(String, String)Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un modello di espressione regolare.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSplit(String, Int32, Int32)Suddivide una stringa di input per un numero massimo di volte specificato in una matrice di sottostringhe in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex. La ricerca del criterio di ricerca di espressioni regolari si avvia a una posizione di carattere specificata nella stringa di input.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSplit(String, String, RegexOptions)Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un modello di espressione regolare specificato. Le opzioni specificate modificano l'operazione di corrispondenza.
Metodo pubblicoMembro staticoSupportato in .NET per applicazioni Windows StoreSplit(String, String, RegexOptions, TimeSpan)Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un modello di espressione regolare specificato. I parametri aggiuntivi specificano opzioni che modificano l'operazione corrispondente e un intervallo di timeout se non viene rilevata alcuna corrispondenza.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToStringRestituisce il criterio dell'espressione regolare passato nel costruttore Regex. (Esegue l'override di Object.ToString()).
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreUnescapeConverte tutti i caratteri di escape presenti nella stringa di input.
Metodo protettoSupportato da XNA FrameworkUseOptionCInfrastruttura. Utilizzato da un oggetto Regex generato dal metodo CompileToAssembly.
Metodo protettoSupportato da XNA FrameworkUseOptionRInfrastruttura. Utilizzato da un oggetto Regex generato dal metodo CompileToAssembly.
Metodo protettoMembro staticoValidateMatchTimeoutInfrastruttura. Verifica se un intervallo di timeout si trova all'interno di un intervallo di valori accettabili.
In alto

  NomeDescrizione
Campo protettoSupportato da XNA FrameworkcapnamesInfrastruttura. Utilizzato da un oggetto Regex generato dal metodo CompileToAssembly.
Campo protettoSupportato da XNA FrameworkcapsInfrastruttura. Utilizzato da un oggetto Regex generato dal metodo CompileToAssembly.
Campo protettoSupportato da XNA FrameworkcapsizeInfrastruttura. Utilizzato da un oggetto Regex generato dal metodo CompileToAssembly.
Campo protettoSupportato da XNA FrameworkcapslistInfrastruttura. Utilizzato da un oggetto Regex generato dal metodo CompileToAssembly.
Campo protettofactoryInfrastruttura. Utilizzato da un oggetto Regex generato dal metodo CompileToAssembly.
Campo pubblicoMembro staticoSupportato in .NET per applicazioni Windows StoreInfiniteMatchTimeoutSpecifica che per un'operazione di criteri di ricerca non deve essere previsto un timeout.
Campo protettointernalMatchTimeoutInfrastruttura. Il tempo massimo che può trascorrere in un'operazione di criteri di ricerca prima dell'operazione di timeout.
Campo protettoSupportato da XNA FrameworkpatternInfrastruttura. Utilizzato da un oggetto Regex generato dal metodo CompileToAssembly.
Campo protettoSupportato da XNA FrameworkroptionsInfrastruttura. Utilizzato da un oggetto Regex generato dal metodo CompileToAssembly.
In alto

  NomeDescrizione
Implementazione esplicita dell'interfacciaMetodo privatoISerializable.GetObjectDataInfrastruttura. Compila un oggetto SerializationInfo con i dati necessari per deserializzare l'oggetto Regex corrente.
In alto

La classe Regex rappresenta il motore delle espressioni regolari di .NET Framework. Può essere utilizzato per analizzare rapidamente grandi quantità di testo per individuare modelli specifici del carattere; , per estrarre, modificare, sostituire o eliminare sottostringhe di testo; e per aggiungere le stringhe estratte a una raccolta per generare un rapporto.

NotaNota

Se l'interesse primario è convalidare una stringa determinandone la conformità a un particolare modello, è possibile utilizzare la classe System.Configuration.RegexStringValidator.

Per utilizzare espressioni regolari, si definisce il modello che si desidera identificare in un flusso di testo utilizzando la sintassi documentata in Linguaggio di espressioni regolari - Riferimento rapido. Successivamente, è possibile facoltativamente creare un'istanza di un oggetto Regex. Infine, chiamare un metodo che esegue una determinata operazione, come la sostituzione di testo che corrisponde al modello di espressione regolare, o ID di corrispondenza dei modelli.

Confronto fra metodi regex e metodi per la gestione delle stringhe

La classe System.String include numerosi metodi di ricerca e confronto che è possibile utilizzare per eseguire corrispondenze di modelli con testo. Ad esempio, i metodi String.Contains, String.EndsWith e String.StartsWith determinano se un'istanza di stringa contiene una sottostringa specificata; i metodi String.IndexOf, String.IndexOfAny, String.LastIndexOf e String.LastIndexOfAny restituiscono la posizione iniziale di una sottostringa specificata in una stringa. Utilizzare i metodi della classe System.String quando occorre cercare una stringa specifica. Utilizzare la classe Regex per cercare un modello specifico in una stringa. Per ulteriori informazioni ed esempi, vedere Espressioni regolari di .NET Framework.

Torna a Osservazioni

Confronto tra metodi statici e metodi di istanza

Dopo avere definito un modello di espressione regolare, immetterla al motore delle espressioni regolari in due modi:

  • Creando un'istanza di un oggetto Regex che rappresenta l'espressione regolare. A tal proposito, occorre passare il modello di espressione regolare a un costruttore Regex. Un oggetto Regex non è modificabile; quando si crea un'istanza di un oggetto Regex con un'espressione regolare, l'espressione regolare di quel oggetto non può essere modificata.

  • Fornendo sia l'espressione regolare che il testo da cercare a un metodo static (Shared in Visual Basic) Regex. In questo modo, è possibile utilizzare un'espressione regolare senza creare esplicitamente un oggetto Regex.

Tutti i metodi di identificazione di modelli Regex includono sia overload statici che di istanza.

Il motore delle espressioni regolari deve compilare un particolare modello prima di poterlo utilizzare. Poiché gli oggetti Regex non sono modificabili, questa è una procedura unica che viene eseguita quando viene chiamato un metodo statico o un costruttore della classe Regex. Per eliminare la necessità di compilare ripetutamente una singola espressione regolare, il motore delle espressioni regolari consente di memorizzare nella cache le espressioni regolari compilate utilizzate in chiamate a metodi statici. Di conseguenza, i metodi di corrispondenza di modelli delle espressioni regolari offrono prestazioni paragonabili per i metodi statici e quelli di istanza.

Nota importanteImportante

Nelle versioni 1.0 e 1.1 di .NET Framework, tutte le espressioni regolari compilate, utilizzate nelle chiamate sia a metodi statici che di istanza, venivano memorizzate nella cache. A partire da .NET Framework 2.0 vengono memorizzate nella cache solo le espressioni regolari utilizzate nelle chiamate al metodo statico.

Tuttavia, la memorizzazione nella cache può influire negativamente sulle prestazioni nei due seguenti casi:

  • Quando si utilizzano chiamate a metodi statici con un gran numero di espressioni regolari. Per impostazione predefinita, il motore delle espressioni regolari memorizza nella cache le 15 espressioni regolari statiche utilizzate più di recente. Se l'applicazione in uso utilizza più di 15 espressioni regolari statiche, alcune espressioni regolari devono essere compilate di nuovo. Per evitare questo ricompilazione, è possibile aumentare la proprietà Regex.CacheSize.

  • Quando viene creata un'istanza Regex nuovo oggetto con le espressioni regolari che erano state compilate. Ad esempio, il codice riportato di seguito viene definita un'espressione regolare per individuare le parole duplicate in un flusso di testo. Sebbene nell'esempio venga utilizzata una singola espressione regolare, viene creata l'istanza di un nuovo oggetto Regex per elaborare ciascuna riga di testo. Il risultato è la ricompilazione dell'espressione regolare con ciascuna iterazione del ciclo.

    
    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();   
    
    
    

    Per impedire la ricompilazione, è necessario creare un'istanza di un singolo oggetto Regex accessibile al codice che lo richiede, come illustrato nell'esempio riscritto.

    
    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
    
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();   
    
    
    

Torna a Osservazioni

Esecuzione di operazioni relative a espressioni regolari

Che si decida di creare un'istanza di un oggetto Regex e chiamarne i metodi o di chiamare i metodi statici, la classe Regex offre le seguenti funzionalità di corrispondenza di modelli:

  • Convalida di una corrispondenza. Il metodo IsMatch consente di determinare se è presente una corrispondenza.

  • Recupero di una singola corrispondenza. Il metodo Match consente di recuperare un oggetto Match che rappresenta la prima corrispondenza in una stringa o in una parte di stringa. Le corrispondenze successive possono essere recuperate chiamando il metodo Match.NextMatch.

  • Recupero di tutte le corrispondenze. Il metodo Matches viene chiamato per recuperare un oggetto System.Text.RegularExpressions.MatchCollection che rappresenta tutte le corrispondenze trovate in una stringa o in una parte di stringa.

  • Sostituzione di testo corrispondente. Il metodo Replace può essere chiamato per sostituire testo corrispondente. Il testo di sostituzione può essere definito anche da un'espressione regolare. Inoltre, alcuni dei metodi Replace includono un parametro MatchEvaluator che consente di definire a livello di codice il testo di sostituzione.

  • Creazione di una matrice di stringhe che è formata da parti di una stringa di input. Il metodo Split viene chiamato per dividere una stringa di input in corrispondenza di posizioni che sono definite dall'espressione regolare.

Oltre a questi metodi di corrispondenza di modelli, la classe Regex include numerosi metodi finalizzati a scopi precisi:

  • Il metodo Escape effettua l'escape di caratteri che possono essere interpretati come operatori di espressioni regolari in un'espressione regolare o in una stringa di input.

  • Il metodo Unescape consente di rimuovere questi caratteri di escape.

  • Il metodo CompileToAssembly crea un assembly che contiene espressioni regolari predefinite. .NET Framework contiene esempi di questi assembly per usi specifici nello spazio dei nomi System.Web.RegularExpressions.

Torna a Osservazioni

Definizione del valore di timeout

.NET Framework supporta un linguaggio delle espressioni regolari completo che fornisce la potenza e flessibilità sostanziali nei criteri di ricerca. Tuttavia, la potenza e flessibilità presentano anche alcuni svantaggi: il rischio delle prestazioni. Le espressioni regolari che esegue erroneamente sorprendente sono facili da creare. In alcuni casi, le operazioni di espressione regolare che si basano su eccessivo del backtracking può sembrare non rispondere quando elaborano il testo che corrisponde quasi al modello di espressione regolare. Per ulteriori informazioni sul motore delle espressioni regolari di .NET Framework, vedere Dettagli sul funzionamento delle espressioni regolari. Per ulteriori informazioni su eccessivo del backtracking, vedere Backtracking.

A partire da .NET Framework 4.5, è possibile definire un intervallo di timeout per le corrispondenze di espressione regolare. Se il motore delle espressioni regolari non può identificare una corrispondenza all'interno di questo intervallo di tempo, l'operazione corrispondente genera un'eccezione RegexMatchTimeoutException. Nella maggior parte dei casi, si impedisce al motore delle espressioni regolari da spreco della potenza di elaborazione tenta di trovare una corrispondenza con il testo che corrisponde quasi al modello di espressione regolare. Potrebbe anche indicare, tuttavia, che l'intervallo di timeout è stato impostato troppo basso, o al caricamento del computer corrente può causare una riduzione delle prestazioni.

Come gestire l'eccezione dipende dalla causa di un'eccezione. Se l'eccezione si verifica poiché l'intervallo di timeout viene impostato troppo basso o a causa del sovraccarico di caricamento del computer, è possibile aumentare l'intervallo di timeout e ritentare l'operazione corrispondente. Se l'eccezione si verifica perché l'espressione regolare si basa su eccessivo del backtracking, è possibile presupporre che una corrispondenza non esiste e, facoltativamente, è possibile registrare informazioni utili per modificare il modello di espressione regolare.

È possibile impostare un intervallo di timeout chiamando il costruttore Regex(String, RegexOptions, TimeSpan) quando viene creata un'istanza di un oggetto di espressione regolare. Per i metodi statici, è possibile impostare un intervallo di timeout chiamando un overload di un metodo corrispondente con un parametro matchTimeout. Se non si imposta un valore di timeout in modo esplicito, il valore di timeout predefinito è determinato come segue:

  • L'utilizzo dell'applicazione un valore di timeout, se presente. Può trattarsi di qualsiasi valore di timeout applicato al dominio applicazione in cui l'oggetto Regex viene creata un'istanza o la chiamata al metodo statico viene eseguita. È possibile impostare il livello del valore di timeout chiamando il metodo AppDomain.SetData per assegnare la rappresentazione di stringa di un valore TimeSpan alla proprietà "di REGEX_DEFAULT_MATCH_TIMEOUT".

  • Utilizzando il valore InfiniteMatchTimeout, se non esplicitamente un valore di timeout è stato impostato.

Nota importanteImportante

Si consiglia di impostare un valore di timeout in tutte le operazioni di criteri di ricerca di espressioni regolari. Per ulteriori informazioni, vedere Procedure consigliate per le espressioni regolari in .NET Framework.

Torna a Osservazioni

Nell'esempio di codice riportato di seguito viene illustrato l'utilizzo di un'espressione regolare per individuare eventuali occorrenze di parole ripetute in una stringa. L'espressione regolare \b(?<word>\w+)\s+(\k<word>)\b può essere interpretata come indicato nella tabella che segue.

Modello

Descrizione

\b

Inizia la corrispondenza al confine di una parola.

(?<word>\w+)

Ricerca la corrispondenza di uno o più caratteri della parola fino al confine della parola. Assegna il nome word al gruppo acquisito.

\s+

Ricerca la corrispondenza di uno o più caratteri spazio vuoto.

(\k<word>)

Ricerca la corrispondenza del gruppo acquisito denominato word.

\b

Trovare la corrispondenza di un confine di parola.


using System;
using System.Text.RegularExpressions;

public class Test
{

    public static void Main ()
    {

        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.        
        string text = "The the quick brown fox  fox jumped over the lazy dog dog.";

        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}", 
                          matches.Count, 
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",  
                              groups["word"].Value, 
                              groups[0].Index, 
                              groups[1].Index);
        }

    }
	
}
// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumped over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54


Nell'esempio di codice riportato di seguito viene illustrato come utilizzare un'espressione regolare per verificare se una stringa rappresenta un valore di valuta o dispone del formato corretto per rappresentare un valore di valuta. In questo caso, l'espressione regolare viene compilata in modo dinamico dalle proprietà NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign e NumberFormatInfo.PositiveSign per le impostazioni cultura correnti dell'utente. Se le impostazioni cultura correnti del sistema sono en-US, l'espressione regolare risultante è ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Questa espressione regolare può essere interpretata come indicato nella tabella che segue.

Modello

Descrizione

^

Inizia all'inizio della stringa.

\s*

Trovare la corrispondenza di zero o più spazi vuoti.

[\+-]?

Ricerca la corrispondenza di zero o di una occorrenza del segno positivo o del segno negativo.

\s?

Trova la corrispondenza di uno o nessuno spazio vuoto.

\$?

Ricerca la corrispondenza di zero o di una occorrenza del simbolo del dollaro.

\s?

Trova la corrispondenza di uno o nessuno spazio vuoto.

\d*

Ricerca la corrispondenza di zero o di più cifre decimali.

\.?

Ricerca la corrispondenza di zero o di un simbolo di separatore decimale.

\d{2}?

Ricerca la corrispondenza di due cifre decimali zero volte o una volta.

(\d*\.?\d{2}?){1}

Ricerca la corrispondenza di un modello di cifre frazionarie e integrali separate da un simbolo di separatore decimale almeno una volta.

$

Ricerca la corrispondenza della fine della stringa.

In questo caso, l'espressione regolare presuppone che una stringa di valuta valida non contenga simboli di separatore di gruppo e che nella stringa non vi siano cifre frazionarie o che vi sia il numero di cifre frazionarie definito dalla proprietà CurrencyDecimalDigits delle impostazioni cultura correnti.


using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get the current NumberFormatInfo object to build the regular 
      // expression pattern dynamically.
      NumberFormatInfo nfi = NumberFormatInfo.CurrentInfo;

      // Define the regular expression pattern.
      string pattern; 
      pattern = @"^\s*[";
      // Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + @"]?\s?";
      // Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + @"?\s?";
      // Add integral digits to the pattern.
      pattern += @"(\d*";
      // Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?";
      // Add the fractional digits.
      pattern += @"\d{";
      // Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "}?){1}$";

      Regex rgx = new Regex(pattern);

      // Define some test strings.
      string[] tests = { "-42", "19.99", "0.001", "100 USD", 
                         ".34", "0.34", "1,052.21", "$10.62", 
                         "+1.43", "-$0.23" };

      // Check each test string against the regular expression.
      foreach (string test in tests)
      {
         if (rgx.IsMatch(test))
            Console.WriteLine("{0} is a currency value.", test);
         else
            Console.WriteLine("{0} is not a currency value.", test);
      }
   }
}
// The example displays the following output:
//       -42 is a currency value.
//       19.99 is a currency value.
//       0.001 is not a currency value.
//       100 USD is not a currency value.
//       .34 is a currency value.
//       0.34 is a currency value.
//       1,052.21 is not a currency value.
//       $10.62 is a currency value.
//       +1.43 is a currency value.
//       -$0.23 is a currency value.


Poiché l'espressione regolare nell'esempio è compilata in modo dinamico, non si può sapere in fase di progettazione se il simbolo di valuta, il separatore decimale e i segni negativi delle impostazioni cultura correnti possono essere erroneamente interpretati dal motore delle espressioni regolari come operatori del linguaggio delle espressioni regolari. Per evitare il problema, nell'esempio ciascuna stringa generata in modo dinamico viene passata al metodo Escape.

.NET Framework

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Libreria di classi portabile

Supportato in: Libreria di classi portabile

.NET per applicazioni Windows Store

Supportato in: Windows 8

.NET per applicazioni Windows Phone

Supportato in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

La classe Regex è thread-safe e non modificabile (in sola lettura). Gli oggetti Regex possono essere creati in qualsiasi thread e condivisi tra thread. Per ulteriori informazioni, vedere Protezione dei thread.

Aggiunte alla community

AGGIUNGI
Microsoft sta conducendo un sondaggio in linea per comprendere l'opinione degli utenti in merito al sito Web di MSDN. Se si sceglie di partecipare, quando si lascia il sito Web di MSDN verrà visualizzato il sondaggio in linea.

Si desidera partecipare?
Mostra:
© 2014 Microsoft