RegexOptions Enumerazione

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.

Fornisce valori enumerati da usare per impostare le opzioni delle espressioni regolari.

Questa enumerazione supporta una combinazione bit per bit dei rispettivi valori dei membri.

public enum class RegexOptions

[System.Flags]
public enum RegexOptions

[<System.Flags>]
type RegexOptions =

Public Enum RegexOptions

Ereditarietà: Object

ValueType

Enum
RegexOptions

Attributi: FlagsAttribute

Campi

Compiled	8	Specifica che l'espressione regolare viene compilata nel codice MSIL anziché essere interpretata. Le espressioni regolari compilate massimizzano le prestazioni in fase di esecuzione a scapito del tempo di inizializzazione. Questo valore non deve essere assegnato alla proprietà Options quando viene chiamato il metodo CompileToAssembly(RegexCompilationInfo[], AssemblyName). Per altre informazioni, vedere la sezione "Espressioni regolari compilate" nell'articolo Opzioni di espressioni regolari .
CultureInvariant	512	Specifica che le differenze culturali della lingua vengono ignorate. Per altre informazioni, vedere la sezione "Confronto con le impostazioni cultura invarianti" nell'articolo Opzioni di espressioni regolari .
ECMAScript	256	Consente un comportamento conforme a ECMAScript per l'espressione. Questo valore può essere utilizzato soltanto in combinazione con i valori IgnoreCase, Multiline e Compiled. L'uso di questo valore con qualsiasi altro valore determina un'eccezione. Per altre informazioni sull'opzione ECMAScript , vedere la sezione "Comportamento di corrispondenza ECMAScript" nell'articolo Opzioni di espressioni regolari .
ExplicitCapture	4	Specifica che le uniche acquisizioni valide sono denominate in modo esplicito o gruppi numerati del modulo (?< nome>...). Ciò consente alle parentesi senza nome di agire come gruppi non incapturi senza la goffa sintattica dell'espressione (?:...). Per altre informazioni, vedere la sezione "Solo acquisizioni esplicite" nell'articolo Opzioni di espressioni regolari .
IgnoreCase	1	Specifica una corrispondenza senza distinzione tra maiuscole e minuscole. Per altre informazioni, vedere la sezione "Corrispondenza senza distinzione tra maiuscole e minuscole" nell'articolo Opzioni di espressioni regolari .
IgnorePatternWhitespace	32	Elimina uno spazio vuoto non preceduto da un carattere di escape dal criterio e consente i commenti contrassegnati da #. Tuttavia, questo valore non influisce né elimina gli spazi in classi di caratteri, quantificatori numerici o token che contrassegnano l'inizio di singoli elementi del linguaggio di espressioni regolari. Per altre informazioni, vedere la sezione "Ignora spazi vuoti" nell'articolo Opzioni di espressioni regolari.
Multiline	2	Modalità multiriga. Modifica il significato dei simboli ^ e $ in modo che corrispondano rispettivamente all'inizio e alla fine di qualsiasi riga e non solo dell'intera stringa. Per altre informazioni, vedere la sezione "Modalità multilinea" nell'articolo Opzioni di espressioni regolari .
NonBacktracking	1024	Abilitare la corrispondenza usando un approccio che evita il backtracking e garantisce l'elaborazione in tempo lineare nella lunghezza dell'input.
None	0	Specifica che non sono state impostate opzioni. Per altre informazioni sul comportamento predefinito del motore delle espressioni regolari, vedere la sezione "Opzioni predefinite" nell'articolo Opzioni di espressioni regolari .
RightToLeft	64	Specifica che la ricerca verrà eseguita da destra a sinistra anziché da sinistra a destra. Per altre informazioni, vedere la sezione "Modalità da destra a sinistra" nell'articolo Opzioni espressioni regolari .
Singleline	16	Specifica la modalità a riga singola. Modifica il significato del punto (.) in modo che corrisponda a ogni carattere (anziché a ogni carattere eccetto \n). Per altre informazioni, vedere la sezione "Modalità a riga singola" nell'articolo Opzioni di espressioni regolari .

Esempio

Nell'esempio seguente vengono definite due espressioni regolari che identificano parole ripetute nel testo, ma che vengono create istanze usando valori diversi RegexOptions . La prima espressione regolare non fa distinzione tra maiuscole e minuscole; la distinzione tra maiuscole e minuscole viene ignorata quando si determina se una parola è identica alla parola precedente. La seconda espressione regolare fa distinzione tra maiuscole e minuscole; una parola deve corrispondere esattamente al caso della parola precedente per essere considerata un duplicato.

using System;
using System.Text.RegularExpressions;

public class Test
{
    public static void Main ()
    {
        // Define a case-insensitive regular expression for repeated words.
        Regex rxInsensitive = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);
        // Define a case-sensitive regular expression for repeated words.
        Regex rxSensitive = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled);

        // Define a test string.        
        string text = "The the quick brown fox  fox jumps over the lazy dog dog.";
        
        // Find matches using case-insensitive regular expression.
        MatchCollection matches = rxInsensitive.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);
        }
        Console.WriteLine();
        
        // Find matches using case-sensitive regular expression.
        matches = rxSensitive.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 jumps 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
//       
//       2 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54

Imports System.Text.RegularExpressions

Public Module Test

    Public Sub Main()
        ' Define a case-insensitive regular expression for repeated words.
        Dim rxInsensitive As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)
        ' Define a case-sensitive regular expression for repeated words.
        Dim rxSensitive As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches using case-insensitive regular expression.
        Dim matches As MatchCollection = rxInsensitive.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
        Console.WriteLine()
        
        ' Find matches using case-sensitive regular expression.
        matches = rxSensitive.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
        Console.WriteLine()
    End Sub
End Module
' The example produces the following output to the console:
'       3 matches found in:
'          The the quick brown fox  fox jumps 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
'       
'       2 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 50 and 54

Commenti

Un RegexOptions valore può essere fornito come parametro ai membri seguenti della Regex classe :

Costruttore della Regex.Regex(String, RegexOptions) classe.
Metodo Regex.Split(String, String, RegexOptions) .
Metodo Regex.IsMatch(String, String, RegexOptions) .
Metodo Regex.Match(String, String, RegexOptions) .
Metodo Regex.Matches(String, String, RegexOptions) .
Metodi Regex.Replace(String, String, String, RegexOptions) e Regex.Replace(String, String, MatchEvaluator, RegexOptions).

Un RegexOptions valore può anche essere fornito come parametro al RegexCompilationInfo costruttore oppure può essere assegnato direttamente alla RegexCompilationInfo.Options proprietà . L'oggetto risultante RegexCompilationInfo viene quindi utilizzato nella chiamata al Regex.CompileToAssembly metodo .

Diverse opzioni fornite dai membri dell'enumerazione RegexOptions (in particolare, dai relativi ExplicitCapturemembri , , IgnoreCaseMultilinee Singleline ) possono essere fornite usando un carattere di opzione inline nel criterio di espressione regolare. Per informazioni dettagliate, vedere Opzioni di espressione regolare.

Si applica a

RegexOptions Enumerazione

Definizione

Campi

Esempio

Commenti

Si applica a

Vedi anche

Commenti e suggerimenti

Risorse aggiuntive