RegexOptions Énumération

Définition

Fournit les valeurs énumérées à utiliser pour définir les options des expressions régulières.Provides enumerated values to use to set regular expression options.

Cette énumération a un attribut FlagsAttribute qui permet une combinaison au niveau du bit de ses valeurs membres.

public enum class RegexOptions
[System.Flags]
public enum RegexOptions
type RegexOptions = 
Public Enum RegexOptions
Héritage
RegexOptions
Attributs

Champs

Compiled 8

Spécifie que l'expression régulière est compilée vers un assembly.Specifies that the regular expression is compiled to an assembly. L'exécution est plus rapide, mais le temps de démarrage s'en trouve augmenté.This yields faster execution but increases startup time. Cette valeur ne doit pas être assignée à la propriété Options lors de l'appel de la méthode CompileToAssembly(RegexCompilationInfo[], AssemblyName).This value should not be assigned to the Options property when calling the CompileToAssembly(RegexCompilationInfo[], AssemblyName) method. Pour plus d’informations, consultez la section « Expressions régulières compilées » dans la rubrique Options des expressions régulières.For more information, see the "Compiled Regular Expressions" section in the Regular Expression Options topic.

CultureInvariant 512

Indique que les différences culturelles dans la langue ne sont pas prises en compte.Specifies that cultural differences in language is ignored. Pour plus d’informations, consultez la section « Comparaison à l’aide de la culture dite indifférente » dans la rubrique Options des expressions régulières.For more information, see the "Comparison Using the Invariant Culture" section in the Regular Expression Options topic.

ECMAScript 256

Active un comportement conforme ECMAScript pour l'expression.Enables ECMAScript-compliant behavior for the expression. Cette valeur ne peut être utilisée qu'en conjonction avec les valeurs IgnoreCase, Multiline et Compiled.This value can be used only in conjunction with the IgnoreCase, Multiline, and Compiled values. L'utilisation de cette valeur avec n'importe quelle autre valeur résulte en une exception.The use of this value with any other values results in an exception.

Pour plus d’informations sur l’option ECMAScript, consultez la section « Comportement correspondant à ECMAScript » dans la rubrique Options des expressions régulières.For more information on the ECMAScript option, see the "ECMAScript Matching Behavior" section in the Regular Expression Options topic.

ExplicitCapture 4

Spécifie que les seules captures valides sont des groupes explicitement nommés ou numérotés de la forme (?<nom>…). Ceci permet à des parenthèses sans nom d’agir comme des groupes qui ne sont pas des groupes de captures sans la lourdeur syntaxique de l’expression (?:…). Pour plus d’informations, consultez la section « Captures explicites uniquement » dans la rubrique Options des expressions régulières.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 1

Spécifie la correspondance qui ne respecte pas la casse.Specifies case-insensitive matching. Pour plus d’informations, consultez la section « Correspondance qui ne respecte pas la casse » dans la rubrique Options des expressions régulières.For more information, see the "Case-Insensitive Matching " section in the Regular Expression Options topic.

IgnorePatternWhitespace 32

Élimine l'espace blanc sans séquence d'échappement du modèle et active les commentaires marqués avec #.Eliminates unescaped white space from the pattern and enables comments marked with #. Cependant, cette valeur n’affecte ni n’élimine l’espace blanc dans les classes de caractères, les quantificateurs numériques ou les jetons qui marquent le début d’éléments de langage d’expression régulière.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. Pour plus d’informations, consultez la section « Ignorer l’espace blanc » dans l’article Options des expressions régulières.For more information, see the "Ignore White Space" section of the Regular Expression Options article.

Multiline 2

Mode multiligne.Multiline mode. Modifie la signification de ^ et $ de sorte qu'ils correspondent respectivement au début et à la fin de n'importe quelle ligne, et non simplement au début et à la fin de la chaîne entière.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. Pour plus d’informations, consultez la section « Mode multiligne » dans la rubrique Options des expressions régulières.For more information, see the "Multiline Mode" section in the Regular Expression Options topic.

None 0

Spécifie qu'aucune option n'est définie.Specifies that no options are set. Pour plus d’informations sur le comportement par défaut du moteur d’expressions régulières, consultez la section « Options par défaut » dans la rubrique Options des expressions régulières.For more information about the default behavior of the regular expression engine, see the "Default Options" section in the Regular Expression Options topic.

RightToLeft 64

Spécifie que la recherche sera effectuée de droite à gauche et non de gauche à droite.Specifies that the search will be from right to left instead of from left to right. Pour plus d’informations, consultez la section « Mode de droite à gauche » dans la rubrique Options des expressions régulières.For more information, see the "Right-to-Left Mode" section in the Regular Expression Options topic.

Singleline 16

Spécifie le mode à ligne simple.Specifies single-line mode. Modifie la signification du point (.) de sorte qu'il corresponde à chaque caractère (et non à chaque caractère sauf \n).Changes the meaning of the dot (.) so it matches every character (instead of every character except \n). Pour plus d’informations, consultez la section « Mode à ligne simple » dans la rubrique Options des expressions régulières.For more information, see the "Single-line Mode" section in the Regular Expression Options topic.

Exemples

L’exemple suivant définit deux expressions régulières qui identifient les mots répétés dans le texte, mais qui sont instanciées à l’aide de différentes valeurs de RegexOptions.The following example defines two regular expressions that identify repeated words in text but that are instantiated using different RegexOptions values. La première expression régulière ne respecte pas la casse ; la casse est ignorée pour déterminer si un mot est identique au mot précédent.The first regular expression is case-insensitive; case is ignored when determining whether a word is identical to the preceding word. La deuxième expression régulière respecte la casse ; un mot doit correspondre exactement à la casse du mot précédent pour être considéré comme un doublon.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

Remarques

Une valeur RegexOptions peut être fournie en tant que paramètre aux membres suivants de la classe Regex :A RegexOptions value can be provided as a parameter to the following members of the Regex class:

Une valeur RegexOptions peut également être fournie en tant que paramètre au constructeur RegexCompilationInfo, ou elle peut être assignée directement à la propriété 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. L’objet RegexCompilationInfo résultant est ensuite utilisé dans l’appel à la méthode Regex.CompileToAssembly.The resulting RegexCompilationInfo object is then used in the call to the Regex.CompileToAssembly method.

Plusieurs options fournies par les membres de l’énumération RegexOptions (en particulier par ses ExplicitCapture, IgnoreCase, Multilineet Singleline membres) peuvent être fournies à la place à l’aide d’un caractère d’option inline dans le modèle d’expression régulière.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. Pour plus d’informations, consultez Options des expressions régulières.For details, see Regular Expression Options.

S’applique à

Voir aussi