RegexOptions Enumeração

Referência

Definição

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Fornece valores enumerados para definir opções de expressão regular.

Essa enumeração dá suporte a uma combinação bit a bit dos valores de membro.

public enum class RegexOptions

[System.Flags]
public enum RegexOptions

[<System.Flags>]
type RegexOptions =

Public Enum RegexOptions

Herança: Object

ValueType

Enum
RegexOptions

Atributos: FlagsAttribute

Campos

Compiled	8	Especifica que a expressão regular é compilada no código MSIL, em vez de ser interpretada. Expressões regulares compiladas maximizam o desempenho do tempo de execução às custas do tempo de inicialização. Esse valor não deve ser atribuído à propriedade Options ao chamar o método CompileToAssembly(RegexCompilationInfo[], AssemblyName). Para obter mais informações, consulte a seção "Expressões Regulares Compiladas" no artigo Opções de Expressão Regular .
CultureInvariant	512	Especifica que as diferenças culturais no idioma serão ignoradas. Para obter mais informações, consulte a seção "Comparação usando a cultura invariável" no artigo Opções de Expressão Regular .
ECMAScript	256	Habilita o comportamento em conformidad com ECMAScript para a expressão. Esse valor pode ser usado somente em conjunto com os valores IgnoreCase, Multiline e Compiled. O uso deste valor com qualquer outro valor resulta em uma exceção. Para obter mais informações sobre a opção ECMAScript , consulte a seção "Comportamento de Correspondência ECMAScript" no artigo Opções de Expressão Regular .
ExplicitCapture	4	Especifica que as únicas capturas válidas são grupos explicitamente nomeados ou numerados do formulário (?< name>...). Isso permite que parênteses sem nome atuem como grupos não paisagísticos sem a desajeitada sintactica da expressão (?:...). Para obter mais informações, consulte a seção "Somente Capturas Explícitas" no artigo Opções de Expressão Regular .
IgnoreCase	1	Especifica a correspondência sem diferenciação de maiúsculas e minúsculas. Para obter mais informações, consulte a seção "Correspondência sem diferenciação de maiúsculas de minúsculas" no artigo Opções de Expressão Regular .
IgnorePatternWhitespace	32	Elimina um espaço em branco sem escape do padrão e habilita comentários marcados por #. No entanto, esse valor não afeta nem elimina espaços em branco em classes de caracteres, em quantificadores numéricos nem em tokens que marcam o início dos elementos de idioma de expressão regular individuais. Saiba mais na seção "Ignorar espaço em branco" do artigo Opções de expressão regular.
Multiline	2	Modo multilinha. Altera o significado de ^ e $ de modo que eles correspondam ao início e ao final, respectivamente, de qualquer linha, e não apenas ao início e ao final da cadeia de caracteres inteira. Para obter mais informações, consulte a seção "Modo Multilinha" no artigo Opções de Expressão Regular .
NonBacktracking	1024	Habilitar a correspondência usando uma abordagem que evita o retrocesso e garante o processamento de tempo linear no comprimento da entrada.
None	0	Especifica que nenhuma opção será definida. Para obter mais informações sobre o comportamento padrão do mecanismo de expressão regular, consulte a seção "Opções Padrão" no artigo Opções de Expressão Regular .
RightToLeft	64	Especifica que a pesquisa se moverá da direita para a esquerda, em vez de se mover da esquerda para a direita. Para obter mais informações, consulte a seção "Modo da direita para a esquerda" no artigo Opções de Expressão Regular .
Singleline	16	Especifica o modo de linha única. Altera o significado do ponto (.) para que coincida com cada caractere (em vez de cada caractere exceto \n). Para obter mais informações, consulte a seção "Modo de linha única" no artigo Opções de Expressão Regular .

Exemplos

O exemplo a seguir define duas expressões regulares que identificam palavras repetidas no texto, mas que são instanciadas usando valores diferentes RegexOptions . A primeira expressão regular não diferencia maiúsculas de minúsculas; o caso é ignorado ao determinar se uma palavra é idêntica à palavra anterior. A segunda expressão regular diferencia maiúsculas de minúsculas; uma palavra deve corresponder ao caso da palavra anterior exatamente para ser considerada uma duplicata.

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

Comentários

Um RegexOptions valor pode ser fornecido como um parâmetro para os seguintes membros da Regex classe:

O Regex.Regex(String, RegexOptions) construtor de classe.
O método Regex.Split(String, String, RegexOptions).
O método Regex.IsMatch(String, String, RegexOptions).
O método Regex.Match(String, String, RegexOptions).
O método Regex.Matches(String, String, RegexOptions).
Os métodos Regex.Replace(String, String, String, RegexOptions) e Regex.Replace(String, String, MatchEvaluator, RegexOptions).

Um RegexOptions valor também pode ser fornecido como um parâmetro para o RegexCompilationInfo construtor ou pode ser atribuído diretamente à RegexCompilationInfo.Options propriedade. O objeto resultante RegexCompilationInfo é usado na chamada para o Regex.CompileToAssembly método.

Várias opções fornecidas por membros da RegexOptions enumeração (em particular, por seus ExplicitCapturemembros IgnoreCase, por ele Multilinee Singleline membros) podem ser fornecidas usando um caractere de opção embutido no padrão de expressão regular. Para obter detalhes, consulte Opções de Expressão Regular.

Aplica-se a