RegexOptions RegexOptions RegexOptions RegexOptions Enum

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
type RegexOptions = 
Public Enum RegexOptions
Herencia
Atributos

Campos

Compiled Compiled Compiled 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 más información, vea la sección "Expresiones regulares compiladas" que encontrará en el tema Opciones de expresiones regulares.For more information, see the "Compiled Regular Expressions" section in the Regular Expression Options topic.

CultureInvariant CultureInvariant CultureInvariant CultureInvariant 512

Especifica que las diferencias culturales de idioma se pasan por alto.Specifies that cultural differences in language is ignored. Para más información, vea la sección "Comparación con la referencia cultural de todos los idiomas" que encontrará en el tema Opciones de expresiones regulares.For more information, see the "Comparison Using the Invariant Culture" section in the Regular Expression Options topic.

ECMAScript ECMAScript ECMAScript 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 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 tema Opciones de expresiones regulares.For more information on the ECMAScript option, see the "ECMAScript Matching Behavior" section in the Regular Expression Options topic.

ExplicitCapture ExplicitCapture ExplicitCapture 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 más información, vea la sección "Solo capturas explícitas" que encontrará en el tema 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 topic.

IgnoreCase IgnoreCase IgnoreCase IgnoreCase 1

Especifica la coincidencia con distinción entre mayúsculas y minúsculas.Specifies case-insensitive matching. Para más información, vea la sección "Coincidencia sin distinción entre mayúsculas y minúsculas" que encontrará en el tema Opciones de expresiones regulares.For more information, see the "Case-Insensitive Matching " section in the Regular Expression Options topic.

IgnorePatternWhitespace IgnorePatternWhitespace IgnorePatternWhitespace IgnorePatternWhitespace 32

Elimina el espacio en blanco no omitido del modelo 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" que encontrará en el tema Opciones de expresiones regulares.For more information, see the "Ignore White Space" section of the Regular Expression Options topic.

Multiline Multiline Multiline Multiline 2

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

None None None None 0

Especifica que no hay opciones establecidas.Specifies that no options are set. Para más información sobre el comportamiento predeterminado del motor de expresiones regulares, vea la sección "Opciones predeterminadas" que encontrará en el tema 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 topic.

RightToLeft RightToLeft RightToLeft 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 más información, vea la sección "Modo de derecha a izquierda" que encontrará en el tema Opciones de expresiones regulares.For more information, see the "Right-to-Left Mode" section in the Regular Expression Options topic.

Singleline Singleline Singleline 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 más información, vea la sección "Modo de una sola línea" que encontrará en el tema Opciones de expresiones regulares.For more information, see the "Single-line Mode" section in the Regular Expression Options topic.

Ejemplos

En el ejemplo siguiente se definen dos expresiones regulares que identifican palabras repetidas en texto pero de las RegexOptions que se crean instancias con distintos valores.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 RegexOptions puede proporcionar un valor como parámetro a los siguientes miembros de la Regex clase:A RegexOptions value can be provided as a parameter to the following members of the Regex class:

También RegexOptions se puede proporcionar un valor como parámetro RegexCompilationInfo al constructor, o bien se puede asignar directamente a la RegexCompilationInfo.Options propiedad.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 RegexCompilationInfo , el objeto resultante se usa en la llamada Regex.CompileToAssembly al método.The resulting RegexCompilationInfo object is then used in the call to the Regex.CompileToAssembly method.

En su lugar, se pueden proporcionar RegexOptions varias opciones proporcionadas por miembros de la IgnoreCaseenumeración ( Singleline en particular, por sus ExplicitCapturemiembros,, Multiliney) mediante un carácter de opción insertado en la expresión regular. ajedrez.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: