RegexOptions Enumeration

Definition

public enum class RegexOptions

[System.Flags]
public enum RegexOptions

[<System.Flags>]
type RegexOptions = 

Public Enum RegexOptions

Vererbung

Object

ValueType

Enum

RegexOptions

Attribute

FlagsAttribute

Felder

Beispiele

Im folgenden Beispiel werden zwei reguläre Ausdrücke definiert, die wiederholte Wörter in Text identifizieren, die jedoch mit unterschiedlichen RegexOptions Werten instanziiert werden. Bei dem ersten regulären Ausdruck wird die Groß-/Kleinschreibung nicht beachtet. Groß-/Kleinschreibung wird ignoriert, wenn ermittelt wird, ob ein Wort mit dem vorhergehenden Wort identisch ist. Bei dem zweiten regulären Ausdruck wird die Groß-/Kleinschreibung beachtet. ein Wort muss mit der Groß-/Kleinschreibung des vorhergehenden Worts übereinstimmen, um genau als Duplikat betrachtet zu werden.

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

Hinweise

Ein RegexOptions Wert kann als Parameter für die folgenden Member der Regex Klasse bereitgestellt werden:

• Der Regex.Regex(String, RegexOptions) Klassenkonstruktor.

• Die Regex.Split(String, String, RegexOptions)-Methode.

• Die Regex.IsMatch(String, String, RegexOptions)-Methode.

• Die Regex.Match(String, String, RegexOptions)-Methode.

• Die Regex.Matches(String, String, RegexOptions)-Methode.

• Die Regex.Replace(String, String, String, RegexOptions) Und Regex.Replace(String, String, MatchEvaluator, RegexOptions) Methoden.

Ein RegexOptions Wert kann auch als Parameter für den RegexCompilationInfo Konstruktor bereitgestellt werden, oder er kann direkt der RegexCompilationInfo.Options Eigenschaft zugewiesen werden. Das resultierende RegexCompilationInfo Objekt wird dann im Aufruf der Regex.CompileToAssembly Methode verwendet.

Es können stattdessen mehrere Optionen bereitgestellt werden, die von Membern der RegexOptions Aufzählung (insbesondere durch seine ExplicitCapture, , IgnoreCaseMultiline, und Singleline Member) bereitgestellt werden, indem sie ein Inlineoptionszeichen im Muster für reguläre Ausdrücke verwenden. Ausführliche Informationen finden Sie unter "Optionen für reguläre Ausdrücke".

Weitere Informationen

• Options
• Optionen für reguläre Ausdrücke