RegexOptions Enumeration

Definition

Stellt Enumerationswerte bereit, mit deren Hilfe Optionen für reguläre Ausdrücke festgelegt werden können.Provides enumerated values to use to set regular expression options.

Diese Enumeration weist ein FlagsAttribute-Attribut auf, die eine bitweise Kombination der Memberwerte zulässt.

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

Felder

Compiled 8

Gibt an, dass der reguläre Ausdruck in eine Assembly kompiliert wird.Specifies that the regular expression is compiled to an assembly. Dies beschleunigt zwar die Ausführung, verlängert jedoch die Ladezeit.This yields faster execution but increases startup time. Dieser Wert sollte der Options-Eigenschaft nicht zugewiesen werden, wenn die CompileToAssembly(RegexCompilationInfo[], AssemblyName)-Methode aufgerufen wird.This value should not be assigned to the Options property when calling the CompileToAssembly(RegexCompilationInfo[], AssemblyName) method. Weitere Informationen finden Sie im Thema Optionen für reguläre Ausdrücke im Abschnitt „Kompilierte reguläre Ausdrücke“.For more information, see the "Compiled Regular Expressions" section in the Regular Expression Options topic.

CultureInvariant 512

Gibt an, dass Unterschiede der Kultur bei der Sprache ignoriert werden.Specifies that cultural differences in language is ignored. Weitere Informationen finden Sie im Thema Optionen für reguläre Ausdrücke im Abschnitt „Vergleiche mit der invarianten Kultur“.For more information, see the "Comparison Using the Invariant Culture" section in the Regular Expression Options topic.

ECMAScript 256

Aktiviert ECMAScript-kompatibles Verhalten für den Ausdruck.Enables ECMAScript-compliant behavior for the expression. Dieser Wert kann nur in Verbindung mit den Werten IgnoreCase, Multiline und Compiled verwendet werden.This value can be used only in conjunction with the IgnoreCase, Multiline, and Compiled values. Bei Verwendung dieses Werts mit allen anderen Werten wird eine Ausnahme ausgelöst.The use of this value with any other values results in an exception.

Weitere Informationen zur ECMAScript-Option finden Sie im Thema Optionen für reguläre Ausdrücke im Abschnitt „ECMAScript-Vergleichsverhalten“.For more information on the ECMAScript option, see the "ECMAScript Matching Behavior" section in the Regular Expression Options topic.

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 Thema Optionen für reguläre Ausdrücke im Abschnitt „Nur explizite Erfassungen“.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

Gibt an, dass bei Übereinstimmungen die Groß- und Kleinschreibung berücksichtigt werden soll.Specifies case-insensitive matching. Weitere Informationen finden Sie im Thema Optionen für reguläre Ausdrücke im Abschnitt „Übereinstimmung ohne Berücksichtigung der Groß-/Kleinschreibung“.For more information, see the "Case-Insensitive Matching " section in the Regular Expression Options topic.

IgnorePatternWhitespace 32

Entfernt Leerraum ohne Escapezeichen aus dem Muster und aktiviert die mit # markierten Kommentare.Eliminates unescaped white space from the pattern and enables comments marked with #. 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.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. Weitere Informationen finden Sie im Thema Optionen für reguläre Ausdrücke im Abschnitt „Leerstellen ignorieren“.For more information, see the "Ignore White Space" section of the Regular Expression Options topic.

Multiline 2

Mehrzeilenmodus.Multiline mode. Ä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.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. Weitere Informationen finden Sie im Thema Optionen für reguläre Ausdrücke im Abschnitt „Mehrzeilenmodus“.For more information, see the "Multiline Mode" section in the Regular Expression Options topic.

None 0

Gibt an, dass keine Optionen festgelegt wurden.Specifies that no options are set. Weitere Informationen zum Standardverhalten der Engine für reguläre Ausdrücke finden Sie im Thema Optionen für reguläre Ausdrücke im Abschnitt „Standardoptionen“.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

Gibt an, dass die Suche von rechts nach links und nicht von links nach rechts durchgeführt wird.Specifies that the search will be from right to left instead of from left to right. Weitere Informationen finden Sie im Thema Optionen für reguläre Ausdrücke im Abschnitt „Modus ‚von rechts nach links‘“.For more information, see the "Right-to-Left Mode" section in the Regular Expression Options topic.

Singleline 16

Gibt den Einzeilenmodus an.Specifies single-line mode. Ändert die Bedeutung des Punkts (.), sodass dieser jedem Zeichen entspricht (und nicht jedem Zeichen mit Ausnahme von \n).Changes the meaning of the dot (.) so it matches every character (instead of every character except \n). Weitere Informationen finden Sie im Thema Optionen für reguläre Ausdrücke im Abschnitt „Einzeilenmodus“.For more information, see the "Single-line Mode" section in the Regular Expression Options topic.

Beispiele

Im folgenden Beispiel werden zwei reguläre Ausdrücke definiert, mit denen wiederholte Wörter im Text identifiziert werden, die jedoch RegexOptions mit unterschiedlichen Werten instanziiert werden.The following example defines two regular expressions that identify repeated words in text but that are instantiated using different RegexOptions values. Beim ersten regulären Ausdruck wird die Groß-/Kleinschreibung nicht beachtet. Case wird ignoriert, wenn bestimmt wird, ob ein Wort mit dem vorangehenden Wort identisch ist.The first regular expression is case-insensitive; case is ignored when determining whether a word is identical to the preceding word. Beim zweiten regulären Ausdruck wird die Groß-/Kleinschreibung beachtet. ein Wort muss der Groß-/Kleinschreibung des vorangehenden Worts genau entsprechen, um als Duplikat angesehen zu werden.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

Hinweise

Ein RegexOptions Wert kann als Parameter für die folgenden Member Regex der-Klasse bereitgestellt werden:A RegexOptions value can be provided as a parameter to the following members of the Regex class:

Ein RegexOptions Wert kann auch als Parameter für den RegexCompilationInfo Konstruktor bereitgestellt werden, oder er kann direkt der RegexCompilationInfo.Options Eigenschaft zugewiesen werden.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. Das resultierende RegexCompilationInfo Objekt wird dann im Aufrufder Regex.CompileToAssembly -Methode verwendet.The resulting RegexCompilationInfo object is then used in the call to the Regex.CompileToAssembly method.

Mehrere von RegexOptions Membern der-Enumeration bereitgestellte Optionen (insbesondere durch die ExplicitCaptureMember, Multiline IgnoreCase, und Singleline ) können stattdessen mithilfe eines Inline Options Zeichens im regulären Ausdruck bereitgestellt werden. Bau.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. Weitere Informationen finden Sie unter Optionen für reguläre Ausdrücke.For details, see Regular Expression Options.

Gilt für:

Siehe auch