RegexOptions Wyliczenie

Definicja

Przestrzeń nazw:

System.Text.RegularExpressions

Zestaw:

System.Text.RegularExpressions.dll

Zestaw:

System.dll

Zestaw:

netstandard.dll

Zawiera wyliczone wartości używane do ustawiania opcji wyrażeń regularnych.

To wyliczenie obsługuje bitową kombinację jego wartości składowych.

public enum class RegexOptions

[System.Flags]
public enum RegexOptions

[<System.Flags>]
type RegexOptions = 

Public Enum RegexOptions

Dziedziczenie

Object

ValueType

Enum

RegexOptions

Atrybuty

FlagsAttribute

Pola

Compiled	8	Określa, że wyrażenie regularne jest kompilowane do kodu MSIL, a nie jest interpretowane. Skompilowane wyrażenia regularne maksymalizują wydajność czasu wykonywania kosztem czasu inicjowania. Ta wartość nie powinna być przypisana Options do właściwości podczas wywoływania CompileToAssembly(RegexCompilationInfo[], AssemblyName) metody . Aby uzyskać więcej informacji, zobacz sekcję "Skompilowane wyrażenia regularne" w artykule Opcje wyrażeń regularnych .
CultureInvariant	512	Określa, że różnice kulturowe w języku są ignorowane. Aby uzyskać więcej informacji, zobacz sekcję "Porównanie przy użyciu niezmiennej kultury" w artykule Opcje wyrażeń regularnych .
ECMAScript	256	Włącza zachowanie zgodne ze standardem ECMAScript dla wyrażenia. Tej wartości można używać tylko w połączeniu IgnoreCasez wartościami , Multilinei Compiled . Użycie tej wartości z innymi wartościami powoduje wyjątek. Aby uzyskać więcej informacji na ECMAScript temat opcji, zobacz sekcję "Zachowanie dopasowywania kodu ECMAScript" w artykule Opcje wyrażeń regularnych .
ExplicitCapture	4	Określa, że jedynymi prawidłowymi przechwytywaniami są jawnie nazwane lub ponumerowane grupy formularza (?< name>...). Dzięki temu nienazwane nawiasy mogą działać jako grupy nieuchwytne bez składniowej niezdarności wyrażenia (?:...). Aby uzyskać więcej informacji, zobacz sekcję "Jawne przechwytywanie tylko" w artykule Opcje wyrażeń regularnych .
IgnoreCase	1	Określa dopasowywanie bez uwzględniania wielkości liter. Aby uzyskać więcej informacji, zobacz sekcję "Dopasowywanie bez uwzględniania wielkości liter" w artykule Opcje wyrażeń regularnych .
IgnorePatternWhitespace	32	Eliminuje niewyobrażalne białe znaki ze wzorca i włącza komentarze oznaczone znakiem #. Jednak ta wartość nie wpływa ani nie eliminuje białych znaków w klasach znaków, kwantyfikatorach liczbowych ani tokenach, które oznaczają początek poszczególnych elementów języka wyrażeń regularnych. Aby uzyskać więcej informacji, zobacz sekcję "Ignoruj białe znaki" artykułu Opcje wyrażeń regularnych .
Multiline	2	Tryb wielowierszowy. Zmienia znaczenie ^ i $ tak, aby odpowiadały odpowiednio na początku i końcu dowolnego wiersza, a nie tylko początku i końca całego ciągu. Aby uzyskać więcej informacji, zobacz sekcję "Tryb wielowierszowy" w artykule Opcje wyrażeń regularnych .
NonBacktracking	1024	Włącz dopasowywanie przy użyciu podejścia, które pozwala uniknąć wycofywania i gwarantuje przetwarzanie liniowe w czasie trwania danych wejściowych.
None	0	Określa, że nie są ustawione żadne opcje. Aby uzyskać więcej informacji na temat domyślnego zachowania aparatu wyrażeń regularnych, zobacz sekcję "Opcje domyślne" w artykule Opcje wyrażeń regularnych.
RightToLeft	64	Określa, że wyszukiwanie będzie od prawej do lewej zamiast od lewej do prawej. Aby uzyskać więcej informacji, zobacz sekcję "Tryb od prawej do lewej" w artykule Opcje wyrażeń regularnych .
Singleline	16	Określa tryb jednowierszowy. Zmienia znaczenie kropki (.), tak aby dopasowywała każdy znak (zamiast każdego znaku z wyjątkiem \n). Aby uzyskać więcej informacji, zobacz sekcję "Tryb jednowierszowy" w artykule Opcje wyrażeń regularnych .

Przykłady

W poniższym przykładzie zdefiniowano dwa wyrażenia regularne, które identyfikują powtarzające się wyrazy w tekście, ale są tworzone przy użyciu różnych RegexOptions wartości. Pierwsze wyrażenie regularne jest bez uwzględniania wielkości liter; wielkość liter jest ignorowana podczas określania, czy wyraz jest identyczny z poprzednim wyrazem. W drugim wyrażeniu regularnym jest uwzględniana wielkość liter; słowo musi odpowiadać wielkości liter poprzedniego wyrazu, aby można je było traktować jako duplikat.

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

Uwagi

RegexOptions Wartość można podać jako parametr dla następujących składowych Regex klasy:

• Konstruktor Regex.Regex(String, RegexOptions) klasy.

• Metoda Regex.Split(String, String, RegexOptions) .

• Metoda Regex.IsMatch(String, String, RegexOptions) .

• Metoda Regex.Match(String, String, RegexOptions) .

• Metoda Regex.Matches(String, String, RegexOptions) .

• Metody Regex.Replace(String, String, String, RegexOptions) i Regex.Replace(String, String, MatchEvaluator, RegexOptions) .

RegexOptions Wartość można również podać jako parametr konstruktora RegexCompilationInfo lub przypisać ją bezpośrednio do RegexCompilationInfo.Options właściwości . Wynikowy RegexCompilationInfo obiekt jest następnie używany w wywołaniu Regex.CompileToAssembly metody .

Zamiast tego można podać kilka opcji udostępnianych RegexOptions przez elementy członkowskie wyliczenia (w szczególności przez jej ExplicitCaptureelementy , IgnoreCase, Multilinei Singleline elementy członkowskie) przy użyciu wbudowanego znaku opcji we wzorcu wyrażenia regularnego. Aby uzyskać szczegółowe informacje, zobacz Opcje wyrażeń regularnych.

Zobacz też

• Options
• Opcje wyrażeń regularnych