RegexOptions RegexOptions RegexOptions RegexOptions Enum

Definizione

Fornisce valori enumerati da utilizzare per impostare le opzioni delle espressioni regolari.Provides enumerated values to use to set regular expression options.

Questa enumerazione ha un attributo FlagsAttribute che consente una combinazione bit per bit dei valori del relativo membro.

public enum class RegexOptions
[System.Flags]
public enum RegexOptions
type RegexOptions = 
Public Enum RegexOptions
Ereditarietà
Attributi

Campi

Compiled Compiled Compiled Compiled 8

Specifica che l'espressione regolare è compilata in un assembly.Specifies that the regular expression is compiled to an assembly. Questa situazione determina un'esecuzione più rapida ma aumenta i tempi di avvio.This yields faster execution but increases startup time. Questo valore non deve essere assegnato alla proprietà Options quando viene chiamato il metodo CompileToAssembly(RegexCompilationInfo[], AssemblyName).This value should not be assigned to the Options property when calling the CompileToAssembly(RegexCompilationInfo[], AssemblyName) method. Per altre informazioni, vedere la sezione "Espressioni regolari compilate" nell'argomento Opzioni di espressioni regolari.For more information, see the "Compiled Regular Expressions" section in the Regular Expression Options topic.

CultureInvariant CultureInvariant CultureInvariant CultureInvariant 512

Specifica che le differenze culturali della lingua vengono ignorate.Specifies that cultural differences in language is ignored. Per altre informazioni, vedere la sezione "Confronto usando la lingua inglese" nell'argomento Opzioni di espressioni regolari.For more information, see the "Comparison Using the Invariant Culture" section in the Regular Expression Options topic.

ECMAScript ECMAScript ECMAScript ECMAScript 256

Consente un comportamento conforme a ECMAScript per l'espressione.Enables ECMAScript-compliant behavior for the expression. Questo valore può essere utilizzato soltanto in combinazione con i valori IgnoreCase, Multiline e Compiled.This value can be used only in conjunction with the IgnoreCase, Multiline, and Compiled values. L'utilizzo di questo valore con qualsiasi altro valore determina un'eccezione.The use of this value with any other values results in an exception.

Per altre informazioni sull'opzione ECMAScript, vedere la sezione "Comportamento di corrispondenza ECMAScript" nell'argomento Opzioni di espressioni regolari.For more information on the ECMAScript option, see the "ECMAScript Matching Behavior" section in the Regular Expression Options topic.

ExplicitCapture ExplicitCapture ExplicitCapture ExplicitCapture 4

Specifica che le uniche acquisizioni valide sono i gruppi denominati o numerati in modo esplicito in formato (?<nome>…). In questo modo, le parentesi non denominate possono fungere da gruppi di non acquisizione senza l'espressione (?:…) poco pratica dal punto di vista sintattico. Per altre informazioni, vedere la sezione "Solo acquisizioni esplicite" nell'argomento Opzioni di espressioni regolari.Specifies that the only valid captures are explicitly named or numbered groups of the form (?<name>...). This allows unnamed parentheses to act as noncapturing groups without the syntactic clumsiness of the expression (?:...). For more information, see the "Explicit Captures Only" section in the Regular Expression Options topic.

IgnoreCase IgnoreCase IgnoreCase IgnoreCase 1

Specifica una corrispondenza che non fa distinzione tra maiuscole e minuscole.Specifies case-insensitive matching. Per altre informazioni, vedere la sezione "Corrispondenza senza distinzione tra maiuscole e minuscole" nell'argomento Opzioni di espressioni regolari.For more information, see the "Case-Insensitive Matching " section in the Regular Expression Options topic.

IgnorePatternWhitespace IgnorePatternWhitespace IgnorePatternWhitespace IgnorePatternWhitespace 32

