RegexOptions Enumeración

Referencia

Definición

Espacio de nombres:: System.Text.RegularExpressions

Ensamblado:: System.Text.RegularExpressions.dll

Ensamblado:: System.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Proporciona valores enumerados que se pueden utilizar para establecer las opciones de expresión regular.

Esta enumeración admite una combinación bit a bit de sus valores de miembro.

public enum class RegexOptions

[System.Flags]
public enum RegexOptions

[<System.Flags>]
type RegexOptions =

Public Enum RegexOptions

Herencia: Object

ValueType

Enum
RegexOptions

Atributos: FlagsAttribute

Campos

Compiled	8	Especifica que la expresión regular se compila en código MSIL, en lugar de interpretarse. Las expresiones regulares compiladas maximizan el rendimiento en tiempo de ejecución a costa del tiempo de inicialización. Este valor no debe asignarse a la propiedad Options al llamar al método CompileToAssembly(RegexCompilationInfo[], AssemblyName). Para obtener más información, vea la sección "Expresiones regulares compiladas" que encontrará en el artículo Opciones de expresiones regulares.
CultureInvariant	512	Especifica que las diferencias culturales de idioma se pasan por alto. Para obtener más información, vea la sección "Comparación con la referencia cultural de todos los idiomas" que encontrará en el artículo Opciones de expresiones regulares.
ECMAScript	256	Habilita el comportamiento conforme a ECMAScript para esta expresión. Este valor sólo se puede utilizar junto con los valores IgnoreCase, Multiline y Compiled. El uso de este valor con otros valores dará como resultado una excepción. Para obtener más información sobre la opción ECMAScript, vea la sección "Comportamiento de búsqueda de coincidencias de ECMAScript" que encontrará en el artículo Opciones de expresiones regulares.
ExplicitCapture	4	Especifica que las únicas capturas válidas son grupos denominados o numerados explícitamente con la forma (?<nombre>…). Esto permite que los paréntesis sin nombre actúen como grupos sin captura sin la torpeza sintáctica de la expresión (?:…). Para obtener más información, vea la sección "Solo capturas explícitas" que encontrará en el artículo Opciones de expresiones regulares.
IgnoreCase	1	Especifica la coincidencia con distinción entre mayúsculas y minúsculas. Para obtener más información, vea la sección "Coincidencia sin distinción entre mayúsculas y minúsculas" que encontrará en el artículo Opciones de expresiones regulares.
IgnorePatternWhitespace	32	Elimina el espacio en blanco sin escape del patrón y habilita los comentarios marcados con #. Sin embargo, este valor no afecta ni elimina el espacio en blanco en clases de caracteres, en cuantificadores numéricos ni en tokens que marquen el inicio de elementos de lenguaje de expresiones regulares individuales. Para más información, vea la sección "Ignorar el espacio en blanco" del artículo Opciones de expresiones regulares.
Multiline	2	Modo multilínea. Cambia el significado de ^ y $ de manera que coincidan al principio y al final, respectivamente, de cada línea y no justo al principio y al final de toda la cadena. Para obtener más información, vea la sección "Modo multilínea" que encontrará en el artículo Opciones de expresiones regulares.
NonBacktracking	1024	Habilite la coincidencia mediante un enfoque que evite el retroceso y garantice el procesamiento en tiempo lineal en la longitud de la entrada.
None	0	Especifica que no hay opciones establecidas. Para obtener más información sobre el comportamiento predeterminado del motor de expresiones regulares, vea la sección "Opciones predeterminadas" que encontrará en el artículo Opciones de expresiones regulares.
RightToLeft	64	Especifica que la búsqueda será de derecha a izquierda en lugar de izquierda a derecha. Para obtener más información, vea la sección "Modo de derecha a izquierda" que encontrará en el artículo Opciones de expresiones regulares.
Singleline	16	Especifica el modo de una sola línea. Cambia el significado del punto (.) de manera que coincida con todos los caracteres (en lugar de hacerlo con todos los caracteres excepto con \n). Para obtener más información, vea la sección "Modo de una sola línea" que encontrará en el artículo Opciones de expresiones regulares.

Ejemplos

En el ejemplo siguiente se definen dos expresiones regulares que identifican palabras repetidas en el texto, pero que se crean instancias mediante valores diferentes RegexOptions . La primera expresión regular no distingue mayúsculas de minúsculas; El caso se omite al determinar si una palabra es idéntica a la palabra anterior. La segunda expresión regular distingue mayúsculas de minúsculas; una palabra debe coincidir exactamente con el caso de la palabra anterior para considerarse duplicado.

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

Comentarios

Se RegexOptions puede proporcionar un valor como parámetro a los siguientes miembros de la Regex clase :

Constructor de Regex.Regex(String, RegexOptions) clase.
El método Regex.Split(String, String, RegexOptions) .
El método Regex.IsMatch(String, String, RegexOptions) .
El método Regex.Match(String, String, RegexOptions) .
El método Regex.Matches(String, String, RegexOptions) .
Los métodos Regex.Replace(String, String, String, RegexOptions) y Regex.Replace(String, String, MatchEvaluator, RegexOptions).

También RegexOptions se puede proporcionar un valor como parámetro al RegexCompilationInfo constructor, o bien se puede asignar directamente a la RegexCompilationInfo.Options propiedad . A continuación, el objeto resultante RegexCompilationInfo se usa en la llamada al Regex.CompileToAssembly método .

En su lugar, se pueden proporcionar varias opciones proporcionadas por los miembros de la RegexOptions enumeración (en particular, por sus ExplicitCapturemiembros , IgnoreCaseMultiline, y Singleline ) mediante un carácter de opción insertado en el patrón de expresión regular. Para obtener más información, consulte Opciones de expresiones regulares.

Se aplica a

Compartir a través de