RegexOptions Enumeration

Definition

Stellt Enumerationswerte bereit, mit deren Hilfe Optionen für reguläre Ausdrücke festgelegt werden können.

Diese Enumeration unterstützt eine bitweise Kombination ihrer Memberwerte.

public enum class RegexOptions
[System.Flags]
public enum RegexOptions
[<System.Flags>]
type RegexOptions = 
Public Enum RegexOptions
Vererbung
RegexOptions
Attribute

Felder

Compiled 8

Gibt an, dass der reguläre Ausdruck in MSIL-Code kompiliert wird, anstatt interpretiert zu werden. Kompilierte reguläre Ausdrücke maximieren die Laufzeitleistung auf Kosten der Initialisierungszeit. Dieser Wert sollte der Options-Eigenschaft nicht zugewiesen werden, wenn die CompileToAssembly(RegexCompilationInfo[], AssemblyName)-Methode aufgerufen wird. Weitere Informationen finden Sie im Artikel Optionen für reguläre Ausdrücke im Abschnitt „Kompilierte reguläre Ausdrücke“.

CultureInvariant 512

Gibt an, dass kulturelle Unterschiede bei der Sprache ignoriert werden. Weitere Informationen finden Sie im Artikel Optionen für reguläre Ausdrücke im Abschnitt „Vergleiche mit der invarianten Kultur“.

ECMAScript 256

Aktiviert ECMAScript-kompatibles Verhalten für den Ausdruck. Dieser Wert kann nur in Verbindung mit den Werten IgnoreCase, Multiline und Compiled verwendet werden. Bei Verwendung dieses Werts mit allen anderen Werten wird eine Ausnahme ausgelöst.

Weitere Informationen zur ECMAScript-Option finden Sie im Artikel Optionen für reguläre Ausdrücke im Abschnitt „ECMAScript-Vergleichsverhalten“.

ExplicitCapture 4

Gibt an, dass die einzigen gültigen Erfassungen ausdrücklich benannte oder nummerierte Gruppen in der Form (?<name>...) sind. Dadurch können unbenannte Klammern wie Nicht-Erfassungsgruppen eingesetzt werden, ohne die komplexe Syntax des Ausdrucks (?:...) zu verwenden. Weitere Informationen finden Sie im Artikel Optionen für reguläre Ausdrücke im Abschnitt „Nur explizite Erfassungen“.

IgnoreCase 1

Gibt an, dass bei Übereinstimmungen die Groß- und Kleinschreibung berücksichtigt werden soll. Weitere Informationen finden Sie im Artikel Optionen für reguläre Ausdrücke im Abschnitt „Übereinstimmung ohne Berücksichtigung der Groß-/Kleinschreibung“.

IgnorePatternWhitespace 32

Entfernt Leerraum ohne Escapezeichen aus dem Muster und aktiviert die mit # markierten Kommentare. Dieser Wert beeinflusst oder entfernt jedoch keinen Leerraum in Zeichenklassen, numerischen Quantifizierern oder Token, die den Anfang von einzelnen Sprachenelementen für reguläre Ausdrücke markieren. Weitere Informationen finden Sie im Artikel Optionen für reguläre Ausdrücke im Abschnitt „Leerstellen ignorieren“.

Multiline 2

Mehrzeilenmodus. Ändert die Bedeutung von ^ und $, sodass sie jeweils dem Anfang und Ende einer beliebigen Zeile und nicht nur dem Anfang und Ende der gesamten Zeichenfolge entsprechen. Weitere Informationen finden Sie im Artikel Optionen für reguläre Ausdrücke im Abschnitt „Mehrzeilenmodus“.

NonBacktracking 1024

Aktivieren Sie den Abgleich mithilfe eines Ansatzes, der eine Rückverfolgung vermeidet und eine lineare Zeitverarbeitung in der Länge der Eingabe garantiert.

None 0

Gibt an, dass keine Optionen festgelegt wurden. Weitere Informationen zum Standardverhalten der Engine für reguläre Ausdrücke finden Sie im Artikel Optionen für reguläre Ausdrücke im Abschnitt „Standardoptionen“.

RightToLeft 64

Gibt an, dass die Suche von rechts nach links und nicht von links nach rechts durchgeführt wird. Weitere Informationen finden Sie im Artikel Optionen für reguläre Ausdrücke im Abschnitt „Modus ‚von rechts nach links‘“.

Singleline 16

Gibt den Einzeilenmodus an. Ändert die Bedeutung des Punkts (.), sodass dieser jedem Zeichen entspricht (und nicht jedem Zeichen mit Ausnahme von \n). Weitere Informationen finden Sie im Artikel Optionen für reguläre Ausdrücke im Abschnitt „Einzeilenmodus“.

Beispiele

Im folgenden Beispiel werden zwei reguläre Ausdrücke definiert, die wiederholte Wörter im Text identifizieren, die aber mit unterschiedlichen RegexOptions Werten instanziiert werden. Beim ersten regulären Ausdruck wird die Groß-/Kleinschreibung nicht beachtet. Groß-/Kleinschreibung wird ignoriert, wenn festgestellt wird, ob ein Wort mit dem vorherigen Wort identisch ist. Beim zweiten regulären Ausdruck wird die Groß-/Kleinschreibung beachtet. ein Wort muss genau mit dem Fall des vorherigen Worts übereinstimmen, um 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:

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

Mehrere Optionen, die von Membern der RegexOptions Enumeration bereitgestellt werden (insbesondere durch ihre ExplicitCaptureMember , IgnoreCase, Multilineund Singleline ), können stattdessen mithilfe eines Inlineoptionszeichens im regulären Ausdrucksmuster bereitgestellt werden. Ausführliche Informationen finden Sie unter Optionen für reguläre Ausdrücke.

Gilt für:

Siehe auch