Elimina gli spazi vuoti non di escape dal criterio e consente i commenti contrassegnati da #.Eliminates unescaped white space from the pattern and enables comments marked with #. 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.However, this value does not affect or eliminate white space in character classes, numeric quantifiers, or tokens that mark the beginning of individual regular expression language elements. Per altre informazioni, vedere la sezione "Ignora spazi vuoti" nell'argomento Opzioni di espressioni regolari.For more information, see the "Ignore White Space" section of the Regular Expression Options topic.

Multiline Multiline Multiline Multiline 2

Modalità multiriga.Multiline mode. 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.Changes the meaning of ^ and $ so they match at the beginning and end, respectively, of any line, and not just the beginning and end of the entire string. Per altre informazioni, vedere la sezione "Modalità multiriga" nell'argomento Opzioni di espressioni regolari.For more information, see the "Multiline Mode" section in the Regular Expression Options topic.

None None None None 0

Specifica che non sono state impostate opzioni.Specifies that no options are set. Per altre informazioni sul comportamento predefinito del motore delle espressioni regolari, vedere la sezione "Opzioni predefinite" nell'argomento Opzioni di espressioni regolari.For more information about the default behavior of the regular expression engine, see the "Default Options" section in the Regular Expression Options topic.

RightToLeft RightToLeft RightToLeft RightToLeft 64

Specifica che la ricerca avverrà da destra a sinistra anziché da sinistra a destra.Specifies that the search will be from right to left instead of from left to right. Per altre informazioni, vedere la sezione "Modalità da destra a sinistra" nell'argomento Opzioni di espressioni regolari.For more information, see the "Right-to-Left Mode" section in the Regular Expression Options topic.

Singleline Singleline Singleline Singleline 16

Specifica la modalità a riga singola.Specifies single-line mode. Modifica il significato del punto (.) in modo che corrisponda a ogni carattere (anziché a ogni carattere eccetto \n).Changes the meaning of the dot (.) so it matches every character (instead of every character except \n). Per altre informazioni, vedere la sezione "Modalità a riga singola" nell'argomento Opzioni di espressioni regolari.For more information, see the "Single-line Mode" section in the Regular Expression Options topic.

Esempi

L'esempio seguente definisce due espressioni regolari che identificano le parole ripetute in formato testo, ma che vengono create istanze mediante diverse RegexOptions.ExplicitCapture valori.The following example defines two regular expressions that identify repeated words in text but that are instantiated using different RegexOptions.ExplicitCapture values. La prima espressione regolare è tra maiuscole e minuscole; maiuscole e minuscole quando si determina se una parola è identica alla parola precedente.The first regular expression is case-insensitive; case is ignored when determining whether a word is identical to the preceding word. La seconda espressione regolare è tra maiuscole e minuscole; una parola deve corrispondere alla combinazione della parola precedente esattamente per essere considerato un duplicato.The second regular expression is case-sensitive; a word must match the case of the preceding word exactly to be considered a duplicate.

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

Oggetto RegexOptions valore può essere fornito come parametro per i membri del seguenti il Regex classe:A RegexOptions value can be provided as a parameter to the following members of the Regex class:

Oggetto RegexOptions può anche essere passata come parametro per il RegexCompilationInfo costruttore oppure può essere assegnata direttamente al Options proprietà.A RegexOptions value can also be supplied as a parameter to the RegexCompilationInfo constructor, or it can be assigned directly to the Options property. L'oggetto risultante RegexCompilationInfo oggetto viene quindi usato nella chiamata al CompileToAssembly (metodo).The resulting RegexCompilationInfo object is then used in the call to the CompileToAssembly method.

Molte opzioni fornite dai membri del RegexOptions enumerazione (in particolare, per i relativi membri ExplicitCapture, IgnoreCase, su più righe e a riga singola) può invece essere fornito con un carattere di opzione inline nel criterio di espressione regolare.Several options provided by members of the RegexOptions enumeration (in particular, by its ExplicitCapture, IgnoreCase, Multiline, and Singleline members) can instead be provided by using an inline option character in the regular expression pattern. Per informazioni dettagliate, vedere Regular Expression Options.For details, see Regular Expression Options.

Si applica a

Vedi anche