Opties voor reguliere expressies

Artikel
08/15/2023

De vergelijking van een invoertekenreeks met letterlijke tekens in een reguliere expressiepatroon is standaard hoofdlettergevoelig, witruimte in een reguliere expressiepatroon wordt geïnterpreteerd als letterlijke witruimtetekens en het vastleggen van groepen in een reguliere expressie wordt impliciet en expliciet benoemd. U kunt deze en verschillende andere aspecten van het standaardgedrag van reguliere expressies wijzigen door reguliere expressieopties op te geven. Sommige van deze opties, die worden vermeld in de volgende tabel, kunnen inline worden opgenomen als onderdeel van het reguliere expressiepatroon, of ze kunnen worden geleverd aan een System.Text.RegularExpressions.Regex klasseconstructor of statische patroonkoppelingsmethode als opsommingswaarde System.Text.RegularExpressions.RegexOptions .

`RegexOptions` lid	Inlineteken	Effect	Meer informatie
None	Niet beschikbaar	Standaardgedrag gebruiken.	Standaardopties
IgnoreCase	`i`	Gebruik hoofdlettergevoelige overeenkomsten.	Hoofdlettergevoelige overeenkomsten
Multiline	`m`	Gebruik de modus met meerdere regels, waarbij `^` het `$` begin en einde van elke regel worden aangegeven (in plaats van het begin en einde van de invoertekenreeks).	Modus met meerdere regels
Singleline	`s`	Gebruik de modus met één regel, waarbij de punt (.) overeenkomt met elk teken (in plaats van elk teken behalve `\n`).	Modus met één regel
ExplicitCapture	`n`	Leg geen niet-benoemde groepen vast. De enige geldige opnamen zijn expliciet benoemde of genummerde groepen van de subexpressie van de formuliernaam`(?<``>`.`)`	Alleen expliciete opnamen
Compiled	Niet beschikbaar	Compileer de reguliere expressie naar een assembly.	Gecompileerde reguliere expressies
IgnorePatternWhitespace	`x`	Sluit niet-gescaped witruimte uit van het patroon en schakel opmerkingen in na een nummerteken (`#`).	Witruimte negeren
RightToLeft	Niet beschikbaar	Wijzig de zoekrichting. Zoeken wordt verplaatst van rechts naar links in plaats van van van links naar rechts.	Modus Van rechts naar links
ECMAScript	Niet beschikbaar	Schakel het gedrag van ECMAScript-compatibel in voor de expressie.	ECMAScript-overeenkomend gedrag
CultureInvariant	Niet beschikbaar	Culturele verschillen in taal negeren.	Vergelijking met behulp van de invariante cultuur
NonBacktracking	Niet beschikbaar	Match met behulp van een benadering die backtracking vermijdt en lineaire tijdverwerking garandeert in de lengte van de invoer. (Beschikbaar in .NET 7 en latere versies.)	Niet-backtrackingmodus

Opties opgeven

U kunt op drie manieren opties opgeven voor reguliere expressies:

In de options parameter van een System.Text.RegularExpressions.Regex klasseconstructor of statische (Shared in Visual Basic) patroonkoppelingsmethode, zoals Regex(String, RegexOptions) of Regex.Match(String, String, RegexOptions). De options parameter is een bitsgewijze OF-combinatie van System.Text.RegularExpressions.RegexOptions geïnventareerde waarden.

Wanneer opties aan een Regex exemplaar worden geleverd met behulp van de options parameter van een klasseconstructor, worden de opties toegewezen aan de System.Text.RegularExpressions.RegexOptions eigenschap. De System.Text.RegularExpressions.RegexOptions eigenschap weerspiegelt echter geen inlineopties in het reguliere expressiepatroon zelf.

In het volgende voorbeeld ziet u een afbeelding. Hierbij wordt de options parameter van de Regex.Match(String, String, RegexOptions) methode gebruikt om hoofdlettergevoelige overeenkomsten mogelijk te maken en om witruimte voor patronen te negeren bij het identificeren van woorden die beginnen met de letter '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.      
```
Door inlineopties toe te passen in een normaal expressiepatroon met de syntaxis (?imnsx-imnsx). De optie is van toepassing op het patroon vanaf het punt dat de optie is gedefinieerd aan het einde van het patroon of op het punt waarop de optie niet is gedefinieerd door een andere inline-optie. Houd er rekening mee dat de System.Text.RegularExpressions.RegexOptions eigenschap van een Regex exemplaar deze inlineopties niet weergeeft. Zie het onderwerp Diverse constructies voor meer informatie.

In het volgende voorbeeld ziet u een afbeelding. Er worden inlineopties gebruikt om hoofdlettergevoelige overeenkomsten mogelijk te maken en om witruimte voor patronen te negeren bij het identificeren van woorden die beginnen met de letter '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.      
```
Door inlineopties toe te passen in een bepaalde groeperingsconstructie in een normaal expressiepatroon met de syntaxissubexpressie(?imnsx-imnsx:). Geen teken voordat een set opties de set inschakelt; een minteken voordat een set opties de set uitschakelt. (? is een vast onderdeel van de syntaxis van de taalconstructie die vereist is of opties zijn ingeschakeld of uitgeschakeld.) De optie is alleen van toepassing op die groep. Zie Groeperingsconstructies voor meer informatie.

In het volgende voorbeeld ziet u een afbeelding. Er worden inlineopties in een groeperingsconstructie gebruikt om hoofdlettergevoelige overeenkomsten mogelijk te maken en om witruimte voor patronen te negeren bij het identificeren van woorden die beginnen met de letter '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.      
```

Als er inline opties zijn opgegeven, wordt deze opties uitgeschakeld door een minteken (-) voordat een optie of set opties wordt uitgeschakeld. De inlineconstructie (?ix-ms) schakelt bijvoorbeeld de RegexOptions.IgnoreCase en opties in en RegexOptions.IgnorePatternWhitespace schakelt de RegexOptions.Multiline en RegexOptions.Singleline opties uit. Alle reguliere expressieopties zijn standaard uitgeschakeld.

Notitie

Als de reguliere expressieopties die zijn opgegeven in de options parameter van een constructor of methode-aanroep conflicteren met de opties die inline zijn opgegeven in een reguliere expressiepatroon, worden de inlineopties gebruikt.

De volgende vijf reguliere expressieopties kunnen worden ingesteld, zowel met de parameter opties als inline:

De volgende vijf reguliere expressieopties kunnen worden ingesteld met behulp van de options parameter, maar kunnen niet inline worden ingesteld:

Opties bepalen

U kunt bepalen welke opties aan een Regex object zijn opgegeven toen het werd geïnstantieerd door de waarde van de eigenschap Alleen-lezen Regex.Options op te halen.

Als u wilt testen op de aanwezigheid van een optie, behalve RegexOptions.None, voert u een AND-bewerking uit met de waarde van de Regex.Options eigenschap en de RegexOptions waarde waarin u geïnteresseerd bent. Test vervolgens of het resultaat gelijk is aan die RegexOptions waarde. In het volgende voorbeeld wordt getest of de RegexOptions.IgnoreCase optie is ingesteld.

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

Als u wilt testen RegexOptions.None, bepaalt u of de waarde van de Regex.Options eigenschap gelijk is aan RegexOptions.None, zoals in het volgende voorbeeld wordt geïllustreerd.

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

De volgende secties bevatten de opties die worden ondersteund door reguliere expressies in .NET.

Standaardopties

De RegexOptions.None optie geeft aan dat er geen opties zijn opgegeven en dat de engine voor reguliere expressies het standaardgedrag gebruikt. Deze eigenschappen omvatten onder andere:

Het patroon wordt geïnterpreteerd als een canonieke in plaats van een reguliere ECMAScript-expressie.
Het reguliere expressiepatroon komt overeen in de invoertekenreeks van links naar rechts.
Vergelijkingen zijn hoofdlettergevoelig.
De ^ en $ taalelementen geven het begin en einde van de invoertekenreeks aan. Het einde van de invoertekenreeks kan een volgteken voor nieuwe regels \n zijn.
Het . taalelement komt overeen met elk teken, behalve \n.
Eventuele witruimte in een normaal expressiepatroon wordt geïnterpreteerd als een letterlijk spatieteken.
De conventies van de huidige cultuur worden gebruikt bij het vergelijken van het patroon met de invoertekenreeks.
Het vastleggen van groepen in het reguliere expressiepatroon is impliciet en expliciet.

Notitie

De RegexOptions.None optie heeft geen inline-equivalent. Wanneer reguliere expressieopties inline worden toegepast, wordt het standaardgedrag hersteld op basis van een optie door een bepaalde optie uit te schakelen. Hiermee schakelt u bijvoorbeeld (?i) een niet-hoofdlettergevoelige vergelijking in en (?-i) herstelt u de standaard hoofdlettergevoelige vergelijking.

Omdat de RegexOptions.None optie het standaardgedrag van de reguliere expressie-engine vertegenwoordigt, wordt deze zelden expliciet opgegeven in een methodeaanroep. In plaats daarvan wordt een options constructor- of statische patroonkoppelingsmethode zonder parameter aangeroepen.

Hoofdlettergevoelige overeenkomsten

De IgnoreCase optie, of de i inlineoptie, biedt hoofdlettergevoelige overeenkomsten. Standaard worden de casingconventies van de huidige cultuur gebruikt.

In het volgende voorbeeld wordt een normaal expressiepatroon gedefinieerd dat \bthe\w*\bovereenkomt met alle woorden die beginnen met 'the'. Omdat de eerste aanroep van de Match methode gebruikmaakt van de standaard hoofdlettergevoelige vergelijking, geeft de uitvoer aan dat de tekenreeks 'The' die de zin begint, niet overeenkomt. Deze wordt vergeleken wanneer de Match methode wordt aangeroepen met opties die zijn ingesteld op 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.

In het volgende voorbeeld wordt het patroon van de reguliere expressie gewijzigd uit het vorige voorbeeld om inlineopties te gebruiken in plaats van de options parameter om hoofdlettergevoelige vergelijking te bieden. Het eerste patroon definieert de hoofdlettergevoelige optie in een groeperingsconstructie die alleen van toepassing is op de letter 't' in de tekenreeks 'the'. Omdat de optieconstructie zich aan het begin van het patroon voordoet, past het tweede patroon de hoofdlettergevoelige optie toe op de gehele reguliere expressie.

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.

Modus met meerdere regels

Met RegexOptions.Multiline de optie, of de m inlineoptie, kan de engine voor reguliere expressies een invoertekenreeks verwerken die uit meerdere regels bestaat. Hiermee wordt de interpretatie van de ^ en $ taalelementen gewijzigd, zodat deze het begin en einde van een regel aangeven, in plaats van het begin en einde van de invoertekenreeks.

$ Standaard wordt alleen aan het einde van de invoertekenreeks voldaan. Als u de RegexOptions.Multiline optie opgeeft, wordt aan de nieuwe regel (\n) of het einde van de invoertekenreeks voldaan.

In geen van beide gevallen $ herkent u de combinatie van regelterugloop-/regelinvoertekens (\r\n). $ negeert altijd alle regelterugloop (\r). Als u uw overeenkomst met een van \r\n beide wilt beëindigen of \n, gebruikt u de subexpressie \r?$ in plaats van alleen $. Houd er rekening mee dat dit het \r deel van de overeenkomst maakt.

In het volgende voorbeeld worden de namen en scores van bowlers geëxtraheerd en toegevoegd aan een SortedList<TKey,TValue> verzameling die ze in aflopende volgorde sorteert. De Matches methode wordt twee keer aangeroepen. In de eerste methode-aanroep is de reguliere expressie ingesteld ^(\w+)\s(\d+)$ en zijn er geen opties ingesteld. Zoals de uitvoer laat zien, omdat de engine voor reguliere expressies niet overeenkomt met het invoerpatroon, samen met het begin en einde van de invoertekenreeks, worden er geen overeenkomsten gevonden. In de tweede methode-aanroep wordt de reguliere expressie gewijzigd ^(\w+)\s(\d+)\r?$ in en worden de opties ingesteld op RegexOptions.Multiline. Zoals in de uitvoer wordt weergegeven, worden de namen en scores gematcht en worden de scores in aflopende volgorde weergegeven.

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

Het reguliere expressiepatroon ^(\w+)\s(\d+)\r*$ wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

Patroon	Beschrijving
`^`	Begin aan het begin van de regel.
`(\w+)`	Komt overeen met een of meer woordtekens. Dit is de eerste opnamegroep.
`\s`	Overeenkomst met een spatieteken.
`(\d+)`	Kom overeen met een of meer decimale cijfers. Dit is de tweede vastleggende groep.
`\r?`	Kom overeen met nul of één regelterugloopteken.
`$`	Eindig aan het einde van de regel.

Het volgende voorbeeld is gelijk aan de vorige, behalve dat de inlineoptie (?m) wordt gebruikt om de optie voor meerdere regels in te stellen.

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

Modus met één regel

De RegexOptions.Singleline optie, of de s inline-optie, zorgt ervoor dat de reguliere expressie-engine de invoertekenreeks behandelt alsof deze uit één regel bestaat. Dit doet u door het gedrag van het taalelement van de punt (.) te wijzigen, zodat het overeenkomt met elk teken, in plaats van elk teken te vergelijken, met uitzondering van het nieuwe regelteken \n.

In het volgende voorbeeld ziet u hoe het gedrag van het . taalelement verandert wanneer u de RegexOptions.Singleline optie gebruikt. De reguliere expressie ^.+ begint aan het begin van de tekenreeks en komt overeen met elk teken. De overeenkomst eindigt standaard aan het einde van de eerste regel; het reguliere expressiepatroon komt overeen met het regelterugloopteken \r, maar komt niet overeen \n. Omdat de RegexOptions.Singleline optie de hele invoertekenreeks als één regel interpreteert, komt deze overeen met elk teken in de invoertekenreeks, inclusief \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\.

Het volgende voorbeeld is gelijk aan de vorige, behalve dat de inlineoptie (?s) wordt gebruikt om de modus met één regel in te schakelen.

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\.

Alleen expliciete opnamen

Standaard worden het vastleggen van groepen gedefinieerd door het gebruik van haakjes in het reguliere expressiepatroon. Benoemde groepen krijgen een naam of nummer toegewezen door de (?<naamsubexpressietaaloptie)>, terwijl niet-benoemde groepen toegankelijk zijn per index. In het GroupCollection object worden niet-benoemde groepen voorafgegaan door benoemde groepen.

Groeperingsconstructies worden vaak alleen gebruikt om kwantificatoren toe te passen op meerdere taalelementen en de vastgelegde subtekenreeksen zijn niet van belang. Bijvoorbeeld als de volgende reguliere expressie:

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

is alleen bedoeld om zinnen te extraheren die eindigen op een punt, uitroepteken of vraagteken uit een document, maar alleen de resulterende zin (die wordt vertegenwoordigd door het Match object) is van belang. De afzonderlijke woorden in de verzameling zijn niet.

Het vastleggen van groepen die niet vervolgens worden gebruikt, kan duur zijn, omdat de reguliere expressie-engine zowel de als CaptureCollection de GroupCollection verzamelingsobjecten moet vullen. Als alternatief kunt u de RegexOptions.ExplicitCapture optie of de n inline-optie gebruiken om op te geven dat de enige geldige opnamen expliciet een naam hebben of genummerde groepen die zijn aangewezen door de(?< naamsubexpressieconstructie>).

In het volgende voorbeeld wordt informatie weergegeven over de overeenkomsten die worden geretourneerd door het \b$?((\w+),?\s?)+[\.!?]$? reguliere expressiepatroon wanneer de Match methode wordt aangeroepen met en zonder de RegexOptions.ExplicitCapture optie. Zoals de uitvoer van de eerste methode-aanroep laat zien, vult de engine voor reguliere expressies de GroupCollection objecten en CaptureCollection verzamelingsobjecten volledig in met informatie over vastgelegde subtekenreeksen. Omdat de tweede methode wordt aangeroepen met options ingesteld op RegexOptions.ExplicitCapture, worden er geen gegevens over groepen vastgelegd.

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.

Het reguliere expressiepatroon\b$?((?>\w+),?\s?)+[\.!?]$? wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

Patroon	Beschrijving
`\b`	Begin bij een woordgrens.
`\(?`	Kom overeen met nul of één exemplaar van het haakje openen ("(").
`(?>\w+),?`	Komen overeen met een of meer woordtekens, gevolgd door nul of één komma. Geen backtrack bij overeenkomende woordtekens.
`\s?`	Kom overeen met nul of één spatietekens.
`((\w+),?\s?)+`	Komt overeen met de combinatie van een of meer woordtekens, nul of één komma en één witruimteteken één of meer keer.
`[\.!?]\)?`	Komt overeen met een van de drie interpunctiesymbolen, gevolgd door nul of één haakje sluiten (")").

U kunt het (?n) inline-element ook gebruiken om automatische opnamen te onderdrukken. In het volgende voorbeeld wordt het vorige patroon voor reguliere expressies gewijzigd om het (?n) inline-element te gebruiken in plaats van de RegexOptions.ExplicitCapture optie.

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.

Ten slotte kunt u het inline-groepselement (?n:) gebruiken om automatische opnamen per groep te onderdrukken. In het volgende voorbeeld wordt het vorige patroon gewijzigd om niet-benoemde opnamen in de buitenste groep te onderdrukken. ((?>\w+),?\s?) Houd er rekening mee dat hiermee ook niet-benoemde opnamen in de binnenste groep worden onderdrukt.

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.

Gecompileerde reguliere expressies

Notitie

Gebruik waar mogelijk reguliere expressies die door de bron zijn gegenereerd in plaats van reguliere expressies te compileren met behulp van de RegexOptions.Compiled optie. Het genereren van bronnen kan ervoor zorgen dat uw app sneller kan worden gestart, sneller kan worden uitgevoerd en beter kan worden ingekort. Als u wilt weten wanneer brongeneratie mogelijk is, raadpleegt u Wanneer u deze gebruikt.

Reguliere expressies in .NET worden standaard geïnterpreteerd. Wanneer een Regex object wordt geïnstantieerd of een statische Regex methode wordt aangeroepen, wordt het reguliere expressiepatroon geparseerd in een set aangepaste opcodes en gebruikt een interpreter deze opcodes om de reguliere expressie uit te voeren. Dit omvat een compromis: de kosten voor het initialiseren van de reguliere expressie-engine worden geminimaliseerd ten koste van runtimeprestaties.

U kunt gecompileerd in plaats van geïnterpreteerde reguliere expressies gebruiken met behulp van de RegexOptions.Compiled optie. Wanneer een patroon in dit geval wordt doorgegeven aan de engine voor reguliere expressies, wordt het geparseerd in een set opcodes en vervolgens geconverteerd naar een gemeenschappelijke tussentaal (CIL), die rechtstreeks kan worden doorgegeven aan de algemene taalruntime. Gecompileerde reguliere expressies maximaliseren de runtimeprestaties ten koste van initialisatietijd.

Notitie

Een reguliere expressie kan alleen worden gecompileerd door de RegexOptions.Compiled waarde op te geven aan de options parameter van een Regex klasseconstructor of een statische patroonkoppelingsmethode. Deze optie is niet beschikbaar als inlineoptie.

U kunt gecompileerde reguliere expressies gebruiken in aanroepen naar zowel statische als reguliere expressies van exemplaren. In statische reguliere expressies wordt de RegexOptions.Compiled optie doorgegeven aan de options parameter van de reguliere expressiepatroonkoppelingsmethode. In reguliere expressies wordt deze doorgegeven aan de options parameter van de Regex klasseconstructor. In beide gevallen resulteert dit in verbeterde prestaties.

Deze verbetering van de prestaties vindt echter alleen plaats onder de volgende omstandigheden:

Een Regex object dat een bepaalde reguliere expressie vertegenwoordigt, wordt gebruikt in meerdere aanroepen naar reguliere expressiemethoden voor patroonkoppeling.
Het Regex object mag niet buiten het bereik vallen, zodat het opnieuw kan worden gebruikt.
Een statische reguliere expressie wordt gebruikt in meerdere aanroepen naar reguliere methoden voor patroonvergelijking van expressies. (De prestatieverbetering is mogelijk omdat reguliere expressies die worden gebruikt in statische methode-aanroepen in de cache worden opgeslagen door de engine voor reguliere expressies.)

Notitie

De RegexOptions.Compiled optie is niet gerelateerd aan de verouderde Regex.CompileToAssembly methode, waarmee een speciaal doelassembly wordt gemaakt die vooraf gedefinieerde, gecompileerde reguliere expressies bevat.

Witruimte negeren

Standaard is witruimte in een normaal expressiepatroon aanzienlijk; hiermee wordt de engine voor reguliere expressies gedwongen overeen te komen met een witruimteteken in de invoertekenreeks. Daarom zijn de reguliere expressie '\b\w+\s' en '\b\w+ ' ongeveer equivalente reguliere expressies. Bovendien wordt het getalteken (#) in een normaal expressiepatroon geïnterpreteerd als een letterlijk teken dat moet worden vergeleken.

De RegexOptions.IgnorePatternWhitespace optie, of de x inlineoptie, wijzigt dit standaardgedrag als volgt:

Niet-gescaped witruimte in het reguliere expressiepatroon wordt genegeerd. Als u deel wilt uitmaken van een normaal expressiepatroon, moeten spatietekens worden ontsnapt (bijvoorbeeld als \s of "\ ").
Het numerieke teken (#) wordt geïnterpreteerd als het begin van een opmerking in plaats van als een letterlijk teken. Alle tekst in het reguliere expressiepatroon van het # teken naar het volgende \n teken of het einde van de tekenreeks wordt geïnterpreteerd als een opmerking.

In de volgende gevallen worden spatietekens in een reguliere expressie echter niet genegeerd, zelfs niet als u de RegexOptions.IgnorePatternWhitespace optie gebruikt:

Witruimte binnen een tekenklasse wordt altijd letterlijk geïnterpreteerd. Het reguliere expressiepatroon [ .,;:] komt bijvoorbeeld overeen met één witruimteteken, punt, komma, puntkomma of dubbele punt.
Witruimte is niet toegestaan binnen een gekwantificeerde haken, zoals {n}, {n,} en {n,m.} Het reguliere expressiepatroon \d{1, 3} komt bijvoorbeeld niet overeen met eventuele reeksen cijfers van één tot drie cijfers, omdat het een witruimteteken bevat.
Witruimte is niet toegestaan binnen een tekenreeks die een taalelement introduceert. Voorbeeld:
- De subexpressie) van het taalelement (?:vertegenwoordigt een niet-inkapserende groep en het (?: gedeelte van het element kan geen ingesloten spaties bevatten. De patroonsubexpressie (? :)genereert een ArgumentException runtime omdat de engine voor reguliere expressies het patroon niet kan parseren en de subexpressie van het patroon( ?: niet overeenkomt met subexpressie.)
- De naam} van het taalelement\p{, dat een Unicode-categorie of benoemd blok vertegenwoordigt, kan geen ingesloten spaties bevatten in het \p{ gedeelte van het element. Als u wel een witruimte opneemt, genereert het element een ArgumentException runtime.

Als u deze optie inschakelt, kunt u reguliere expressies vereenvoudigen die vaak moeilijk te parseren en te begrijpen zijn. Het verbetert de leesbaarheid en maakt het mogelijk om een reguliere expressie te documenteren.

In het volgende voorbeeld wordt het volgende patroon voor reguliere expressies gedefinieerd:

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

Dit patroon is vergelijkbaar met het patroon dat is gedefinieerd in de sectie Alleen expliciet vastleggen, behalve dat het de RegexOptions.IgnorePatternWhitespace optie gebruikt om witruimte voor patronen te negeren.

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.

In het volgende voorbeeld wordt de inlineoptie (?x) gebruikt om witruimte voor patronen te negeren.

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.

Modus Van rechts naar links

Standaard wordt met de engine voor reguliere expressies van links naar rechts gezocht. U kunt de zoekrichting omkeren met behulp van de RegexOptions.RightToLeft optie. De zoekopdracht van rechts naar links begint automatisch op de laatste tekenpositie van de tekenreeks. Voor patroonkoppelingsmethoden die een beginpositieparameter bevatten, zoals Regex.Match(String, Int32), is de opgegeven beginpositie de index van de meest rechtse tekenpositie waarop de zoekopdracht moet beginnen.

Notitie

De patroonmodus Van rechts naar links is alleen beschikbaar door de RegexOptions.RightToLeft waarde op te geven aan de options parameter van een klasseconstructor of statische Regex patroonkoppelingsmethode. Deze optie is niet beschikbaar als inlineoptie.

Opmerking

De reguliere expressie \bb\w+\s komt overeen met woorden met twee of meer tekens die beginnen met de letter 'b' en worden gevolgd door een spatieteken. In het volgende voorbeeld bestaat de invoertekenreeks uit drie woorden met een of meer 'b'-tekens. De eerste en tweede woorden beginnen met 'b' en het derde woord eindigt op 'b'. Zoals in de uitvoer van het voorbeeld van rechts naar links wordt weergegeven, komen alleen de eerste en tweede woorden overeen met het reguliere expressiepatroon, waarbij het tweede woord eerst wordt vergeleken.

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.

Evaluatievolgorde

De RegexOptions.RightToLeft optie wijzigt de zoekrichting en keert ook de volgorde om waarin het reguliere expressiepatroon wordt geëvalueerd. In een zoekactie van rechts naar links wordt het zoekpatroon van rechts naar links gelezen. Dit onderscheid is belangrijk omdat het van invloed kan zijn op zaken als capturegroepen en backreferences. Met de expressie Regex.Match("abcabc", @"\1(abc)", RegexOptions.RightToLeft) wordt bijvoorbeeld een overeenkomst abcabcgevonden, maar in een zoekactie van links naar rechts (Regex.Match("abcabc", @"\1(abc)", RegexOptions.None)), wordt er geen overeenkomst gevonden. Dat komt doordat het element moet worden geëvalueerd voordat het (abc) genummerde groepselement (\1) voor een overeenkomst moet worden gevonden.

Lookahead- en lookbehind-asserties

De locatie van een overeenkomst voor een lookahead ((?=subexpression)) of lookbehind ((?<=subexpression))-assertie verandert niet in een zoekactie van rechts naar links. De lookahead-asserties zien er rechts van de huidige overeenkomstlocatie uit; de lookbehind-asserties kijken links van de huidige overeenkomstlocatie.

Tip

Of een zoekopdracht nu van rechts naar links is of niet, lookbehinds worden geïmplementeerd met behulp van een zoekactie van rechts naar links vanaf de huidige overeenkomstlocatie.

De reguliere expressie (?<=\d{1,2}\s)\w+,\s\d{4} gebruikt bijvoorbeeld de lookbehind-assertie om te testen op een datum die voorafgaat aan een maandnaam. De reguliere expressie komt vervolgens overeen met de maand en het jaar. Zie Groeperingsconstructies voor informatie over lookahead- en lookbehind-asserties.

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.

Het reguliere expressiepatroon wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

Patroon	Beschrijving
`(?<=\d{1,2}\s)`	Het begin van de overeenkomst moet worden voorafgegaan door een of twee decimale cijfers, gevolgd door een spatie.
`\w+`	Komt overeen met een of meer woordtekens.
`,`	Komma's overeen met één komma.
`\s`	Overeenkomst met een spatieteken.
`\d{4}`	Kom overeen met vier decimalen.

ECMAScript-overeenkomend gedrag

De engine voor reguliere expressies maakt standaard gebruik van canoniek gedrag wanneer het overeenkomt met een normaal expressiepatroon om tekst in te voeren. U kunt echter de engine voor reguliere expressies instrueren om het overeenkomende gedrag van ECMAScript te gebruiken door de RegexOptions.ECMAScript optie op te geven.

Notitie

ECMAScript-compatibel gedrag is alleen beschikbaar door de waarde op te geven aan de RegexOptions.ECMAScript options parameter van een Regex klasseconstructor of statische patroonkoppelingsmethode. Deze optie is niet beschikbaar als inlineoptie.

De RegexOptions.ECMAScript optie kan alleen worden gecombineerd met de RegexOptions.IgnoreCase en RegexOptions.Multiline opties. Het gebruik van een andere optie in een reguliere expressie resulteert in een ArgumentOutOfRangeException.

Het gedrag van ECMAScript en canonieke reguliere expressies verschilt in drie gebieden: syntaxis van tekenklasse, zelfverwijzing van het vastleggen van groepen en octale versus interpretatie van backreference.

Syntaxis van tekenklasse. Omdat canonieke reguliere expressies Unicode ondersteunen terwijl ECMAScript dat niet doet, hebben tekenklassen in ECMAScript een beperktere syntaxis en hebben sommige tekenklassetaalelementen een andere betekenis. ECMAScript biedt bijvoorbeeld geen ondersteuning voor taalelementen zoals de Unicode-categorie of blokelementen \p en \P. Op dezelfde manier is het \w element, dat overeenkomt met een woordteken, gelijk aan de [a-zA-Z_0-9] tekenklasse bij het gebruik van ECMAScript en [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] bij het gebruik van canoniek gedrag. Zie Tekenklassen voor meer informatie.

In het volgende voorbeeld ziet u het verschil tussen canonieke en ECMAScript-patroonkoppeling. Hiermee wordt een reguliere expressie gedefinieerd, \b(\w+\s*)+die overeenkomt met woorden gevolgd door spatietekens. De invoer bestaat uit twee tekenreeksen, een tekenreeks die gebruikmaakt van de Latijnse tekenset en de andere die gebruikmaakt van de Cyrillische tekenset. Zoals in de uitvoer wordt weergegeven, komt de aanroep van de Regex.IsMatch(String, String, RegexOptions) methode die gebruikmaakt van ECMAScript-overeenkomsten niet overeen met de Cyrillische woorden, terwijl de methode-aanroep die gebruikmaakt van canonieke overeenkomsten wel overeenkomt met deze woorden.

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.

Zelfverwijzend naar het vastleggen van groepen. Een reguliere expressie-opnameklasse met een backreference naar zichzelf moet worden bijgewerkt met elke capture-iteratie. Zoals in het volgende voorbeeld wordt weergegeven, kan met deze functie de reguliere expressie ((a+)(\1) ?)+ overeenkomen met de invoertekenreeks 'aa aaaa aaaaaa' bij het gebruik van ECMAScript, maar niet wanneer canonieke overeenkomsten worden gebruikt.

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 '

De reguliere expressie wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

Patroon	Beschrijving
(a+)	Komt een of meer keren overeen met de letter 'a'. Dit is de tweede vastleggende groep.
(\1)	Komt overeen met de subtekenreeks die is vastgelegd door de eerste groep die wordt vastgelegd. Dit is de derde groep die vastlegt.
?	Kom overeen met nul of één spatieteken.
((a+)(\1) ?)+	Komt overeen met het patroon van een of meer 'a'-tekens, gevolgd door een tekenreeks die overeenkomt met de eerste groep die wordt vastgelegd, gevolgd door nul of één spatieteken een of meer keer. Dit is de eerste opnamegroep.

Oplossing van dubbelzinnigheden tussen octale escapes en backreferences. De volgende tabel bevat een overzicht van de verschillen in octale versus backreference-interpretatie door canonieke en ECMAScript-reguliere expressies.

Regular expression	Canoniek gedrag	ECMAScript-gedrag
`\0` gevolgd door 0 tot 2 octale cijfers	Interpreteren als een octaal getal. Wordt bijvoorbeeld `\044` altijd geïnterpreteerd als een octale waarde en betekent '$'.	Hetzelfde gedrag.
`\` gevolgd door een cijfer van 1 tot en met 9, gevolgd door geen extra decimale cijfers,	Interpreteren als een backreference. Dit betekent bijvoorbeeld `\9` altijd backreference 9, zelfs als er geen negende groep bestaat. Als de vastleggende groep niet bestaat, genereert de reguliere expressieparser een ArgumentException.	Als er één decimaal cijfer bestaat dat een groep vastlegt, wordt de deductie naar dat cijfer terugverwijzing uitgevoerd. Anders interpreteert u de waarde als een letterlijke waarde.
`\` gevolgd door een cijfer van 1 tot en met 9, gevolgd door extra decimale cijfers	Interpreteer de cijfers als een decimale waarde. Als die groep voor vastleggen bestaat, interpreteert u de expressie als een backreference. Interpreteer anders de voorloopcijferige octale cijfers tot octaal 377; dat wil gezegd, alleen rekening houden met de lage 8 bits van de waarde. Interpreteer de resterende cijfers als letterlijke gegevens. Als in de expressie `\3000`bijvoorbeeld groep 300 wordt vastgelegd, interpreteert u als backreference 300; als het vastleggen van groep 300 niet bestaat, interpreteert u als octaal 300 gevolgd door 0.	Interpreteer als een backreference door zoveel mogelijk cijfers te converteren naar een decimale waarde die naar een opname kan verwijzen. Als er geen cijfers kunnen worden geconverteerd, interpreteert u deze als een octaal getal met behulp van de voorloopcijferen tot octaal 377; interpreteer de resterende cijfers als letterlijke gegevens.

Vergelijken met behulp van de invariante cultuur

Wanneer de engine voor reguliere expressies standaard hoofdlettergevoelige vergelijkingen uitvoert, worden de hoofdletterconventies van de huidige cultuur gebruikt om gelijkwaardige hoofdletters en kleine letters te bepalen.

Dit gedrag is echter ongewenst voor sommige typen vergelijkingen, met name bij het vergelijken van gebruikersinvoer met de namen van systeembronnen, zoals wachtwoorden, bestanden of URL's. In het volgende voorbeeld ziet u een dergelijk scenario. De code is bedoeld om de toegang tot elke resource te blokkeren waarvan de URL vooraf gaat aan FILE://. De reguliere expressie probeert een hoofdlettergevoelige overeenkomst met de tekenreeks uit te voeren met behulp van de reguliere expressie $FILE://. Wanneer de huidige systeemcultuur echter tr-TR (Turks-Türk machtiging) is, is "I" niet het hoofdlettere equivalent van "i". Als gevolg hiervan retourneert falsede aanroep van de Regex.IsMatch methode en is toegang tot het bestand toegestaan.

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.

Notitie

Zie Aanbevolen procedures voor het gebruik van tekenreeksen voor tekenreeksen die hoofdlettergevoelig zijn en die gebruikmaken van de invariante cultuur voor meer informatie over tekenreeksvergelijkingen.

In plaats van de hoofdlettergevoelige vergelijkingen van de huidige cultuur te gebruiken, kunt u de RegexOptions.CultureInvariant optie opgeven om culturele verschillen in taal te negeren en de conventies van de invariante cultuur te gebruiken.

Notitie

Vergelijking met behulp van de invariante cultuur is alleen beschikbaar door de RegexOptions.CultureInvariant waarde op te geven aan de options parameter van een Regex klasseconstructor of statische patroonkoppelingsmethode. Deze optie is niet beschikbaar als inlineoptie.

Het volgende voorbeeld is identiek aan het vorige voorbeeld, behalve dat de statische Regex.IsMatch(String, String, RegexOptions) methode wordt aangeroepen met opties die zijn opgenomen RegexOptions.CultureInvariant. Zelfs wanneer de huidige cultuur is ingesteld op Turks (), kan de engine voor reguliere expressies "FILE" en "file" afstemmen en de toegang tot de bestandsresource blokkeren.

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.

Niet-backtrackingmodus

Standaard. De regex-engine van NET maakt gebruik van backtracking om patroonovereenkomsten te zoeken. Een backtracking-engine is een engine die probeert overeen te komen met één patroon, en als dat mislukt, teruggaat en probeert een alternatief patroon te vinden, enzovoort. Een backtracking-engine is zeer snel voor typische gevallen, maar vertraagt naarmate het aantal patroonwisselingen toeneemt, wat kan leiden tot catastrofale backtracking. De RegexOptions.NonBacktracking optie, die is geïntroduceerd in .NET 7, gebruikt geen backtracking en vermijdt dat slechtste scenario. Het doel is om consistent goed gedrag te bieden, ongeacht de invoer die wordt doorzocht.

De RegexOptions.NonBacktracking optie biedt geen ondersteuning voor alles wat de andere ingebouwde engines ondersteunen. De optie kan met name niet worden gebruikt in combinatie met RegexOptions.RightToLeft of RegexOptions.ECMAScript. Het biedt ook geen toestemming voor de volgende constructies in het patroon:

Atomische groepen
Backreferences
Taakverdelingsgroepen
Vereisten
Lookarounds
Ankers starten (\G)

RegexOptions.NonBacktracking heeft ook een subtiel verschil met betrekking tot uitvoering. Als een capture-groep zich in een lus bevindt, bieden de meeste (non-.NET) regex-engines alleen de laatst overeenkomende waarde voor die opname. Echter. De regex-engine van NET houdt alle waarden bij die in een lus worden vastgelegd en biedt toegang tot deze waarden. De RegexOptions.NonBacktracking optie is net als de meeste andere regex-implementaties en biedt alleen ondersteuning voor het leveren van de uiteindelijke opname.

Zie Backtracking in reguliere expressies voor meer informatie over backtracking.

Zie ook

Reguliere expressietaal - Snelzoekgids

Delen via

Opties voor reguliere expressies

Opties opgeven

Opties bepalen

Standaardopties

Hoofdlettergevoelige overeenkomsten

Modus met meerdere regels

Modus met één regel

Alleen expliciete opnamen

Gecompileerde reguliere expressies

Witruimte negeren

Modus Van rechts naar links

Opmerking

Evaluatievolgorde

Lookahead- en lookbehind-asserties

ECMAScript-overeenkomend gedrag

Vergelijken met behulp van de invariante cultuur

Niet-backtrackingmodus

Zie ook

Aanvullende resources