Partilhar via

RegexOptions Enumeração

  • Referência

Definição

Namespace:
System.Text.RegularExpressions
Assembly:
System.Text.RegularExpressions.dll
Assembly:
System.dll
Assembly:
netstandard.dll

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 para o 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 não nomeados atuem como grupos não pais 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

Habilite 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; case é 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:

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 . Em seguida, 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, Multilinee Singleline ) 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

Confira também