RegexOptions Énumération

Définition

public enum class RegexOptions

[System.Flags]
public enum RegexOptions

[<System.Flags>]
type RegexOptions = 

Public Enum RegexOptions

Héritage

Object

ValueType

Enum

RegexOptions

Attributs

FlagsAttribute

Champs

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és à l’aide de valeurs différentes RegexOptions . La première expression régulière ne respecte pas la casse ; la casse est ignorée lors de la détermination d’un mot identique au mot précédent. La deuxième expression régulière respecte la casse ; un mot doit correspondre exactement au cas du mot précédent pour être considéré comme un doublon.

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 RegexOptions valeur peut être fournie en tant que paramètre aux membres suivants de la Regex classe :

• Constructeur de Regex.Regex(String, RegexOptions) classe.

• Méthode Regex.Split(String, String, RegexOptions)

• Méthode Regex.IsMatch(String, String, RegexOptions)

• Méthode Regex.Match(String, String, RegexOptions)

• Méthode Regex.Matches(String, String, RegexOptions)

• Méthodes Regex.Replace(String, String, String, RegexOptions) et Regex.Replace(String, String, MatchEvaluator, RegexOptions).

Une RegexOptions valeur peut également être fournie en tant que paramètre au RegexCompilationInfo constructeur, ou elle peut être affectée directement à la RegexCompilationInfo.Options propriété . L’objet résultant RegexCompilationInfo est ensuite utilisé dans l’appel à la Regex.CompileToAssembly méthode .

Plusieurs options fournies par les membres de l’énumération RegexOptions (en particulier, par ses ExplicitCapturemembres , IgnoreCase, Multilineet Singleline ) peuvent être fournies à l’aide d’un caractère d’option inline dans le modèle d’expression régulière. Pour plus d’informations, consultez Options d’expression régulière.

S’applique à

Voir aussi

• Options
• Options des expressions régulières