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 lorsque vous déterminez si un mot est 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).

• Les méthodes et Regex.Replace(String, String, MatchEvaluator, RegexOptions) les Regex.Replace(String, String, String, RegexOptions) méthodes.

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 membres , et IgnoreCaseMultilineSingleline ses ExplicitCapturemembres) peuvent être fournies à la place à 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.

Voir aussi

• Options
• Options des expressions régulières