RegexOptions Enumeración

Definición

Proporciona valores enumerados que se pueden utilizar para establecer las opciones de expresión regular.Provides enumerated values to use to set regular expression options.

Esta enumeración tiene el atributo FlagsAttribute, que permite una combinación bit a bit de sus valores de miembro.

public enum class RegexOptions
[System.Flags]
public enum RegexOptions
public enum RegexOptions
type RegexOptions = 
Public Enum RegexOptions
Herencia
RegexOptions
Atributos

Campos

Compiled 8

Especifica que la expresión regular esté compilada en un ensamblado.Specifies that the regular expression is compiled to an assembly. Esto proporciona una ejecución más veloz pero incrementa el tiempo de inicio.This yields faster execution but increases startup time. Este valor no debe asignarse a la propiedad Options al llamar al método CompileToAssembly(RegexCompilationInfo[], AssemblyName).This value should not be assigned to the Options property when calling the CompileToAssembly(RegexCompilationInfo[], AssemblyName) method. Para obtener más información, vea la sección "Expresiones regulares compiladas" que encontrará en el artículo Opciones de expresiones regulares.For more information, see the "Compiled Regular Expressions" section in the Regular Expression Options article.

CultureInvariant 512

Especifica que las diferencias culturales de idioma se pasan por alto.Specifies that cultural differences in language is ignored. 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.For more information, see the "Comparison Using the Invariant Culture" section in the Regular Expression Options article.

ECMAScript 256

Habilita el comportamiento conforme a ECMAScript para esta expresión.Enables ECMAScript-compliant behavior for the expression. Este valor sólo se puede utilizar junto con los valores IgnoreCase, Multiline y Compiled.This value can be used only in conjunction with the IgnoreCase, Multiline, and Compiled values. El uso de este valor con otros valores dará como resultado una excepción.The use of this value with any other values results in an exception.

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.For more information on the ECMAScript option, see the "ECMAScript Matching Behavior" section in the Regular Expression Options article.

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.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 article.

IgnoreCase 1

Especifica la coincidencia con distinción entre mayúsculas y minúsculas.Specifies case-insensitive matching. 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.For more information, see the "Case-Insensitive Matching " section in the Regular Expression Options article.

IgnorePatternWhitespace 32

Elimina el espacio en blanco sin escape del patrón y habilita los comentarios marcados con #.Eliminates unescaped white space from the pattern and enables comments marked with #. 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.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. Para más información, vea la sección "Ignorar el espacio en blanco" del artículo Opciones de expresiones regulares.For more information, see the "Ignore White Space" section of the Regular Expression Options article.

Multiline 2

Modo multilínea.Multiline mode. 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.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. Para obtener más información, vea la sección "Modo multilínea" que encontrará en el artículo Opciones de expresiones regulares.For more information, see the "Multiline Mode" section in the Regular Expression Options article.

None 0

Especifica que no hay opciones establecidas.Specifies that no options are set. 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.For more information about the default behavior of the regular expression engine, see the "Default Options" section in the Regular Expression Options article.

RightToLeft 64

Especifica que la búsqueda será de derecha a izquierda en lugar de izquierda a derecha.Specifies that the search will be from right to left instead of from left to right. 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.For more information, see the "Right-to-Left Mode" section in the Regular Expression Options article.

Singleline 16

Especifica el modo de una sola línea.Specifies single-line mode. Cambia el significado del punto (.) de manera que coincida con todos los caracteres (en lugar de hacerlo con todos los caracteres excepto con \n).Changes the meaning of the dot (.) so it matches every character (instead of every character except \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.For more information, see the "Single-line Mode" section in the Regular Expression Options article.

Ejemplos

En el ejemplo siguiente se definen dos expresiones regulares que identifican palabras repetidas en texto pero de las que se crean instancias con distintos valores de RegexOptions.The following example defines two regular expressions that identify repeated words in text but that are instantiated using different RegexOptions values. 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.The first regular expression is case-insensitive; case is ignored when determining whether a word is identical to the preceding word. La segunda expresión regular distingue entre mayúsculas y minúsculas; una palabra debe coincidir exactamente con las mayúsculas y minúsculas de la palabra anterior para que se considere un duplicado.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

Comentarios

Se puede proporcionar un valor RegexOptions como parámetro a los siguientes miembros de la clase Regex:A RegexOptions value can be provided as a parameter to the following members of the Regex class:

También se puede proporcionar un valor RegexOptions como parámetro al constructor RegexCompilationInfo, o bien se puede asignar directamente a la propiedad RegexCompilationInfo.Options.A RegexOptions value can also be supplied as a parameter to the RegexCompilationInfo constructor, or it can be assigned directly to the RegexCompilationInfo.Options property. A continuación, se usa el objeto RegexCompilationInfo resultante en la llamada al método Regex.CompileToAssembly.The resulting RegexCompilationInfo object is then used in the call to the Regex.CompileToAssembly method.

En su lugar, se pueden proporcionar varias opciones proporcionadas por miembros de la enumeración RegexOptions (en particular, por sus miembros ExplicitCapture, IgnoreCase, Multiliney Singleline) mediante un carácter de opción insertada en el patrón de expresión regular.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. Para obtener más información, consulte Opciones de expresiones regulares.For details, see Regular Expression Options.

Se aplica a

Consulte también: