Opcje wyrażeń regularnych

  • Artykuł

Domyślnie porównanie ciągu wejściowego z dowolnymi znakami literału we wzorcu wyrażenia regularnego jest uwzględniane wielkość liter, odstęp w wzorcu wyrażenia regularnego jest interpretowany jako znaki literału odstępu, a przechwytywanie grup w wyrażeniu regularnym jest jawnie nazywane również jawnie. Można zmodyfikować te i kilka innych aspektów domyślnego zachowania wyrażenia regularnego, określając opcje wyrażeń regularnych. Niektóre z tych opcji, które są wymienione w poniższej tabeli, można uwzględnić w tekście jako część wzorca wyrażenia regularnego lub mogą być dostarczane do System.Text.RegularExpressions.Regex konstruktora klasy lub metody dopasowywania wzorca statycznego jako System.Text.RegularExpressions.RegexOptions wartości wyliczenia.

RegexOptions Członkowskich Znak wbudowany Efekt Więcej informacji
None Niedostępny Użyj domyślnego zachowania. Opcje domyślne
IgnoreCase i Używa dopasowywania bez uwzględniania wielkości liter. Dopasowywanie bez uwzględniania wielkości liter
Multiline m Użyj trybu wielowierszowego, gdzie ^ i $ wskazuje początek i koniec każdego wiersza (zamiast początku i końca ciągu wejściowego). Tryb wielowierszowy
Singleline s Użyj trybu jednowierszowego, w którym kropka (.) pasuje do każdego znaku (zamiast każdego znaku z wyjątkiem \n). Tryb jednowierszowy
ExplicitCapture n Nie przechwytuje nienazwanych grup. Jedynymi prawidłowymi przechwytywaniami są jawnie nazwane lub ponumerowane grupy podwyrażenia) nazwy>formularza.(?< Jawne przechwytywanie tylko
Compiled Niedostępny Skompiluj wyrażenie regularne do zestawu. Skompilowane wyrażenia regularne
IgnorePatternWhitespace x Wyklucz niewyobrażalne białe znaki ze wzorca i włącz komentarze po znaku numeru (#). Ignoruj białe znaki
RightToLeft Niedostępny Zmień kierunek wyszukiwania. Wyszukiwanie przechodzi od prawej do lewej zamiast od lewej do prawej. Tryb od prawej do lewej
ECMAScript Niedostępny Włącz zachowanie zgodne ze standardem ECMAScript dla wyrażenia. Zachowanie dopasowania w języku ECMAScript
CultureInvariant Niedostępny Ignoruj różnice kulturowe w języku. Porównanie przy użyciu niezmiennej kultury
NonBacktracking Niedostępny Dopasowanie przy użyciu podejścia, które pozwala uniknąć wycofywania i gwarantuje przetwarzanie w czasie liniowym w długości danych wejściowych. (Dostępne na platformie .NET 7 i nowszych wersjach). Tryb niepowodzeń śledzenia

Określanie opcji

Opcje wyrażeń regularnych można określić na jeden z trzech sposobów:

  • W parametrze options konstruktora klasy lub metody statycznej System.Text.RegularExpressions.Regex (Shared w Visual Basic) dopasowywania wzorca, takiej jak Regex(String, RegexOptions) lub Regex.Match(String, String, RegexOptions). Parametr options jest bitową kombinacją System.Text.RegularExpressions.RegexOptions wyliczonych wartości LUB.

    Gdy opcje są dostarczane do Regex wystąpienia przy użyciu options parametru konstruktora klasy, opcje są przypisywane do System.Text.RegularExpressions.RegexOptions właściwości. System.Text.RegularExpressions.RegexOptions Jednak właściwość nie odzwierciedla opcji wbudowanych we wzorcu wyrażenia regularnego.

    Poniższy przykład stanowi ilustrację. Używa options parametru Regex.Match(String, String, RegexOptions) metody , aby włączyć dopasowywanie bez uwzględniania wielkości liter i ignorować biały znak wzorca podczas identyfikowania wyrazów rozpoczynających się literą "d".

    string pattern = @"d \w+ \s";
string input = "Dogs are decidedly good pets.";
RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace;

foreach (Match match in Regex.Matches(input, pattern, options))
    Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

    Dim pattern As String = "d \w+ \s"
Dim input As String = "Dogs are decidedly good pets."
Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.IgnorePatternWhitespace

For Each match As Match In Regex.Matches(input, pattern, options)
    Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.

  • Stosując opcje wbudowane we wzorcu wyrażenia regularnego ze składnią (?imnsx-imnsx). Opcja ma zastosowanie do wzorca od momentu, w którym opcja jest zdefiniowana na końcu wzorca lub do punktu, w którym opcja jest niezdefiniowana przez inną opcję śródwierszową. Należy pamiętać, że System.Text.RegularExpressions.RegexOptions właściwość Regex wystąpienia nie odzwierciedla tych opcji wbudowanych. Aby uzyskać więcej informacji, zobacz temat Różne konstrukcje .

    Poniższy przykład stanowi ilustrację. Używa opcji wbudowanych, aby włączyć dopasowywanie bez uwzględniania wielkości liter i ignorować biały znak wzorca podczas identyfikowania wyrazów rozpoczynających się literą "d".

    string pattern = @"(?ix) d \w+ \s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
    Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

    Dim pattern As String = "\b(?ix) d \w+ \s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
    Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.

  • Stosując opcje wbudowane w określonej konstrukcji grupowania we wzorcu wyrażenia regularnego z podexpressionem) składni(?imnsx-imnsx:. Nie ma znaku przed ustawieniem zestawu opcji; znak minus przed zestawem opcji powoduje wyłączenie. (? jest stałą częścią składni konstrukcji języka, która jest wymagana, czy opcje są włączone, czy wyłączone). Opcja ma zastosowanie tylko do tej grupy. Aby uzyskać więcej informacji, zobacz Grouping Constructs (Konstrukcje grupowania).

    Poniższy przykład stanowi ilustrację. Używa opcji wbudowanych w konstrukcji grupowania, aby włączyć dopasowywanie bez uwzględniania wielkości liter i ignorować biały znak wzorca podczas identyfikowania wyrazów rozpoczynających się literą "d".

    string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
    Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

    Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
    Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.

Jeśli opcje są określone w tekście, znak minus (-) przed opcją lub zestawem opcji wyłącza te opcje. Na przykład konstrukcja (?ix-ms) śródliniowa włącza RegexOptions.IgnoreCase opcje i i RegexOptions.IgnorePatternWhitespace wyłącza RegexOptions.Multiline opcje i RegexOptions.Singleline . Wszystkie opcje wyrażeń regularnych są domyślnie wyłączone.

Uwaga

Jeśli opcje wyrażenia regularnego określone w parametrze options konstruktora lub wywołania metody powodują konflikt z opcjami określonymi w tekście we wzorcu wyrażenia regularnego, używane są opcje wbudowane.

Następujące pięć opcji wyrażeń regularnych można ustawić zarówno za pomocą parametru options, jak i wbudowanego:

Następujące pięć opcji wyrażeń regularnych można ustawić przy użyciu parametru options , ale nie można go ustawić w tekście:

Określanie opcji

Można określić, które opcje zostały udostępnione Regex obiektowi podczas tworzenia wystąpienia, pobierając wartość właściwości tylko Regex.Options do odczytu. Ta właściwość jest szczególnie przydatna do określania opcji zdefiniowanych dla skompilowanego wyrażenia regularnego utworzonego przez metodę Regex.CompileToAssembly .

Aby przetestować obecność dowolnej opcji z wyjątkiem RegexOptions.None, wykonaj operację AND z wartością Regex.Options właściwości i RegexOptions wartością, w której cię interesujesz. Następnie przetestuj, czy wynik jest równy tej RegexOptions wartości. Poniższy przykład sprawdza, czy opcja została ustawiona RegexOptions.IgnoreCase .

if ((rgx.Options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase)
    Console.WriteLine("Case-insensitive pattern comparison.");
else
    Console.WriteLine("Case-sensitive pattern comparison.");

If (rgx.Options And RegexOptions.IgnoreCase) = RegexOptions.IgnoreCase Then
    Console.WriteLine("Case-insensitive pattern comparison.")
Else
    Console.WriteLine("Case-sensitive pattern comparison.")
End If

Aby przetestować element RegexOptions.None, określ, czy wartość Regex.Options właściwości jest równa RegexOptions.Nonewartości , jak pokazano w poniższym przykładzie.

if (rgx.Options == RegexOptions.None)
    Console.WriteLine("No options have been set.");

If rgx.Options = RegexOptions.None Then
    Console.WriteLine("No options have been set.")
End If

W poniższych sekcjach wymieniono opcje obsługiwane przez wyrażenie regularne na platformie .NET.

Opcje domyślne

Opcja RegexOptions.None wskazuje, że nie określono żadnych opcji, a aparat wyrażeń regularnych używa jego domyślnego zachowania. Do takich właściwości należą:

  • Wzorzec jest interpretowany jako kanoniczny, a nie wyrażenie regularne ECMAScript.

  • Wzorzec wyrażenia regularnego jest dopasowywany w ciągu wejściowym od lewej do prawej.

  • W porównaniach jest rozróżniana wielkość liter.

  • ^ Elementy języka i $ wskazują początek i koniec ciągu wejściowego. Koniec ciągu wejściowego może być końcowym znakiem nowego wiersza \n .

  • Element . języka pasuje do każdego znaku z wyjątkiem \n.

  • Każdy biały znak we wzorcu wyrażenia regularnego jest interpretowany jako znak spacji literału.

  • Konwencje bieżącej kultury są używane podczas porównywania wzorca z ciągiem wejściowym.

  • Przechwytywanie grup we wzorcu wyrażenia regularnego jest niejawne, a także jawne.

Uwaga

Opcja RegexOptions.None nie ma wbudowanych odpowiedników. Gdy opcje wyrażeń regularnych są stosowane w tekście, domyślne zachowanie jest przywracane w oparciu o opcję po opcji, wyłączając określoną opcję. Na przykład (?i) włącza porównanie bez uwzględniania wielkości liter i (?-i) przywraca domyślne porównanie z uwzględnieniem wielkości liter.

RegexOptions.None Ponieważ opcja reprezentuje domyślne zachowanie aparatu wyrażeń regularnych, rzadko jest jawnie określona w wywołaniu metody. Konstruktor lub statyczna metoda dopasowywania wzorca bez parametru jest wywoływana options .

Dopasowywanie bez uwzględniania wielkości liter

Opcja IgnoreCase lub opcja śródliniowa i zapewnia dopasowywanie bez uwzględniania wielkości liter. Domyślnie są używane konwencje wielkości liter bieżącej kultury.

W poniższym przykładzie zdefiniowano wzorzec wyrażenia regularnego , \bthe\w*\bktóry pasuje do wszystkich wyrazów rozpoczynających się od "the". Ponieważ pierwsze wywołanie Match metody używa domyślnego porównania z uwzględnieniem wielkości liter, dane wyjściowe wskazują, że ciąg "The", który rozpoczyna zdanie, nie jest zgodny. Jest ona dopasowywana, gdy Match metoda jest wywoływana z opcjami ustawionymi na IgnoreCase.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bthe\w*\b";
      string input = "The man then told them about that event.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern,
                                            RegexOptions.IgnoreCase))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found then at index 8.
//       Found them at index 18.
//
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\bthe\w*\b"
        Dim input As String = "The man then told them about that event."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
        Next
        Console.WriteLine()
        For Each match As Match In Regex.Matches(input, pattern, _
                                                 RegexOptions.IgnoreCase)
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       Found then at index 8.
'       Found them at index 18.
'       
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.

Poniższy przykład modyfikuje wzorzec wyrażenia regularnego z poprzedniego przykładu, aby użyć opcji wbudowanych zamiast parametru options w celu zapewnienia porównania bez uwzględniania wielkości liter. Pierwszy wzorzec definiuje opcję bez uwzględniania wielkości liter w konstrukcji grupowania, która ma zastosowanie tylko do litery "t" w ciągu "the". Ponieważ konstrukcja opcji występuje na początku wzorca, drugi wzorzec stosuje opcję bez uwzględniania wielkości liter do całego wyrażenia regularnego.

using System;
using System.Text.RegularExpressions;

public class CaseExample
{
    public static void Main()
    {
        string pattern = @"\b(?i:t)he\w*\b";
        string input = "The man then told them about that event.";
        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

        Console.WriteLine();
        pattern = @"(?i)\bthe\w*\b";
        foreach (Match match in Regex.Matches(input, pattern,
                                              RegexOptions.IgnoreCase))
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
    }
}
// The example displays the following output:
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.
//
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.

Imports System.Text.RegularExpressions

Module CaseExample
    Public Sub Main()
        Dim pattern As String = "\b(?i:t)he\w*\b"
        Dim input As String = "The man then told them about that event."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
        Next
        Console.WriteLine()
        pattern = "(?i)\bthe\w*\b"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
        Next
    End Sub
End Module

' The example displays the following output:
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.
'       
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.

Tryb wielowierszowy

Opcja RegexOptions.Multiline lub opcja śródliniowa m umożliwia aparatowi wyrażeń regularnych obsługę ciągu wejściowego składającego się z wielu wierszy. Zmienia interpretację ^ elementów języka i $ tak, aby wskazywały początek i koniec wiersza zamiast początku i końca ciągu wejściowego.

Domyślnie $ będzie spełniony tylko na końcu ciągu wejściowego. Jeśli określisz RegexOptions.Multiline opcję, będzie ona spełniona przez znak nowego wiersza (\n) lub koniec ciągu wejściowego.

W żadnym przypadku nie $ rozpoznaje kombinacji znaków powrotu/wiersza karetki (\r\n). $ zawsze ignoruje wszelkie powroty karetki (\r). Aby zakończyć dopasowanie z elementem \r\n lub \n, użyj podexpressionu \r?$ zamiast tylko $. Należy pamiętać, że będzie \r to część dopasowania.

Poniższy przykład wyodrębnia nazwy i wyniki meloniki i dodaje je do SortedList<TKey,TValue> kolekcji, która sortuje je w kolejności malejącej. Metoda jest wywoływana Matches dwa razy. W pierwszym wywołaniu metody wyrażenie regularne jest ^(\w+)\s(\d+)$ ustawione i nie są ustawione żadne opcje. Jak pokazują dane wyjściowe, ponieważ aparat wyrażeń regularnych nie może dopasować wzorca wejściowego wraz z początkiem i końcem ciągu wejściowego, nie można odnaleźć dopasowań. W drugim wywołaniu metody wyrażenie regularne jest zmieniane na ^(\w+)\s(\d+)\r?$ , a opcje są ustawione na RegexOptions.Multiline. Jak pokazują dane wyjściowe, nazwy i wyniki są pomyślnie dopasowane, a wyniki są wyświetlane w kolejności malejącej.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Multiline1Example
{
    public static void Main()
    {
        SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer1<int>());

        string input = "Joe 164\n" +
                       "Sam 208\n" +
                       "Allison 211\n" +
                       "Gwen 171\n";
        string pattern = @"^(\w+)\s(\d+)$";
        bool matched = false;

        Console.WriteLine("Without Multiline option:");
        foreach (Match match in Regex.Matches(input, pattern))
        {
            scores.Add(Int32.Parse(match.Groups[2].Value), (string)match.Groups[1].Value);
            matched = true;
        }
        if (!matched)
            Console.WriteLine("   No matches.");
        Console.WriteLine();

        // Redefine pattern to handle multiple lines.
        pattern = @"^(\w+)\s(\d+)\r*$";
        Console.WriteLine("With multiline option:");
        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
            scores.Add(Int32.Parse(match.Groups[2].Value), (string)match.Groups[1].Value);

        // List scores in descending order.
        foreach (KeyValuePair<int, string> score in scores)
            Console.WriteLine("{0}: {1}", score.Value, score.Key);
    }
}

public class DescendingComparer1<T> : IComparer<T>
{
    public int Compare(T x, T y)
    {
        return Comparer<T>.Default.Compare(x, y) * -1;
    }
}
// The example displays the following output:
//   Without Multiline option:
//      No matches.
//
//   With multiline option:
//   Allison: 211
//   Sam: 208
//   Gwen: 171
//   Joe: 164

Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Multiline1Example
    Public Sub Main()
        Dim scores As New SortedList(Of Integer, String)(New DescendingComparer1(Of Integer)())

        Dim input As String = "Joe 164" + vbCrLf +
                              "Sam 208" + vbCrLf +
                              "Allison 211" + vbCrLf +
                              "Gwen 171" + vbCrLf
        Dim pattern As String = "^(\w+)\s(\d+)$"
        Dim matched As Boolean = False

        Console.WriteLine("Without Multiline option:")
        For Each match As Match In Regex.Matches(input, pattern)
            scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
            matched = True
        Next
        If Not matched Then Console.WriteLine("   No matches.")
        Console.WriteLine()

        ' Redefine pattern to handle multiple lines.
        pattern = "^(\w+)\s(\d+)\r*$"
        Console.WriteLine("With multiline option:")
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
            scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
        Next
        ' List scores in descending order. 
        For Each score As KeyValuePair(Of Integer, String) In scores
            Console.WriteLine("{0}: {1}", score.Value, score.Key)
        Next
    End Sub
End Module

Public Class DescendingComparer1(Of T) : Implements IComparer(Of T)
    Public Function Compare(x As T, y As T) As Integer _
           Implements IComparer(Of T).Compare
        Return Comparer(Of T).Default.Compare(x, y) * -1
    End Function
End Class
' The example displays the following output:
'    Without Multiline option:
'       No matches.
'    
'    With multiline option:
'    Allison: 211
'    Sam: 208
'    Gwen: 171
'    Joe: 164

Wzorzec ^(\w+)\s(\d+)\r*$ wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzorzec opis
^ Rozpocznij od początku wiersza.
(\w+) Dopasowuje co najmniej jeden znak słowa. Jest to pierwsza grupa przechwytywania.
\s Dopasowuje znak odstępu.
(\d+) Dopasowanie do co najmniej jednej cyfry dziesiętnej. Jest to druga grupa przechwytywania.
\r? Dopasuj zero lub jeden znak powrotu karetki.
$ Koniec na końcu wiersza.

Poniższy przykład jest odpowiednikiem poprzedniego, z tą różnicą, że używa wbudowanej opcji w celu ustawienia opcji (?m) wielowierszowej.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Multiline2Example
{
    public static void Main()
    {
        SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());

        string input = "Joe 164\n" +
                       "Sam 208\n" +
                       "Allison 211\n" +
                       "Gwen 171\n";
        string pattern = @"(?m)^(\w+)\s(\d+)\r*$";

        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
            scores.Add(Convert.ToInt32(match.Groups[2].Value), match.Groups[1].Value);

        // List scores in descending order.
        foreach (KeyValuePair<int, string> score in scores)
            Console.WriteLine("{0}: {1}", score.Value, score.Key);
    }
}

public class DescendingComparer<T> : IComparer<T>
{
    public int Compare(T x, T y)
    {
        return Comparer<T>.Default.Compare(x, y) * -1;
    }
}
// The example displays the following output:
//    Allison: 211
//    Sam: 208
//    Gwen: 171
//    Joe: 164

Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Multiline2Example
    Public Sub Main()
        Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())

        Dim input As String = "Joe 164" + vbCrLf +
                              "Sam 208" + vbCrLf +
                              "Allison 211" + vbCrLf +
                              "Gwen 171" + vbCrLf
        Dim pattern As String = "(?m)^(\w+)\s(\d+)\r*$"

        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
            scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
        Next
        ' List scores in descending order. 
        For Each score As KeyValuePair(Of Integer, String) In scores
            Console.WriteLine("{0}: {1}", score.Value, score.Key)
        Next
    End Sub
End Module

Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
    Public Function Compare(x As T, y As T) As Integer _
           Implements IComparer(Of T).Compare
        Return Comparer(Of T).Default.Compare(x, y) * -1
    End Function
End Class
' The example displays the following output:
'    Allison: 211
'    Sam: 208
'    Gwen: 171
'    Joe: 164

Tryb jednowierszowy

Opcja RegexOptions.Singleline lub s opcja śródwierszowa powoduje, że aparat wyrażeń regularnych traktuje ciąg wejściowy tak, jakby składał się z jednego wiersza. Robi to przez zmianę zachowania elementu języka kropki (.), tak aby pasował do każdego znaku, zamiast dopasowywać każdy znak z wyjątkiem znaku \nnowego wiersza .

W poniższym przykładzie pokazano, jak zachowanie . elementu języka zmienia się podczas korzystania z RegexOptions.Singleline opcji. Wyrażenie ^.+ regularne rozpoczyna się na początku ciągu i pasuje do każdego znaku. Domyślnie dopasowanie kończy się na końcu pierwszego wiersza; wzorzec wyrażenia regularnego pasuje do znaku \rpowrotu karetki , ale nie pasuje \ndo znaku . RegexOptions.Singleline Ponieważ opcja interpretuje cały ciąg wejściowy jako pojedynczy wiersz, pasuje do każdego znaku w ciągu wejściowym, w tym \n.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r
//
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^.+"
        Dim input As String = "This is one line and" + vbCrLf + "this is the second."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(Regex.Escape(match.Value))
        Next
        Console.WriteLine()
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
            Console.WriteLine(Regex.Escape(match.Value))
        Next
    End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r
'       
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Poniższy przykład jest odpowiednikiem poprzedniego, z tą różnicą, że używa wbudowanej opcji (?s) w celu włączenia trybu jednowierszowego.

using System;
using System.Text.RegularExpressions;

public class SingleLineExample
{
    public static void Main()
    {
        string pattern = "(?s)^.+";
        string input = "This is one line and" + Environment.NewLine + "this is the second.";

        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine(Regex.Escape(match.Value));
    }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Imports System.Text.RegularExpressions

Module SingleLineExample
    Public Sub Main()
        Dim pattern As String = "(?s)^.+"
        Dim input As String = "This is one line and" + vbCrLf + "this is the second."

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(Regex.Escape(match.Value))
        Next
    End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Jawne przechwytywanie tylko

Domyślnie przechwytywanie grup jest definiowane przez użycie nawiasów we wzorcu wyrażenia regularnego. Nazwane grupy mają przypisaną nazwę lub liczbę według (?<opcji języka podwyrażenia) nazwy>, natomiast grupy bez nazw są dostępne dla indeksu. GroupCollection W obiekcie nienazwane grupy poprzedzają nazwane grupy.

Konstrukcje grupowania są często używane tylko do stosowania kwantyfikatorów do wielu elementów języka, a przechwycone podciągi nie są interesujące. Jeśli na przykład następujące wyrażenie regularne:

\b\(?((\w+),?\s?)+[\.!?]\)?

ma na celu wyodrębnienie zdań kończących się kropką, wykrzyknikiem lub znakiem zapytania z dokumentu, tylko wynikowe zdanie (reprezentowane przez Match obiekt) jest interesujące. Poszczególne wyrazy w kolekcji nie są.

Przechwytywanie grup, które nie są następnie używane, może być kosztowne, ponieważ aparat wyrażeń regularnych musi wypełnić zarówno obiekty kolekcji, jak GroupCollection i CaptureCollection . Alternatywnie można użyć opcji lub wbudowanej opcji, aby określić, że jedynymi prawidłowymi przechwyceniami są jawnie nazwane lub ponumerowane grupy wyznaczone przez(?< konstrukcję podwyrażenia) nazwy>.nRegexOptions.ExplicitCapture

Poniższy przykład przedstawia informacje o dopasowaniach zwracanych przez wzorzec wyrażenia regularnego \b\(?((\w+),?\s?)+[\.!?]\)? , gdy Match metoda jest wywoływana z opcją RegexOptions.ExplicitCapture i bez tej opcji. Jak pokazuje dane wyjściowe z pierwszego wywołania metody, aparat wyrażeń regularnych w pełni wypełnia GroupCollection obiekty kolekcji i CaptureCollection informacjami o przechwyconych podciągach. Ponieważ druga metoda jest wywoływana z ustawioną wartością optionsRegexOptions.ExplicitCapture, nie przechwytuje informacji o grupach.

using System;
using System.Text.RegularExpressions;

public class Explicit1Example
{
    public static void Main()
    {
        string input = "This is the first sentence. Is it the beginning " +
                       "of a literary masterpiece? I think not. Instead, " +
                       "it is a nonsensical paragraph.";
        string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";
        Console.WriteLine("With implicit captures:");
        foreach (Match match in Regex.Matches(input, pattern))
        {
            Console.WriteLine("The match: {0}", match.Value);
            int groupCtr = 0;
            foreach (Group group in match.Groups)
            {
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
                groupCtr++;
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
                    captureCtr++;
                }
            }
        }
        Console.WriteLine();
        Console.WriteLine("With explicit captures only:");
        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.ExplicitCapture))
        {
            Console.WriteLine("The match: {0}", match.Value);
            int groupCtr = 0;
            foreach (Group group in match.Groups)
            {
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
                groupCtr++;
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
                    captureCtr++;
                }
            }
        }
    }
}
// The example displays the following output:
//    With implicit captures:
//    The match: This is the first sentence.
//       Group 0: This is the first sentence.
//          Capture 0: This is the first sentence.
//       Group 1: sentence
//          Capture 0: This
//          Capture 1: is
//          Capture 2: the
//          Capture 3: first
//          Capture 4: sentence
//       Group 2: sentence
//          Capture 0: This
//          Capture 1: is
//          Capture 2: the
//          Capture 3: first
//          Capture 4: sentence
//    The match: Is it the beginning of a literary masterpiece?
//       Group 0: Is it the beginning of a literary masterpiece?
//          Capture 0: Is it the beginning of a literary masterpiece?
//       Group 1: masterpiece
//          Capture 0: Is
//          Capture 1: it
//          Capture 2: the
//          Capture 3: beginning
//          Capture 4: of
//          Capture 5: a
//          Capture 6: literary
//          Capture 7: masterpiece
//       Group 2: masterpiece
//          Capture 0: Is
//          Capture 1: it
//          Capture 2: the
//          Capture 3: beginning
//          Capture 4: of
//          Capture 5: a
//          Capture 6: literary
//          Capture 7: masterpiece
//    The match: I think not.
//       Group 0: I think not.
//          Capture 0: I think not.
//       Group 1: not
//          Capture 0: I
//          Capture 1: think
//          Capture 2: not
//       Group 2: not
//          Capture 0: I
//          Capture 1: think
//          Capture 2: not
//    The match: Instead, it is a nonsensical paragraph.
//       Group 0: Instead, it is a nonsensical paragraph.
//          Capture 0: Instead, it is a nonsensical paragraph.
//       Group 1: paragraph
//          Capture 0: Instead,
//          Capture 1: it
//          Capture 2: is
//          Capture 3: a
//          Capture 4: nonsensical
//          Capture 5: paragraph
//       Group 2: paragraph
//          Capture 0: Instead
//          Capture 1: it
//          Capture 2: is
//          Capture 3: a
//          Capture 4: nonsensical
//          Capture 5: paragraph
//
//    With explicit captures only:
//    The match: This is the first sentence.
//       Group 0: This is the first sentence.
//          Capture 0: This is the first sentence.
//    The match: Is it the beginning of a literary masterpiece?
//       Group 0: Is it the beginning of a literary masterpiece?
//          Capture 0: Is it the beginning of a literary masterpiece?
//    The match: I think not.
//       Group 0: I think not.
//          Capture 0: I think not.
//    The match: Instead, it is a nonsensical paragraph.
//       Group 0: Instead, it is a nonsensical paragraph.
//          Capture 0: Instead, it is a nonsensical paragraph.

Imports System.Text.RegularExpressions

Module Explicit1Example
    Public Sub Main()
        Dim input As String = "This is the first sentence. Is it the beginning " +
                              "of a literary masterpiece? I think not. Instead, " +
                              "it is a nonsensical paragraph."
        Dim pattern As String = "\b\(?((?>\w+),?\s?)+[\.!?]\)?"
        Console.WriteLine("With implicit captures:")
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("The match: {0}", match.Value)
            Dim groupCtr As Integer = 0
            For Each group As Group In match.Groups
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
                groupCtr += 1
                Dim captureCtr As Integer = 0
                For Each capture As Capture In group.Captures
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
                    captureCtr += 1
                Next
            Next
        Next
        Console.WriteLine()
        Console.WriteLine("With explicit captures only:")
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.ExplicitCapture)
            Console.WriteLine("The match: {0}", match.Value)
            Dim groupCtr As Integer = 0
            For Each group As Group In match.Groups
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
                groupCtr += 1
                Dim captureCtr As Integer = 0
                For Each capture As Capture In group.Captures
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
                    captureCtr += 1
                Next
            Next
        Next
    End Sub
End Module
' The example displays the following output:
'    With implicit captures:
'    The match: This is the first sentence.
'       Group 0: This is the first sentence.
'          Capture 0: This is the first sentence.
'       Group 1: sentence
'          Capture 0: This
'          Capture 1: is
'          Capture 2: the
'          Capture 3: first
'          Capture 4: sentence
'       Group 2: sentence
'          Capture 0: This
'          Capture 1: is
'          Capture 2: the
'          Capture 3: first
'          Capture 4: sentence
'    The match: Is it the beginning of a literary masterpiece?
'       Group 0: Is it the beginning of a literary masterpiece?
'          Capture 0: Is it the beginning of a literary masterpiece?
'       Group 1: masterpiece
'          Capture 0: Is
'          Capture 1: it
'          Capture 2: the
'          Capture 3: beginning
'          Capture 4: of
'          Capture 5: a
'          Capture 6: literary
'          Capture 7: masterpiece
'       Group 2: masterpiece
'          Capture 0: Is
'          Capture 1: it
'          Capture 2: the
'          Capture 3: beginning
'          Capture 4: of
'          Capture 5: a
'          Capture 6: literary
'          Capture 7: masterpiece
'    The match: I think not.
'       Group 0: I think not.
'          Capture 0: I think not.
'       Group 1: not
'          Capture 0: I
'          Capture 1: think
'          Capture 2: not
'       Group 2: not
'          Capture 0: I
'          Capture 1: think
'          Capture 2: not
'    The match: Instead, it is a nonsensical paragraph.
'       Group 0: Instead, it is a nonsensical paragraph.
'          Capture 0: Instead, it is a nonsensical paragraph.
'       Group 1: paragraph
'          Capture 0: Instead,
'          Capture 1: it
'          Capture 2: is
'          Capture 3: a
'          Capture 4: nonsensical
'          Capture 5: paragraph
'       Group 2: paragraph
'          Capture 0: Instead
'          Capture 1: it
'          Capture 2: is
'          Capture 3: a
'          Capture 4: nonsensical
'          Capture 5: paragraph
'    
'    With explicit captures only:
'    The match: This is the first sentence.
'       Group 0: This is the first sentence.
'          Capture 0: This is the first sentence.
'    The match: Is it the beginning of a literary masterpiece?
'       Group 0: Is it the beginning of a literary masterpiece?
'          Capture 0: Is it the beginning of a literary masterpiece?
'    The match: I think not.
'       Group 0: I think not.
'          Capture 0: I think not.
'    The match: Instead, it is a nonsensical paragraph.
'       Group 0: Instead, it is a nonsensical paragraph.
'          Capture 0: Instead, it is a nonsensical paragraph.

Wzorzec\b\(?((?>\w+),?\s?)+[\.!?]\)? wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzorzec opis
\b Zacznij od granicy słowa.
\(? Dopasuj zero lub jedno wystąpienie nawiasu otwierającego ("(").
(?>\w+),? Dopasuj co najmniej jeden znak wyrazu, po którym następuje zero lub jeden przecinek. Nie cofaj się podczas dopasowywania znaków wyrazów.
\s? Dopasowanie do zera lub jednego znaku odstępu.
((\w+),?\s?)+ Dopasuj kombinację co najmniej jednego znaku wyrazu, zera lub jednego przecinka oraz zero lub jeden znak odstępu jeden lub więcej razy.
[\.!?]\)? Dopasuj dowolny z trzech symboli interpunkcyjnych, po których następuje zero lub jeden nawias zamykający (")").

Możesz również użyć elementu wbudowanego (?n) , aby pominąć automatyczne przechwytywanie. Poniższy przykład modyfikuje poprzedni wzorzec wyrażenia regularnego, aby zamiast opcji używać (?n) elementu wbudowanego RegexOptions.ExplicitCapture .

using System;
using System.Text.RegularExpressions;

public class Explicit2Example
{
    public static void Main()
    {
        string input = "This is the first sentence. Is it the beginning " +
                       "of a literary masterpiece? I think not. Instead, " +
                       "it is a nonsensical paragraph.";
        string pattern = @"(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?";

        foreach (Match match in Regex.Matches(input, pattern))
        {
            Console.WriteLine("The match: {0}", match.Value);
            int groupCtr = 0;
            foreach (Group group in match.Groups)
            {
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
                groupCtr++;
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
                    captureCtr++;
                }
            }
        }
    }
}
// The example displays the following output:
//       The match: This is the first sentence.
//          Group 0: This is the first sentence.
//             Capture 0: This is the first sentence.
//       The match: Is it the beginning of a literary masterpiece?
//          Group 0: Is it the beginning of a literary masterpiece?
//             Capture 0: Is it the beginning of a literary masterpiece?
//       The match: I think not.
//          Group 0: I think not.
//             Capture 0: I think not.
//       The match: Instead, it is a nonsensical paragraph.
//          Group 0: Instead, it is a nonsensical paragraph.
//             Capture 0: Instead, it is a nonsensical paragraph.

Imports System.Text.RegularExpressions

Module Explicit2Example
    Public Sub Main()
        Dim input As String = "This is the first sentence. Is it the beginning " +
                              "of a literary masterpiece? I think not. Instead, " +
                              "it is a nonsensical paragraph."
        Dim pattern As String = "(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?"

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("The match: {0}", match.Value)
            Dim groupCtr As Integer = 0
            For Each group As Group In match.Groups
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
                groupCtr += 1
                Dim captureCtr As Integer = 0
                For Each capture As Capture In group.Captures
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
                    captureCtr += 1
                Next
            Next
        Next
    End Sub
End Module
' The example displays the following output:
'       The match: This is the first sentence.
'          Group 0: This is the first sentence.
'             Capture 0: This is the first sentence.
'       The match: Is it the beginning of a literary masterpiece?
'          Group 0: Is it the beginning of a literary masterpiece?
'             Capture 0: Is it the beginning of a literary masterpiece?
'       The match: I think not.
'          Group 0: I think not.
'             Capture 0: I think not.
'       The match: Instead, it is a nonsensical paragraph.
'          Group 0: Instead, it is a nonsensical paragraph.
'             Capture 0: Instead, it is a nonsensical paragraph.

Na koniec możesz użyć wbudowanego elementu (?n:) grupy, aby pominąć automatyczne przechwytywanie według grupy. Poniższy przykład modyfikuje poprzedni wzorzec w celu pomijania nienazwanych przechwytywania w grupie zewnętrznej . ((?>\w+),?\s?) Należy pamiętać, że pomija on również nienazwane przechwytywanie w grupie wewnętrznej.

using System;
using System.Text.RegularExpressions;

public class Explicit3Example
{
    public static void Main()
    {
        string input = "This is the first sentence. Is it the beginning " +
                       "of a literary masterpiece? I think not. Instead, " +
                       "it is a nonsensical paragraph.";
        string pattern = @"\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?";

        foreach (Match match in Regex.Matches(input, pattern))
        {
            Console.WriteLine("The match: {0}", match.Value);
            int groupCtr = 0;
            foreach (Group group in match.Groups)
            {
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
                groupCtr++;
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
                    captureCtr++;
                }
            }
        }
    }
}
// The example displays the following output:
//       The match: This is the first sentence.
//          Group 0: This is the first sentence.
//             Capture 0: This is the first sentence.
//       The match: Is it the beginning of a literary masterpiece?
//          Group 0: Is it the beginning of a literary masterpiece?
//             Capture 0: Is it the beginning of a literary masterpiece?
//       The match: I think not.
//          Group 0: I think not.
//             Capture 0: I think not.
//       The match: Instead, it is a nonsensical paragraph.
//          Group 0: Instead, it is a nonsensical paragraph.
//             Capture 0: Instead, it is a nonsensical paragraph.

Imports System.Text.RegularExpressions

Module Explicit3Example
    Public Sub Main()
        Dim input As String = "This is the first sentence. Is it the beginning " +
                              "of a literary masterpiece? I think not. Instead, " +
                              "it is a nonsensical paragraph."
        Dim pattern As String = "\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?"

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("The match: {0}", match.Value)
            Dim groupCtr As Integer = 0
            For Each group As Group In match.Groups
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
                groupCtr += 1
                Dim captureCtr As Integer = 0
                For Each capture As Capture In group.Captures
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
                    captureCtr += 1
                Next
            Next
        Next
    End Sub
End Module
' The example displays the following output:
'       The match: This is the first sentence.
'          Group 0: This is the first sentence.
'             Capture 0: This is the first sentence.
'       The match: Is it the beginning of a literary masterpiece?
'          Group 0: Is it the beginning of a literary masterpiece?
'             Capture 0: Is it the beginning of a literary masterpiece?
'       The match: I think not.
'          Group 0: I think not.
'             Capture 0: I think not.
'       The match: Instead, it is a nonsensical paragraph.
'          Group 0: Instead, it is a nonsensical paragraph.
'             Capture 0: Instead, it is a nonsensical paragraph.

Skompilowane wyrażenia regularne

Uwaga

Jeśli to możliwe, użyj źródłowych wyrażeń regularnych generowanych zamiast kompilowania wyrażeń regularnych przy użyciu RegexOptions.Compiled opcji . Generowanie źródła może pomóc aplikacji szybciej rozpocząć pracę, szybciej działać i być bardziej przycinane. Aby dowiedzieć się, kiedy jest możliwe generowanie źródła, zobacz Kiedy go używać.

Domyślnie wyrażenia regularne na platformie .NET są interpretowane. Po utworzeniu Regex wystąpienia obiektu lub wywołaniu metody statycznej Regex wzorzec wyrażenia regularnego jest analizowany w zestawie niestandardowych kodów operacji, a interpreter używa tych kodów opcode do uruchamiania wyrażenia regularnego. Wiąże się to z kompromisem: koszt inicjowania aparatu wyrażeń regularnych jest zminimalizowany kosztem wydajności w czasie wykonywania.

Można użyć skompilowanych zamiast interpretowanych wyrażeń regularnych przy użyciu RegexOptions.Compiled opcji . W takim przypadku, gdy wzorzec jest przekazywany do aparatu wyrażeń regularnych, jest analizowany w zestawie kodów operacji, a następnie konwertowany na wspólny język pośredni (CIL), który można przekazać bezpośrednio do środowiska uruchomieniowego języka wspólnego. Skompilowane wyrażenia regularne maksymalizują wydajność czasu wykonywania kosztem czasu inicjowania.

Uwaga

Wyrażenie regularne można skompilować tylko przez RegexOptions.Compiled podanie wartości do options parametru Regex konstruktora klasy lub statycznej metody dopasowywania wzorca. Nie jest dostępna jako opcja śródliniowa.

Skompilowane wyrażenia regularne można używać w wywołaniach zarówno do wyrażeń regularnych statycznych, jak i wystąpień. W statycznych wyrażeniach regularnych RegexOptions.Compiled opcja jest przekazywana do options parametru metody dopasowywania wzorca wyrażenia regularnego. W przypadku wyrażeń regularnych jest przekazywany do options parametru konstruktora Regex klasy. W obu przypadkach skutkuje to zwiększoną wydajnością.

Jednak ta poprawa wydajności występuje tylko w następujących warunkach:

  • Regex Obiekt reprezentujący określone wyrażenie regularne jest używany w wielu wywołaniach do metod dopasowywania wzorców wyrażeń regularnych.

  • Obiekt Regex nie może wykraczać poza zakres, więc można go użyć ponownie.

  • Statyczne wyrażenie regularne jest używane w wielu wywołaniach do metod dopasowywania wzorców wyrażeń regularnych. (Poprawa wydajności jest możliwa, ponieważ wyrażenia regularne używane w wywołaniach metod statycznych są buforowane przez aparat wyrażeń regularnych).

Uwaga

Opcja RegexOptions.Compiled nie jest powiązana z Regex.CompileToAssembly metodą, która tworzy zestaw specjalnego przeznaczenia, który zawiera wstępnie zdefiniowane skompilowane wyrażenia regularne.

Ignoruj białe znaki

Domyślnie białe znaki we wzorcu wyrażenia regularnego są znaczące; wymusza dopasowanie aparatu wyrażeń regularnych do znaku odstępu w ciągu wejściowym. W związku z tym wyrażenia regularne "\b\w+\s" i "\b\w+ " są w przybliżeniu równoważne wyrażenia regularne. Ponadto, gdy znak numeru (#) występuje we wzorcu wyrażenia regularnego, jest interpretowany jako znak literału, który ma być dopasowany.

Opcja RegexOptions.IgnorePatternWhitespace lub opcja śródliniowa x zmienia to domyślne zachowanie w następujący sposób:

  • Niezasłane białe znaki we wzorcu wyrażenia regularnego są ignorowane. Aby być częścią wzorca wyrażenia regularnego, znaki odstępu muszą zostać uniknięte (na przykład jako \s lub "\ ").

  • Znak numeru (#) jest interpretowany jako początek komentarza, a nie jako znak literału. Cały tekst we wzorcu wyrażenia regularnego # od znaku do następnego \n znaku lub na końcu ciągu jest interpretowany jako komentarz.

Jednak w następujących przypadkach znaki odstępu w wyrażeniu regularnym nie są ignorowane, nawet jeśli używasz RegexOptions.IgnorePatternWhitespace opcji:

  • Białe znaki w klasie znaków są zawsze interpretowane dosłownie. Na przykład wzorzec [ .,;:] wyrażenia regularnego pasuje do każdego pojedynczego znaku odstępu, kropki, przecinka, średnika lub dwukropka.

  • Białe znaki nie są dozwolone w kwantyfikatorze nawiasów, takich jak {n}, {n,} i {n,m.} Na przykład wzorzec \d{1, 3} wyrażenia regularnego nie pasuje do wszystkich sekwencji cyfr z jednej do trzech cyfr, ponieważ zawiera znak odstępu.

  • Białe znaki nie są dozwolone w sekwencji znaków, która wprowadza element języka. Na przykład:

    • Podwyrażenie) elementu (?:języka reprezentuje nieuwzwoloną grupę, a (?: część elementu nie może mieć osadzonych spacji. Podexpression) wzorca (? :zgłasza ArgumentException wyjątek w czasie wykonywania, ponieważ aparat wyrażeń regularnych nie może przeanalizować wzorca, a podexpression) wzorca( ?: nie pasuje do podwyrażu podrzędnego.

    • Nazwa} elementu \p{języka, która reprezentuje kategorię Unicode lub nazwany blok, nie może zawierać osadzonych spacji w \p{ części elementu. Jeśli dołączysz biały znak, element zgłasza ArgumentException błąd w czasie wykonywania.

Włączenie tej opcji ułatwia uproszczenie wyrażeń regularnych, które często są trudne do analizowania i zrozumienia. Poprawia czytelność i umożliwia dokumentowanie wyrażenia regularnego.

W poniższym przykładzie zdefiniowano następujący wzorzec wyrażenia regularnego:

\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.

Ten wzorzec jest podobny do wzorca zdefiniowanego w sekcji Jawne przechwytywanie tylko , z tą różnicą, że używa RegexOptions.IgnorePatternWhitespace opcji ignorowania białych znaków wzorca.

using System;
using System.Text.RegularExpressions;

public class Whitespace1Example
{
    public static void Main()
    {
        string input = "This is the first sentence. Is it the beginning " +
                       "of a literary masterpiece? I think not. Instead, " +
                       "it is a nonsensical paragraph.";
        string pattern = @"\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.";

        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace))
            Console.WriteLine(match.Value);
    }
}
// The example displays the following output:
//       This is the first sentence.
//       Is it the beginning of a literary masterpiece?
//       I think not.
//       Instead, it is a nonsensical paragraph.

Imports System.Text.RegularExpressions

Module Whitespace1Example
    Public Sub Main()
        Dim input As String = "This is the first sentence. Is it the beginning " +
                              "of a literary masterpiece? I think not. Instead, " +
                              "it is a nonsensical paragraph."
        Dim pattern As String = "\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence."

        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       This is the first sentence.
'       Is it the beginning of a literary masterpiece?
'       I think not.
'       Instead, it is a nonsensical paragraph.

W poniższym przykładzie użyto opcji (?x) wbudowanej, aby zignorować biały znak wzorca.

using System;
using System.Text.RegularExpressions;

public class Whitespace2Example
{
    public static void Main()
    {
        string input = "This is the first sentence. Is it the beginning " +
                       "of a literary masterpiece? I think not. Instead, " +
                       "it is a nonsensical paragraph.";
        string pattern = @"(?x)\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence.";

        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine(match.Value);
    }
}
// The example displays the following output:
//       This is the first sentence.
//       Is it the beginning of a literary masterpiece?
//       I think not.
//       Instead, it is a nonsensical paragraph.

Imports System.Text.RegularExpressions

Module Whitespace2Example
    Public Sub Main()
        Dim input As String = "This is the first sentence. Is it the beginning " +
                              "of a literary masterpiece? I think not. Instead, " +
                              "it is a nonsensical paragraph."
        Dim pattern As String = "(?x)\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence."

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       This is the first sentence.
'       Is it the beginning of a literary masterpiece?
'       I think not.
'       Instead, it is a nonsensical paragraph.

Tryb od prawej do lewej

Domyślnie aparat wyrażeń regularnych wyszukuje od lewej do prawej. Kierunek wyszukiwania można odwrócić przy użyciu RegexOptions.RightToLeft opcji . Wyszukiwanie od prawej do lewej automatycznie rozpoczyna się od ostatniego położenia znaku ciągu. W przypadku metod dopasowywania wzorców, które zawierają parametr pozycji początkowej, na Regex.Match(String, Int32)przykład , określona pozycja początkowa jest indeksem najbardziej prawego położenia znaku, na którym należy rozpocząć wyszukiwanie.

Uwaga

Tryb wzorca od prawej do lewej jest dostępny tylko przez RegexOptions.RightToLeft podanie wartości do options parametru Regex konstruktora klasy lub metody dopasowania statycznego wzorca. Nie jest dostępna jako opcja śródliniowa.

Przykład

Wyrażenie \bb\w+\s regularne pasuje do wyrazów z co najmniej dwoma znakami rozpoczynającymi się literą "b" i następuje znak odstępu. W poniższym przykładzie ciąg wejściowy składa się z trzech wyrazów zawierających co najmniej jeden znak "b". Pierwsze i drugie wyrazy zaczynają się od "b", a trzecie słowo kończy się wyrazem "b". Jak pokazano w przykładzie wyszukiwania od prawej do lewej, tylko pierwsze i drugie wyrazy są zgodne ze wzorcem wyrażenia regularnego, a drugie słowo jest dopasowywane jako pierwsze.

using System;
using System.Text.RegularExpressions;

public class RTL1Example
{
    public static void Main()
    {
        string pattern = @"\bb\w+\s";
        string input = "build band tab";
        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.RightToLeft))
            Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
    }
}
// The example displays the following output:
//       'band ' found at position 6.
//       'build ' found at position 0.

Imports System.Text.RegularExpressions

Module RTL1Example
    Public Sub Main()
        Dim pattern As String = "\bb\w+\s"
        Dim input As String = "build band tab"
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.RightToLeft)
            Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       'band ' found at position 6.
'       'build ' found at position 0.

Kolejność oceny

Opcja RegexOptions.RightToLeft zmienia kierunek wyszukiwania, a także odwraca kolejność oceniania wzorca wyrażenia regularnego. W wyszukiwaniu od prawej do lewej wzorzec wyszukiwania jest odczytywany od prawej do lewej. To rozróżnienie jest ważne, ponieważ może mieć wpływ na takie elementy jak grupy przechwytywania i wnioskowania wsteczne. Na przykład wyrażenie Regex.Match("abcabc", @"\1(abc)", RegexOptions.RightToLeft) znajduje dopasowanie abcabc, ale w wyszukiwaniu od lewej do prawej (Regex.Match("abcabc", @"\1(abc)", RegexOptions.None)) nie można odnaleźć dopasowania. Wynika to z faktu (abc) , że element musi zostać oceniony przed znalezionym elementem grupy przechwytywania numerowanego (\1).

Lookahead i asercji lookbehind

Lokalizacja dopasowania dla asercji lookahead ((?=subexpression)) lub lookbehind ((?<=subexpression)) nie zmienia się w wyszukiwaniu od prawej do lewej. Asercji lookahead wyglądają na prawo od bieżącej lokalizacji dopasowania; asercji lookbehind wyglądają po lewej stronie bieżącej lokalizacji dopasowania.

Napiwek

Niezależnie od tego, czy wyszukiwanie jest od prawej do lewej, czy nie, wyszukiwanie jest implementowane przy użyciu wyszukiwania od prawej do lewej, zaczynając od bieżącej lokalizacji dopasowania.

Na przykład wyrażenie (?<=\d{1,2}\s)\w+,\s\d{4} regularne używa asercji lookbehind do przetestowania daty poprzedzającej nazwę miesiąca. Wyrażenie regularne jest następnie zgodne z miesiącem i rokiem. Aby uzyskać informacje na temat asercji lookahead i lookbehind, zobacz Grouping Constructs (Konstrukcje grupowania).

using System;
using System.Text.RegularExpressions;

public class RTL2Example
{
    public static void Main()
    {
        string[] inputs = { "1 May, 1917", "June 16, 2003" };
        string pattern = @"(?<=\d{1,2}\s)\w+,\s\d{4}";

        foreach (string input in inputs)
        {
            Match match = Regex.Match(input, pattern, RegexOptions.RightToLeft);
            if (match.Success)
                Console.WriteLine("The date occurs in {0}.", match.Value);
            else
                Console.WriteLine("{0} does not match.", input);
        }
    }
}

// The example displays the following output:
//       The date occurs in May, 1917.
//       June 16, 2003 does not match.

Imports System.Text.RegularExpressions

Module RTL2Example
    Public Sub Main()
        Dim inputs() As String = {"1 May, 1917", "June 16, 2003"}
        Dim pattern As String = "(?<=\d{1,2}\s)\w+,\s\d{4}"

        For Each input As String In inputs
            Dim match As Match = Regex.Match(input, pattern, RegexOptions.RightToLeft)
            If match.Success Then
                Console.WriteLine("The date occurs in {0}.", match.Value)
            Else
                Console.WriteLine("{0} does not match.", input)
            End If
        Next
    End Sub
End Module

' The example displays the following output:
'       The date occurs in May, 1917.
'       June 16, 2003 does not match.

Wzorzec wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzorzec opis
(?<=\d{1,2}\s) Początek dopasowania musi być poprzedzony jedną lub dwiema cyframi dziesiętnym, po których następuje spacja.
\w+ Dopasowuje co najmniej jeden znak słowa.
, Dopasuj jeden znak przecinka.
\s Dopasowuje znak odstępu.
\d{4} Dopasuj cztery cyfry dziesiętne.

Zachowanie dopasowania w języku ECMAScript

Domyślnie aparat wyrażeń regularnych używa zachowania kanonicznego podczas dopasowywania wzorca wyrażenia regularnego do tekstu wejściowego. Można jednak poinstruować aparat wyrażeń regularnych, aby używał pasującego zachowania ECMAScript, określając RegexOptions.ECMAScript opcję.

Uwaga

Zachowanie zgodne ze standardem ECMAScript jest dostępne tylko przez podanie RegexOptions.ECMAScript wartości options do parametru Regex konstruktora klasy lub metody dopasowania statycznego wzorca. Nie jest dostępna jako opcja śródliniowa.

Tę RegexOptions.ECMAScript opcję można połączyć tylko z opcjami RegexOptions.IgnoreCase i RegexOptions.Multiline . Użycie dowolnej innej opcji w wyrażeniu regularnym powoduje wyświetlenie elementu ArgumentOutOfRangeException.

Zachowanie języka ECMAScript i kanonicznych wyrażeń regularnych różni się w trzech obszarach: składnia klasy znaków, samoodwoływanie się do grup przechwytywania oraz interpretacja ósemkowego i wstecznego.

  • Składnia klasy znaków. Ponieważ kanoniczne wyrażenia regularne obsługują kod Unicode, natomiast klasa ECMAScript nie, klasy znaków w języku ECMAScript mają bardziej ograniczoną składnię, a niektóre elementy języka klas znaków mają inne znaczenie. Na przykład kod ECMAScript nie obsługuje elementów języka, takich jak kategoria Unicode lub elementy \p blokowe i \P. Podobnie element, \w który pasuje do [a-zA-Z_0-9] znaku słowa, jest odpowiednikiem klasy znaków podczas korzystania z ecMAScript i [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] podczas korzystania z zachowania kanonicznego. Aby uzyskać więcej informacji, zobacz Klasy znaków.

    Poniższy przykład ilustruje różnicę między dopasowaniem wzorca canonical i ECMAScript. Definiuje wyrażenie regularne , \b(\w+\s*)+które pasuje do wyrazów, po których następują znaki odstępu. Dane wejściowe składają się z dwóch ciągów, jeden, który używa zestawu znaków łacińskich, a drugi, który używa zestawu znaków cyrylica. Jak pokazano w danych wyjściowych, wywołanie Regex.IsMatch(String, String, RegexOptions) metody używającej dopasowania ECMAScript nie pasuje do wyrazów cyrylica, natomiast wywołanie metody używające dopasowania kanonicznego jest zgodne z tymi słowami.

    using System;
using System.Text.RegularExpressions;

public class EcmaScriptExample
{
    public static void Main()
    {
        string[] values = { "целый мир", "the whole world" };
        string pattern = @"\b(\w+\s*)+";
        foreach (var value in values)
        {
            Console.Write("Canonical matching: ");
            if (Regex.IsMatch(value, pattern))
                Console.WriteLine("'{0}' matches the pattern.", value);
            else
                Console.WriteLine("{0} does not match the pattern.", value);

            Console.Write("ECMAScript matching: ");
            if (Regex.IsMatch(value, pattern, RegexOptions.ECMAScript))
                Console.WriteLine("'{0}' matches the pattern.", value);
            else
                Console.WriteLine("{0} does not match the pattern.", value);
            Console.WriteLine();
        }
    }
}
// The example displays the following output:
//       Canonical matching: 'целый мир' matches the pattern.
//       ECMAScript matching: целый мир does not match the pattern.
//
//       Canonical matching: 'the whole world' matches the pattern.
//       ECMAScript matching: 'the whole world' matches the pattern.

    Imports System.Text.RegularExpressions

Module Ecma1Example
    Public Sub Main()
        Dim values() As String = {"целый мир", "the whole world"}
        Dim pattern As String = "\b(\w+\s*)+"
        For Each value In values
            Console.Write("Canonical matching: ")
            If Regex.IsMatch(value, pattern) Then
                Console.WriteLine("'{0}' matches the pattern.", value)
            Else
                Console.WriteLine("{0} does not match the pattern.", value)
            End If

            Console.Write("ECMAScript matching: ")
            If Regex.IsMatch(value, pattern, RegexOptions.ECMAScript) Then
                Console.WriteLine("'{0}' matches the pattern.", value)
            Else
                Console.WriteLine("{0} does not match the pattern.", value)
            End If
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       Canonical matching: 'целый мир' matches the pattern.
'       ECMAScript matching: целый мир does not match the pattern.
'       
'       Canonical matching: 'the whole world' matches the pattern.
'       ECMAScript matching: 'the whole world' matches the pattern.

  • Samodzielne odwoływanie się do grup przechwytywania. Klasa przechwytywania wyrażeń regularnych z odwołaniem do siebie musi zostać zaktualizowana przy użyciu każdej iteracji przechwytywania. Jak pokazano w poniższym przykładzie, ta funkcja umożliwia wyrażeniu ((a+)(\1) ?)+ regularnym dopasowanie ciągu wejściowego "a aa" w przypadku używania kodu ECMAScript, ale nie w przypadku używania dopasowania kanonicznego.

    using System;
using System.Text.RegularExpressions;

public class EcmaScript2Example
{
    static string pattern;

    public static void Main()
    {
        string input = "aa aaaa aaaaaa ";
        pattern = @"((a+)(\1) ?)+";

        // Match input using canonical matching.
        AnalyzeMatch(Regex.Match(input, pattern));

        // Match input using ECMAScript.
        AnalyzeMatch(Regex.Match(input, pattern, RegexOptions.ECMAScript));
    }

    private static void AnalyzeMatch(Match m)
    {
        if (m.Success)
        {
            Console.WriteLine("'{0}' matches {1} at position {2}.",
                              pattern, m.Value, m.Index);
            int grpCtr = 0;
            foreach (Group grp in m.Groups)
            {
                Console.WriteLine("   {0}: '{1}'", grpCtr, grp.Value);
                grpCtr++;
                int capCtr = 0;
                foreach (Capture cap in grp.Captures)
                {
                    Console.WriteLine("      {0}: '{1}'", capCtr, cap.Value);
                    capCtr++;
                }
            }
        }
        else
        {
            Console.WriteLine("No match found.");
        }
        Console.WriteLine();
    }
}
// The example displays the following output:
//    No match found.
//
//    '((a+)(\1) ?)+' matches aa aaaa aaaaaa  at position 0.
//       0: 'aa aaaa aaaaaa '
//          0: 'aa aaaa aaaaaa '
//       1: 'aaaaaa '
//          0: 'aa '
//          1: 'aaaa '
//          2: 'aaaaaa '
//       2: 'aa'
//          0: 'aa'
//          1: 'aa'
//          2: 'aa'
//       3: 'aaaa '
//          0: ''
//          1: 'aa '
//          2: 'aaaa '

    Imports System.Text.RegularExpressions

Module Ecma2Example
    Dim pattern As String

    Public Sub Main()
        Dim input As String = "aa aaaa aaaaaa "
        pattern = "((a+)(\1) ?)+"

        ' Match input using canonical matching.
        AnalyzeMatch(Regex.Match(input, pattern))

        ' Match input using ECMAScript.
        AnalyzeMatch(Regex.Match(input, pattern, RegexOptions.ECMAScript))
    End Sub

    Private Sub AnalyzeMatch(m As Match)
        If m.Success Then
            Console.WriteLine("'{0}' matches {1} at position {2}.",
                              pattern, m.Value, m.Index)
            Dim grpCtr As Integer = 0
            For Each grp As Group In m.Groups
                Console.WriteLine("   {0}: '{1}'", grpCtr, grp.Value)
                grpCtr += 1
                Dim capCtr As Integer = 0
                For Each cap As Capture In grp.Captures
                    Console.WriteLine("      {0}: '{1}'", capCtr, cap.Value)
                    capCtr += 1
                Next
            Next
        Else
            Console.WriteLine("No match found.")
        End If
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'    No match found.
'    
'    '((a+)(\1) ?)+' matches aa aaaa aaaaaa  at position 0.
'       0: 'aa aaaa aaaaaa '
'          0: 'aa aaaa aaaaaa '
'       1: 'aaaaaa '
'          0: 'aa '
'          1: 'aaaa '
'          2: 'aaaaaa '
'       2: 'aa'
'          0: 'aa'
'          1: 'aa'
'          2: 'aa'
'       3: 'aaaa '
'          0: ''
'          1: 'aa '
'          2: 'aaaa '

    Wyrażenie regularne jest definiowane, jak pokazano w poniższej tabeli.

    Wzorzec opis
    (a+) Dopasuj literę "a" co najmniej raz. Jest to druga grupa przechwytywania.
    (\1) Dopasuj podciąg przechwycony przez pierwszą grupę przechwytywania. Jest to trzecia grupa przechwytywania.
    ? Dopasuj zero lub jeden znak spacji.
    ((a+)(\1) ?) + Dopasuj wzorzec co najmniej jednego znaku "a", po którym następuje ciąg zgodny z pierwszą grupą przechwytywania, po której następuje zero lub jeden znak spacji jeden lub więcej razy. Jest to pierwsza grupa przechwytywania.

  • Rozpoznawanie niejednoznaczności między ucieczkami ósemkowymi i backreferences. W poniższej tabeli przedstawiono podsumowanie różnic w interpretacji ósemkowej i wstecznej według wyrażeń regularnych canonical i ECMAScript.

    Regular expression Zachowanie kanoniczne Zachowanie ecMAScript
    \0 po 0 do 2 cyfr ósemkowej Interpretowanie jako ósemka. Na przykład \044 wartość ósemkowa jest zawsze interpretowana jako wartość ósemkowa i oznacza "$". To samo zachowanie.
    \ cyfra z zakresu od 1 do 9, po której nie ma dodatkowych cyfr dziesiętnych, Interpretowanie jako wnioskowania wstecznego. Na przykład \9 zawsze oznacza backreference 9, nawet jeśli dziewiąta grupa przechwytywania nie istnieje. Jeśli grupa przechwytywania nie istnieje, analizator wyrażeń regularnych zgłasza wartość ArgumentException. Jeśli istnieje pojedyncza cyfra dziesiętna przechwytujący grupę, odroczenie do tej cyfry. W przeciwnym razie zinterpretuj wartość jako literał.
    \ cyfra z zakresu od 1 do 9, po której następuje dodatkowe cyfry dziesiętne Interpretuj cyfry jako wartość dziesiętną. Jeśli grupa przechwytywania istnieje, zinterpretuj wyrażenie jako wnioskowanie wsteczne.

    W przeciwnym razie zinterpretuj wiodące cyfry ósemkowe do ósemki 377; oznacza to, że należy wziąć pod uwagę tylko małe 8 bitów wartości. Interpretowanie pozostałych cyfr jako literałów. Na przykład w wyrażeniu \3000, jeśli przechwytywanie grupy 300 istnieje, zinterpretuj jako backreference 300; jeśli przechwytywanie grupy 300 nie istnieje, zinterpretuj jako ósemk 300, a następnie 0.    		 Interpretuj jako wnioskowanie wsteczne, konwertując jak najwięcej cyfr na wartość dziesiętną, która może odwoływać się do przechwytywania. Jeśli nie można przekonwertować cyfr, zinterpretuj jako ósemkową, używając wiodących cyfr ósemkowych do ósemki 377; interpretować pozostałe cyfry jako literały.

Porównywanie przy użyciu niezmiennej kultury

Domyślnie gdy aparat wyrażeń regularnych wykonuje porównania bez uwzględniania wielkości liter, używa konwencji wielkości liter bieżącej kultury w celu określenia równoważnych wielkich i małych liter.

Jednak to zachowanie jest niepożądane w przypadku niektórych typów porównań, szczególnie w przypadku porównywania danych wejściowych użytkownika z nazwami zasobów systemowych, takich jak hasła, pliki lub adresy URL. Poniższy przykład ilustruje taki scenariusz. Kod jest przeznaczony do blokowania dostępu do dowolnego zasobu, którego adres URL jest poprzedzony FILE://. Wyrażenie regularne próbuje dopasować wielkość liter z ciągiem przy użyciu wyrażenia $FILE://regularnego . Jednak gdy obecna kultura systemowa jest tr-TR (Turkish-Türkiye), "I" nie jest wielkim odpowiednikiem "i". W związku z tym wywołanie Regex.IsMatch metody zwraca falsemetodę , a dostęp do pliku jest dozwolony.

CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");

string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";

Console.WriteLine("Culture-sensitive matching ({0} culture)...",
                  Thread.CurrentThread.CurrentCulture.Name);
if (Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase))
    Console.WriteLine("URLs that access files are not allowed.");
else
    Console.WriteLine("Access to {0} is allowed.", input);

Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
//       Culture-sensitive matching (tr-TR culture)...
//       Access to file://c:/Documents.MyReport.doc is allowed.

Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")

Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"

Console.WriteLine("Culture-sensitive matching ({0} culture)...",
                  Thread.CurrentThread.CurrentCulture.Name)
If Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase) Then
    Console.WriteLine("URLs that access files are not allowed.")
Else
    Console.WriteLine("Access to {0} is allowed.", input)
End If

Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
'       Culture-sensitive matching (tr-TR culture)...
'       Access to file://c:/Documents.MyReport.doc is allowed.

Uwaga

Aby uzyskać więcej informacji na temat porównań ciągów, które są wrażliwe na wielkość liter i które używają niezmiennej kultury, zobacz Najlepsze rozwiązania dotyczące używania ciągów.

Zamiast używać porównań bez uwzględniania wielkości liter w bieżącej kulturze, można określić RegexOptions.CultureInvariant opcję ignorowania różnic kulturowych w języku i używania konwencji niezmiennej kultury.

Uwaga

Porównanie przy użyciu niezmiennej kultury jest dostępne tylko przez podanie RegexOptions.CultureInvariant wartości do options parametru Regex konstruktora klasy lub metody dopasowania wzorca statycznego. Nie jest dostępna jako opcja śródliniowa.

Poniższy przykład jest identyczny z poprzednim przykładem, z tą różnicą, że metoda statyczna Regex.IsMatch(String, String, RegexOptions) jest wywoływana z opcjami, które obejmują RegexOptions.CultureInvariant. Nawet jeśli bieżąca kultura jest ustawiona na turecki (Türkiye), aparat wyrażeń regularnych może pomyślnie dopasować wartość "FILE" i "file" i zablokować dostęp do zasobu pliku.

CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");

string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";

Console.WriteLine("Culture-insensitive matching...");
if (Regex.IsMatch(input, pattern,
                  RegexOptions.IgnoreCase | RegexOptions.CultureInvariant))
    Console.WriteLine("URLs that access files are not allowed.");
else
    Console.WriteLine("Access to {0} is allowed.", input);

Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
//       Culture-insensitive matching...
//       URLs that access files are not allowed.

Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")

Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"

Console.WriteLine("Culture-insensitive matching...")
If Regex.IsMatch(input, pattern,
               RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant) Then
    Console.WriteLine("URLs that access files are not allowed.")
Else
    Console.WriteLine("Access to {0} is allowed.", input)
End If
Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
'        Culture-insensitive matching...
'        URLs that access files are not allowed.

Tryb niepowodzeń śledzenia

Domyślnie . Aparat wyrażeń regularnych platformy NET używa wycofywania , aby spróbować znaleźć dopasowania wzorca. Aparat wycofywania jest taki, który próbuje dopasować jeden wzorzec, a jeśli to się nie powiedzie, wraca i próbuje dopasować alternatywny wzorzec itd. Aparat wycofywania jest bardzo szybki w typowych przypadkach, ale spowalnia w miarę wzrostu liczby zmian wzorców, co może prowadzić do katastrofalnego wycofywania. Opcja RegexOptions.NonBacktracking , która została wprowadzona na platformie .NET 7, nie używa wycofywania i pozwala uniknąć tego scenariusza najgorszego przypadku. Jego celem jest zapewnienie spójnego dobrego zachowania, niezależnie od wyszukiwanych danych wejściowych.

Opcja RegexOptions.NonBacktracking nie obsługuje wszystkich innych wbudowanych aparatów. W szczególności nie można użyć opcji w połączeniu z lub RegexOptions.RightToLeftRegexOptions.ECMAScript. Nie zezwala również na następujące konstrukcje we wzorcu:

  • Grupy niepodzielne
  • Odwołania wsteczne
  • Równoważenie grup
  • Wyrażenia warunkowe
  • Lookarounds
  • Uruchamianie kotwic (\G)

RegexOptions.NonBacktracking ma również subtelną różnicę w odniesieniu do wykonywania. Jeśli grupa przechwytywania znajduje się w pętli, większość (non-.NET) aparatów wyrażeń regularnych udostępnia tylko ostatnią dopasowaną wartość tego przechwytywania. Jednak. Aparat wyrażeń regularnych platformy NET śledzi wszystkie wartości przechwycone wewnątrz pętli i zapewniają dostęp do nich. Opcja RegexOptions.NonBacktracking jest jak większość innych implementacji wyrażeń regularnych i obsługuje tylko dostarczanie końcowego przechwytywania.

Aby uzyskać więcej informacji na temat wycofywania, zobacz Wycofywanie w wyrażeniach regularnych.

Zobacz też