Reguláris kifejezés beállításai

Alapértelmezés szerint a beviteli sztringek és a reguláris kifejezésmintákban szereplő összes literális karakter összehasonlítása kis- és nagybetűkre érzékeny, a normál kifejezésmintában lévő üres térköz literális szóköz karakterként van értelmezve, a normál kifejezésben lévő csoportok rögzítése pedig implicit és explicit módon történik. Ezeket és az alapértelmezett reguláris kifejezések viselkedésének számos egyéb aspektusát módosíthatja a reguláris kifejezés beállításainak megadásával. Az alábbi táblázatban felsorolt lehetőségek némelyike a reguláris kifejezésminta részeként beágyazottan is szerepelhet, vagy megadható egy System.Text.RegularExpressions.Regex osztálykonstruktornak vagy statikus mintaegyező metódusnak enumerálási System.Text.RegularExpressions.RegexOptions értékként.

`RegexOptions` tag	Beágyazott karakter	Hatály	További információ
None	Nem elérhető	Használja az alapértelmezett viselkedést.	Alapértelmezett beállítások
IgnoreCase	`i`	Használjon kis- és nagybetűkre nem érzékeny egyezést.	Kis- és nagybetűk megkülönböztetése
Multiline	`m`	Használjon többsoros módot, ahol `^` és `$` jelezze az egyes sorok elejét és végét (a bemeneti sztring kezdete és vége helyett).	Többsoros üzemmód
Singleline	`s`	Használjon egysoros módot, ahol a pont (.) minden karakternek megfelel (a `\n` karaktert is beleértve).	Egysoros mód
ExplicitCapture	`n`	Ne rögzítsen névtelen csoportokat. Az egyetlen érvényes elfogás az olyan kifejezetten nevezett vagy számozott csoportok, amelyek formája: `(?<`név`>`, alexpresszió`)`.	Csak explicit rögzítések
Compiled	Nem elérhető	Fordítsa le a reguláris kifejezést egy assemblyvé.	Lefordított reguláris kifejezések
IgnorePatternWhitespace	`x`	Zárjon ki üres szóközt a mintából, és engedélyezze a megjegyzéseket egy számjel (`#`) után.	Üres terület figyelmen kívül hagyása
RightToLeft	Nem elérhető	Módosítsa a keresési irányt. A keresés jobbról balra halad ahelyett, hogy balról jobbra halad.	Jobbról balra irányú mód
ECMAScript	Nem elérhető	Engedélyezze az ECMAScript-kompatibilis viselkedést a kifejezéshez.	ECMAScript-egyeztetési viselkedés
CultureInvariant	Nem elérhető	A nyelvi különbségek figyelmen kívül hagyása.	Összehasonlítás az invariáns kultúrával
NonBacktracking	Nem elérhető	Párosítson egy olyan megközelítéssel, amely elkerüli a visszakövetést, és garantálja a lineáris idejű feldolgozást a bemenet hosszának függvényében. (.NET 7 és az újabb verziókban érhető el.)	Nem-visszalépős mód
AnyNewLine	Nem elérhető	Ismerje fel a `^`, `$`, `\Z` és `.` az összes gyakori újsoros sorozatot, és ne csak a `\n`-t. (.NET 11-ben és újabb verziókban érhető el.)	AnyNewLine mód

Beállítások megadása

A reguláris kifejezések beállításait háromféleképpen adhatja meg:

Egy options osztálykonstruktor vagy statikus (System.Text.RegularExpressions.Regex Visual Basic) Shared paraméterében mintaegyeztetési módszer, például Regex(String, RegexOptions) vagy Regex.Match(String, String, RegexOptions). A options paraméter az enumerált értékek bitenkénti VAGY kombinációja System.Text.RegularExpressions.RegexOptions .

Ha egy Regex példányhoz egy osztálykonstruktor paraméterével adja meg a options beállításokat, a beállítások a System.Text.RegularExpressions.RegexOptions tulajdonsághoz lesznek rendelve. A System.Text.RegularExpressions.RegexOptions tulajdonság azonban nem tükrözi magában a reguláris kifejezésmintában szereplő beágyazott beállításokat.

Az alábbi példa egy illusztrációt tartalmaz. A metódus paraméterével engedélyezi a optionsRegex.Match(String, String, RegexOptions) kis- és nagybetűk megkülönböztetését, és figyelmen kívül hagyja a minta üres területét a "d" betűvel kezdődő szavak azonosításakor.
```
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($"'{match.Value}// found at index {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.      
```
Ha soros beállításokat alkalmaz egy reguláris kifejezési mintában a szintaxissal (?imnsx-imnsx). A beállítás a mintára vonatkozik attól a ponttól kezdve, amelytől a beállítás a minta végéig vagy arra a pontra vonatkozik, ahol a beállítást egy másik beágyazott beállítás nem definiálja. Vegye figyelembe, hogy egy System.Text.RegularExpressions.RegexOptions Regex példány tulajdonsága nem tükrözi ezeket a beágyazott beállításokat. További információ: Vegyes szerkezetek témakör.

Az alábbi példa egy illusztrációt tartalmaz. Beágyazott beállításokkal teszi lehetővé a kis- és nagybetűk megkülönböztetését, és figyelmen kívül hagyja a minta üres területét a "d" betűvel kezdődő szavak azonosításakor.
```
string pattern = @"(?ix) d \w+ \s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
    Console.WriteLine($"'{match.Value}// found at index {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.      
```
Ha beágyazott beállításokat alkalmaz egy különleges csoportosítási szerkezetben egy reguláris kifejezési mintában a szintaxis (?imnsx-imnsx:al-kifejezés) segítségével. Nincs előjel, mielőtt egy beállításkészlet bekapcsolja a beállítást; egy mínuszjel, mielőtt egy beállításkészlet kikapcsolja a beállítást. (? a nyelvi szerkezet szintaxisának rögzített része, amely kötelező, függetlenül attól, hogy a beállítások engedélyezve vagy letiltva vannak-e.) A beállítás csak az adott csoportra vonatkozik. További információért lásd: Csoportosítási szerkezetek.

Az alábbi példa egy illusztrációt tartalmaz. Beágyazott beállításokat használ egy csoportosítási szerkezetben, hogy lehetővé tegye a kis- és nagybetűk megkülönböztetését, és figyelmen kívül hagyja a minta üres területét a "d" betűvel kezdődő szavak azonosításakor.
```
string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
    Console.WriteLine($"'{match.Value}// found at index {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.      
```

Ha a beállítások beágyazottan vannak megadva, egy mínuszjel (-) a beállítás vagy beállításkészlet előtt kikapcsolja ezeket a beállításokat. A beágyazott szerkezet (?ix-ms) például bekapcsolja az RegexOptions.IgnoreCase és RegexOptions.IgnorePatternWhitespace beállításokat, és kikapcsolja a RegexOptions.Multiline és RegexOptions.Singleline beállításokat. Alapértelmezés szerint minden normál kifejezési beállítás ki van kapcsolva.

Feljegyzés

Ha egy konstruktor vagy metódushívás paraméterében options megadott reguláris kifejezési beállítások ütköznek a normál kifejezésmintában megadott beágyazott beállításokkal, a rendszer a beágyazott beállításokat használja.

A következő öt reguláris kifejezés opció beállítható a beállítás paraméterrel és soros megadással is:

A következő hét reguláris kifejezési beállítás adható meg a options paraméterrel, de nem állítható be beágyazott módon:

Beállítások meghatározása

Az Regex objektum példányosításakor megadott beállításokat az írásvédett Regex.Options tulajdonság értékének beolvasásával határozhatja meg.

Bármely opció jelenlétének ellenőrzéséhez, kivéve a RegexOptions.None értéket, hajtsa végre az AND műveletet a Regex.Options tulajdonság értékével és az RegexOptions értékkel, amely érdekli önt. Ezután ellenőrizze, hogy az eredmény megegyezik-e ezzel az RegexOptions értékkel. Az alábbi példa azt ellenőrzi, hogy a RegexOptions.IgnoreCase beállítás be van-e állítva.

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

A RegexOptions.None teszteléshez állapítsa meg, hogy a Regex.Options tulajdonság értéke egyenlő-e RegexOptions.None-vel, amint azt a következő példa illusztrálja.

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

Az alábbi szakaszok a .NET reguláris kifejezései által támogatott beállításokat sorolják fel.

Alapértelmezett beállítások

A RegexOptions.None beállítás azt jelzi, hogy nincs megadva beállítás, és a normál kifejezésmotor az alapértelmezett viselkedését használja. Ezek a következők lehetnek:

A minta ekmaScript-reguláris kifejezés helyett canonikusként értelmezendő.
A normál kifejezésminta balról jobbra illeszkedik a bemeneti sztringben.
Az összehasonlítások megkülönböztetik a kis- és nagybetűket.
^ A $ nyelvi elemek a bemeneti sztring elejét és végét jelölik. A bemeneti sztring vége lehet egy záró újvonalas \n karakter.
A . nyelvi elem minden karakternek megfelel, kivéve \n.
A reguláris kifejezésmintában lévő üres térközeket a rendszer literális szóköz karakterként értelmezi.
A rendszer az aktuális kultúra konvencióit használja a minta és a bemeneti sztring összehasonlításakor.
A csoportok rögzítése a reguláris kifejezési mintában implicit és explicit is.

Feljegyzés

A RegexOptions.None beállításnak nincs beágyazott megfelelője. Ha a normál kifejezési beállításokat beágyazott módon alkalmazza, az alapértelmezett viselkedés beállításonként lesz visszaállítva egy adott beállítás kikapcsolásával. Például a (?i) bekapcsolja a kis- és nagybetűket nem megkülönböztető összehasonlítást, a (?-i) pedig visszaállítja az alapértelmezett kis- és nagybetűket megkülönböztető összehasonlítást.

Mivel a RegexOptions.None beállítás a normál kifejezésmotor alapértelmezett viselkedését jelöli, a metódushívásokban ritkán van explicit módon megadva. Ehelyett egy konstruktort vagy statikus mintaegyeztetési metódust options hívunk meg paraméter nélkül.

Kis- és nagybetűk megkülönböztetése

A IgnoreCase beállítás vagy a i beágyazott beállítás megkülönbözteti a kis- és nagybetűket. Alapértelmezés szerint a rendszer az aktuális kultúra burkolati konvencióit használja.

Az alábbi példa egy reguláris kifejezésmintát határoz meg, \bthe\w*\b, amely az "the" szóval kezdődő összes szóra illeszkedik. Mivel a metódus első hívása a Match kis- és nagybetűk alapértelmezett összehasonlítását használja, a kimenet azt jelzi, hogy a mondatot kezdő "The" sztring nem egyezik. Akkor van megfeleltetve, amikor a Match metódus IgnoreCase opciókkal van meghívva.

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 {match.Value} at index {match.Index}.");

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern,
                                            RegexOptions.IgnoreCase))
         Console.WriteLine($"Found {match.Value} at index {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.

Az alábbi példa módosítja az előző példában szereplő reguláris kifejezésmintát, hogy a paraméter helyett beágyazott beállításokat használjon a options kis- és nagybetűk közötti összehasonlításhoz. Az első minta határozza meg a kis- és nagybetűre érzéketlen beállítást egy csoportosítási szerkezetben, amely csak a "the" szöveg "t" betűjére vonatkozik. Mivel az opciós szerkezet a minta elején található, a második minta az egész reguláris kifejezésre érvényesíti a kis- és nagybetű érzéketlenségi opciót.

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 {match.Value} at index {match.Index}.");

        Console.WriteLine();
        pattern = @"(?i)\bthe\w*\b";
        foreach (Match match in Regex.Matches(input, pattern,
                                              RegexOptions.IgnoreCase))
            Console.WriteLine($"Found {match.Value} at index {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.

Többsoros mód

A RegexOptions.Multiline beállítás vagy a m beágyazott beállítás lehetővé teszi, hogy a reguláris kifejezésmotor kezelje a több sorból álló bemeneti sztringet. Úgy módosítja a ^ nyelvi elemek $ értelmezését, hogy azok a bemeneti sztring kezdete és vége helyett egy sor elejét és végét jelölik.

Alapértelmezés szerint $ csak a bemeneti sztring végén lesz elégedett. Ha megadja a RegexOptions.Multiline opciót, azt az új sor karakter (\n) vagy a bemeneti sztring vége teljesítheti.

Egyik esetben sem ismeri fel a $ a kocsivisszatérési/sorbetöltési karakterkombinációt (\r\n). $ mindig figyelmen kívül hagyja a kocsivissza (\r). A mérkőzést either \r\n vagy \n befejezéséhez használja a szubexpressziót \r?$ ahelyett, hogy csak $ alkalmazná. Vegye figyelembe, hogy ez lesz a \r meccs része.

Tipp.

.NET 11-től kezdve a RegexOptions.AnyNewLine használatával a ^, $, \Z és . az összes gyakori újsor-karaktert felismerheti, nemcsak a \n-t, így nincs szükség \r? kerülő megoldásokra. AnyNewLine atomi \r\n újvonalas sorozatként is kezeli, így \r soha nem szerepel a mérkőzésben. További információ: AnyNewLine mód szakasz.

Az alábbi példa kinyeri a dobók nevét és pontszámait, és hozzáadja őket egy SortedList<TKey,TValue> gyűjteményhez, amely csökkenő sorrendben rendezi őket. A Matches metódust kétszer hívjuk meg. Az első metódushívásban a reguláris kifejezés van ^(\w+)\s(\d+)$ megadva, és nincsenek megadva beállítások. Ahogy a kimenet is mutatja, mivel a reguláris kifejezésmotor nem tud illeszkedni a bemeneti mintával, illetve a bemeneti sztring elejével és végével, nem találhatóak egyezések. A második metódushívásban a normál kifejezés ^(\w+)\s(\d+)\r?$ módosul, és a beállítások a következőre RegexOptions.Multilinevannak állítva: . Ahogy a kimenet is mutatja, a nevek és a pontszámok sikeresen megegyeznek, és a pontszámok csökkenő sorrendben jelennek meg.

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($"{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

A reguláris kifejezésminta ^(\w+)\s(\d+)\r*$ az alábbi táblázatban látható módon van definiálva.

Minta	Leírás
`^`	Kezdje a sor elején.
`(\w+)`	Egy vagy több szó karakterének egyeztetése. Ez az első rögzítési csoport.
`\s`	Feleljen meg egy szóköz karakternek.
`(\d+)`	Egy vagy több számjegy keresése. Ez a második rögzítési csoport.
`\r?`	Nulla vagy egy kocsivissza karakter illesztése.
`$`	Vége a sor végén.

Az alábbi példa egyenértékű az előző példával, azzal a különbséggel, hogy a beágyazott beállítással (?m) állítja be a többsoros beállítást.

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($"{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

Egysoros mód

A RegexOptions.Singleline beállítás vagy a s beágyazott beállítás miatt a reguláris kifejezésmotor úgy kezeli a bemeneti sztringet, mintha egyetlen sorból áll. Ezt úgy teszi, hogy módosítja a pont (.) elem viselkedését, hogy az minden karaktert egyeztesse, ahelyett hogy minden karaktert az újsor karakterét (\n) kivéve egyeztetne.

Az alábbi példa bemutatja, hogyan változik a . nyelvi elem viselkedése a RegexOptions.Singleline beállítás használatakor. A reguláris kifejezés ^.+ a karakterlánc elején kezdődik, és minden karaktert illeszt. Alapértelmezés szerint az egyezés az első sor végén ér véget; a reguláris kifejezésminta megegyezik a kocsi visszatérési karakterével \r, de nem egyezik \n. Mivel a RegexOptions.Singleline beállítás a teljes bemeneti sztringet egyetlen sorként értelmezi, megfelel a bemeneti sztring minden karakterének, beleértve a \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\.

Az alábbi példa egyenértékű az előző példával, azzal a különbséggel, hogy a beágyazott beállítással (?s) engedélyezi az egysoros módot.

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

Csak explicit rögzítések

Alapértelmezés szerint a csoportok rögzítését zárójelek használata határozza meg a reguláris kifejezési mintában. Az elnevezett csoportok neve vagy száma a (?<név>alatti) nyelv beállítással van hozzárendelve, míg a névtelen csoportok indexelhetők. Az objektumban a GroupCollection névtelen csoportok megelőzik az elnevezett csoportokat.

A csoportosítási szerkezeteket gyakran csak kvantitátorok több nyelvi elemre való alkalmazására használják, és a rögzített részszűkítések nem érdekesek. Ha például a következő reguláris kifejezés:

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

csak olyan mondatok kinyerésére szolgál, amelyek ponttal, felkiáltójellel vagy kérdőjellel végződnek egy dokumentumból, csak az eredményül kapott mondat (amelyet az Match objektum jelöl) érdekes. A gyűjtemény egyes szavai nem.

A később nem használt csoportok rögzítése költséges lehet, mivel a normál kifejezésmotornak mind a gyűjteményobjektumokat, mind a GroupCollection CaptureCollection gyűjteményobjektumokat fel kell töltenie. Másik lehetőségként a RegexOptions.ExplicitCapture beállítással vagy a n beágyazott beállítással megadhatja, hogy az egyetlen érvényes rögzítés kifejezetten elnevezett vagy számozott csoport legyen, amelyeket a (?<név> alexpressziós) szerkezete jelöl ki.

Az alábbi példa a reguláris kifejezésminta által \b$?((\w+),?\s?)+[\.!?]$? visszaadott egyezésekkel kapcsolatos információkat jeleníti meg, amikor a Match metódus hívása az RegexOptions.ExplicitCapture opcióval és nélküle történik. Ahogy az első metódushívás kimenete is mutatja, a reguláris kifejezésmotor teljes mértékben kitölti az és GroupCollection a gyűjtemény objektumait a CaptureCollection rögzített részszűkítésekre vonatkozó információkkal. Mivel a második metódust úgy hívják meg, hogy a options értéke RegexOptions.ExplicitCapture, így nem rögzíti a csoportok adatait.

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: {match.Value}");
            int groupCtr = 0;
            foreach (Group group in match.Groups)
            {
                Console.WriteLine($"   Group {groupCtr}: {group.Value}");
                groupCtr++;
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    Console.WriteLine($"      Capture {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: {match.Value}");
            int groupCtr = 0;
            foreach (Group group in match.Groups)
            {
                Console.WriteLine($"   Group {groupCtr}: {group.Value}");
                groupCtr++;
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    Console.WriteLine($"      Capture {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.

A reguláris kifejezésminta\b$?((?>\w+),?\s?)+[\.!?]$? az alábbi táblázatban látható módon van definiálva.

Minta	Leírás
`\b`	Kezdj egy szóhatáron.
`\(?`	A nyitó zárójel nullájának vagy egy előfordulásának egyezése ("(").
`(?>\w+),?`	Egy vagy több szó karakterének egyezése, amelyet nulla vagy egy vessző követ. Ne lépjen vissza, amikor a szavakat alkotó karaktereket egyezteti.
`\s?`	Egy vagy nulla szóköz karakter egyezése.
`((\w+),?\s?)+`	Egy vagy több szókarakter, nulla vagy egy vessző, valamint egy vagy több üres szóköz karakter kombinációjának felel meg.
`[\.!?]\)?`	Egyezzen meg bármelyik három írásjellel, amelyet nulla vagy egy záró zárójel (")") követ.

A (?n) sorközi elem használatával elkerülheti az automatikus rögzítéseket. Az alábbi példa úgy módosítja az előző reguláris kifejezésmintát, hogy a (?n) beágyazott elemet használja a RegexOptions.ExplicitCapture beállítás helyett.

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: {match.Value}");
            int groupCtr = 0;
            foreach (Group group in match.Groups)
            {
                Console.WriteLine($"   Group {groupCtr}: {group.Value}");
                groupCtr++;
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    Console.WriteLine($"      Capture {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.

Végül a beágyazott csoportelem (?n:) használatával csoportonként letilthatja az automatikus rögzítéseket. Az alábbi példa módosítja az előző mintát, hogy letiltsa a névtelen rögzítéseket a külső csoportban. ((?>\w+),?\s?) Vegye figyelembe, hogy ez a belső csoportban is letiltja a névtelen rögzítéseket.

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: {match.Value}");
            int groupCtr = 0;
            foreach (Group group in match.Groups)
            {
                Console.WriteLine($"   Group {groupCtr}: {group.Value}");
                groupCtr++;
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    Console.WriteLine($"      Capture {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.

Lefordított reguláris kifejezések

Feljegyzés

Ahol lehetséges, használjon forrás által létrehozott reguláris kifejezéseket ahelyett, hogy reguláris kifejezéseket állít össze a RegexOptions.Compiled beállítással. A forráskód-generálás segíthet az alkalmazás gyorsabb elindításában, gyorsabb futásában és optimalizálásában. A forráslétrehozás lehetőségének megismeréséhez lásd : Mikor érdemes használni.

Alapértelmezés szerint a rendszer a .NET reguláris kifejezéseit értelmezi. Amikor egy Regex objektumot példányosít vagy statikus Regex metódust hív meg, a rendszer egyéni opkódok készletébe elemzi a reguláris kifejezésmintát, és egy értelmező ezeket az opkódokat használja a reguláris kifejezés futtatásához. Ez kompromisszumot jelent: a normál kifejezésmotor inicializálásának költsége a futtatókörnyezet teljesítményének rovására minimálisra csökken.

Használhatja a RegexOptions.Compiled beállítást fordított reguláris kifejezések helyett előre fordított reguláris kifejezésekhez. Ebben az esetben, amikor egy mintát átadnak a normál kifejezésmotornak, a rendszer opkódok készletében elemzi, majd közös köztes nyelvre (CIL) konvertálja, amelyet közvetlenül a közös nyelvi futtatókörnyezetbe továbbíthat. A lefordított reguláris kifejezések maximalizálják a futtatókörnyezet teljesítményét az inicializálási idő rovására.

Feljegyzés

A reguláris kifejezések csak úgy állíthatók össze, ha RegexOptions.Compiled az options értéket egy Regex osztálykonstruktor paraméterének vagy egy statikus mintaegyeztetési módszernek adja meg. Beágyazott beállításként nem érhető el.

A lefordított reguláris kifejezéseket statikus és példány reguláris kifejezések hívásaiban is használhatja. Statikus reguláris kifejezésekben a rendszer átadja a RegexOptions.Compiled beállítást a options reguláris kifejezésminta-egyeztetési módszer paraméterének. Az instance reguláris kifejezések esetén a options paraméterként kerülnek átadásra a Regex osztálykonstruktorban. Mindkét esetben jobb teljesítményt eredményez.

Ez a teljesítménybeli javulás azonban csak a következő feltételek mellett történik:

Egy Regex adott reguláris kifejezést jelképező objektumot a rendszer több, a reguláris kifejezésminta-egyeztetési metódusokra irányuló hívásban is használ.
Az Regex objektum nem hagyható ki a hatókörből, így újra felhasználható.
A rendszer statikus reguláris kifejezést használ a reguláris kifejezésminta-egyeztetési metódusok több hívásában. (A teljesítmény javítása azért lehetséges, mert a statikus metódushívásokban használt reguláris kifejezéseket a normál kifejezésmotor gyorsítótárazza.)

Feljegyzés

A RegexOptions.Compiled beállítás nem kapcsolódik az elavult Regex.CompileToAssembly metódushoz, amely egy speciális célú szerelvényt hoz létre, amely előre meghatározott, lefordított reguláris kifejezéseket tartalmaz.

Üres terület figyelmen kívül hagyása

Alapértelmezés szerint a reguláris kifejezési mintában a szóköz jelentős; arra kényszeríti a reguláris kifejezésmotort, hogy egyezzen a bemeneti sztringben található szóköz karakterrel. Emiatt a "\b\w+\s" és ""\b\w+ reguláris kifejezés nagyjából egyenértékű reguláris kifejezések. Emellett, ha a számjel (#) egy reguláris kifejezési mintában jelentkezik, akkor a rendszer konstans karakterként értelmezi, amelyet egyeztetni kell.

A RegexOptions.IgnorePatternWhitespace beállítás vagy a x beágyazott beállítás az alábbiak szerint módosítja ezt az alapértelmezett viselkedést:

A rendszer figyelmen kívül hagyja a normál kifejezésmintában lévő üres szóközt. Ahhoz, hogy egy reguláris kifejezésminta része legyen, a szóköz karaktereket escape-elni kell (például mint \s vagy "\ ").
A számjel (#) a megjegyzés kezdeteként van értelmezve, nem pedig literális karakterként. A normál kifejezésmintában szereplő összes szöveg a # karaktertől a következő \n karakterig vagy a sztring végéig megjegyzésként lesz értelmezve.

A következő esetekben azonban a normál kifejezésben lévő szóköz karaktereket a rendszer nem hagyja figyelmen kívül, még akkor sem, ha a RegexOptions.IgnorePatternWhitespace beállítást használja:

A karakterosztályon belüli szóköz mindig szó szerint értelmezendő. Például a reguláris kifejezésmintázat [ .,;:] megfelel bármely egyetlen szóköz karakternek, pontnak, vesszőnek, pontosvesszőnek vagy kettőspontnak.
A zárójeles kvantorban nem engedélyezett a térköz, például {n}, {n,}, és {n,m}. A reguláris kifejezésminta \d{1, 3} például nem felel meg az egy-három számjegyből álló számjegysorozatoknak, mert üres szóköz karaktert tartalmaz.
A nyelvi elemet tartalmazó karaktersorozatokban nem engedélyezett a szóköz. Példa:
- A nyelvi elem (?:részexpresszió) nem rögzítő csoportot jelöl, és az elem (?: része nem tartalmazhat szóközöket. A minta (? :alexpressziója) futásidőben ad vissza egy ArgumentException hibát, mert a reguláris kifejezésmotor nem tudja elemezni a mintát, és a minta ( ?:alexpressziója) nem egyezik a szubexpresszióval.
- A Unicode-kategóriát vagy elnevezett blokkot jelképező nyelvi elemnév \p{}nem tartalmazhat beágyazott szóközöket az \p{ elem részébe. Ha szóközt is tartalmaz, az elem futásidőben dob egy ArgumentException helyet.

Ennek a beállításnak a engedélyezése leegyszerűsíti a gyakran nehezen elemezni és értelmezni kívánt reguláris kifejezéseket. Javítja az olvashatóságot, és lehetővé teszi egy reguláris kifejezés dokumentálására.

Az alábbi példa a következő reguláris kifejezésmintát határozza meg:

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

Ez a minta hasonló az Explicit rögzítések csak szakaszában definiált mintához, azzal a kivétellel, hogy a RegexOptions.IgnorePatternWhitespace opciót használja a minta üres területének figyelmen kívül hagyására.

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.

Az alábbi példa a beágyazott beállítással (?x) figyelmen kívül hagyja a minta üres területét.

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.

Jobbról balra irányultság

Alapértelmezés szerint a normál kifejezésmotor balról jobbra keres. A keresési irányt a beállítással RegexOptions.RightToLeft megfordíthatja. A jobbról balra történő keresés automatikusan elindul a sztring utolsó karakterpozíciójában. Olyan mintaegyeztetési metódusok esetében, amelyek egy kezdő pozícióparamétert tartalmaznak, például Regex.Match(String, Int32)a megadott kezdő pozíció annak a jobb szélső karakterpozíciónak az indexe, amelyen a keresés elkezdődik.

Feljegyzés

A jobbról balra mintázat mód csak azzal érhető el, ha egy RegexOptions.RightToLeft osztálykonstruktor vagy statikus mintaegyező metódus options paraméterének Regex értéket adunk meg. Beágyazott beállításként nem érhető el.

Példa

A reguláris kifejezés \bb\w+\s két vagy több karakterből álló szavakkal egyezik, amelyek a "b" betűvel kezdődnek, és egy szóköz karakter követi őket. A következő példában a bemeneti sztring három olyan szóból áll, amelyek egy vagy több "b" karaktert tartalmaznak. Az első és a második szó a "b" betűvel kezdődik, a harmadik pedig a "b" betűvel végződik. Ahogy a jobbról balra keresési példa kimenete mutatja, csak az első és a második szó egyezik meg a reguláris kifejezésmintával, és a második szó lesz az első.

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($"'{match.Value}' found at position {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.

Kiértékelési sorrend

A RegexOptions.RightToLeft beállítás megváltoztatja a keresési irányt, és megfordítja a reguláris kifejezésminta kiértékelésének sorrendjét is. Jobbról balra történő keresés esetén a keresési minta jobbról balra olvasható. Ez a megkülönböztetés azért fontos, mert hatással lehet például a rögzítési csoportokra és a háttérrendszerekre. A kifejezés Regex.Match("abcabc", @"\1(abc)", RegexOptions.RightToLeft) például talál egyezést abcabc, de a balról jobbra irányuló keresésben (Regex.Match("abcabc", @"\1(abc)", RegexOptions.None)) nem található egyezés. Ennek az az oka, hogy az (abc) elemet a számozott rögzítési csoport () elem (\1) előtt kell kiértékelni egy egyezés megtalálása érdekében.

Lookahead és lookbehind állítások

A lookahead ((?=subexpression)) vagy a lookbehind ((?<=subexpression)) állítás egyezésének helye nem változik a jobbról balra történő keresésben. A lookahead-állítások az aktuális egyezés helyétől jobbra jelennek meg; a lookbehind állítások az aktuális egyezés helyétől balra jelennek meg.

Tipp.

Akár jobbról balra történik a keresés, akár nem, a visszatekintéseket jobbról balra kereséssel hajtják végre, az aktuális egyezés helyétől kezdve.

A reguláris kifejezés (?<=\d{1,2}\s)\w+,\s\d{4} például a lookbehind követeléssel tesztel egy hónapnevet megelőző dátumot. A reguláris kifejezés ezután illeszti a hónapot és az évet. A lookahead és a lookbehind állításokkal kapcsolatos információkért lásd a csoportosítási szerkezeteket.

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 {match.Value}.");
            else
                Console.WriteLine($"{input} does not match.");
        }
    }
}

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

A reguláris kifejezésminta az alábbi táblázatban látható módon van definiálva.

Minta	Leírás
`(?<=\d{1,2}\s)`	Az egyezés elejét egy vagy két tizedesjegynek kell megelőznie, amelyet szóköz követ.
`\w+`	Egy vagy több szó karakterének egyeztetése.
`,`	Egyezik egy vessző karakter.
`\s`	Feleljen meg egy szóköz karakternek.
`\d{4}`	Négy tizedesjegy egyeztetése.

ECMAScript-egyeztetési viselkedés

Alapértelmezés szerint a reguláris kifejezésmotor a szokásos kifejezésminta beviteli szöveghez való illesztésekor a canonical viselkedést használja. A beállítás megadásával azonban utasíthatja a reguláris kifejezésmotort az ECMAScript-megfeleltetési RegexOptions.ECMAScript viselkedés használatára.

Feljegyzés

Az ECMAScript-kompatibilis viselkedés csak úgy érhető el, ha a RegexOptions.ECMAScript értéket a options osztálykonstruktor vagy statikus mintaegyező metódus Regex paraméterének megadjuk. Beágyazott beállításként nem érhető el.

A RegexOptions.ECMAScript beállítás csak a , RegexOptions.IgnoreCaseés RegexOptions.Multiline a RegexOptions.Compiledbeállításokkal kombinálható. A reguláris kifejezésben bármely más lehetőség használata ArgumentOutOfRangeException-t eredményez.

Az ECMAScript és a kanonikus reguláris kifejezések viselkedése három területen különbözik: a karakterosztályok szintaxisa, az önhivatkozó fogó csoportok, valamint az oktális és a háttérhivatkozás értelmezése.

Karakterosztály szintaxisa. Mivel a canonical reguláris kifejezések támogatják a Unicode-t, míg az ECMAScript nem, az ECMAScript karakterosztályai korlátozottabb szintaxissal rendelkeznek, és néhány karakterosztály nyelvi eleme más jelentéssel rendelkezik. Az ECMAScript például nem támogatja a nyelvi elemeket, például a Unicode-kategóriát vagy a blokkelemeket \p és \Pa . Hasonlóképpen, a \w szó karakterével egyező elem egyenértékű az ECMAScript használatakor és [a-zA-Z_0-9] a [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] canonikus viselkedés használatakor használt karakterosztálysal. További információ: Karakterosztályok.

Az alábbi példa a canonical és az ECMAScript mintaegyezés közötti különbséget mutatja be. Egy reguláris kifejezést határoz meg, amely a szavakat követő szóköz karakterekkel egyezik meg. A bemenet két sztringből áll, az egyik a latin karakterkészletet, a másik a cirill karakterkészletet használja. Ahogy a kimenet is mutatja, az Regex.IsMatch(String, String, RegexOptions) ECMAScript-egyeztetést használó metódus hívása nem egyezik a cirill szavakkal, míg a canonical matching metódushívása megfelel ezeknek a szavaknak.

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($"'{value}' matches the pattern.");
            else
                Console.WriteLine($"{value} does not match the pattern.");

            Console.Write("ECMAScript matching: ");
            if (Regex.IsMatch(value, pattern, RegexOptions.ECMAScript))
                Console.WriteLine($"'{value}' matches the pattern.");
            else
                Console.WriteLine($"{value} does not match the pattern.");
            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.

Önhivatkozó rögzítő csoportok. A reguláris kifejezések rögzítésére szolgáló osztályt, amely visszahivatkozással rendelkezik önmagára, minden rögzítési iteráció során frissíteni kell. Ahogy az alábbi példa is mutatja, ez a funkció lehetővé teszi, hogy a reguláris kifejezés ((a+)(\1) ?)+ megfeleljen az "aa aaaa a" bemeneti sztringnek ECMAScript használatakor, de a canonical matching használata esetén nem.

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($"'{pattern}' matches {m.Value} at position {m.Index}.");
            int grpCtr = 0;
            foreach (Group grp in m.Groups)
            {
                Console.WriteLine($"   {grpCtr}: '{grp.Value}'");
                grpCtr++;
                int capCtr = 0;
                foreach (Capture cap in grp.Captures)
                {
                    Console.WriteLine($"      {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 '

A reguláris kifejezés az alábbi táblázatban látható módon van definiálva.

Minta	Leírás
(a+)	Egyszer vagy többször egyezzen meg az "a" betűvel. Ez a második rögzítési csoport.
(\1)	Egyezzen meg az első rögzítési csoport által rögzített szövegrészlettel. Ez a harmadik rögzítési csoport.
?	Nulla vagy egy szóköz karakter illesztése.
((a+)(\1) ?)+	Egyezzen meg egy vagy több "a" karakter mintájával, majd egy sztringgel, amely megfelel az első rögzítési csoportnak, és amelyet nulla vagy egy szóköz karakter követ, ezt ismételve egy vagy több alkalommal. Ez az első rögzítési csoport.

Az oktális menekülések és a visszahivatkozások közötti kétértelműségek megoldása. Az alábbi táblázat összefoglalja az oktális és a visszahivatkozás értelmezése közötti különbségeket a kanonikus és ECMAScript reguláris kifejezések esetén.

Reguláris kifejezés	Kanonikus viselkedés	ECMAScript-viselkedés
`\0` majd 0–2 oktális számjegy	Értelmezze oktálisként. A `\044` az mindig oktális értékként van értelmezve, és azt jelenti, hogy "$".	Ugyanaz a viselkedés.
`\` 1-től 9-ig egy számjegy követi, amelyet további tizedesjegyek nélkül követnek,	Értelmezze visszautalásként. Például `\9` mindig a 9-es visszahivatkozást jelenti, még akkor is, ha egy kilencedik kapcsolási csoport nem létezik. Ha a rögzítési csoport nem létezik, a reguláris kifejezéselemző egy ArgumentException.	Ha létezik egyetlen számjegyrögzítő csoport, legyen visszautalás az adott számjegyre. Ellenkező esetben az értéket literálként értelmezze.
`\` 1 és 9 közötti számjegy, majd további tizedesjegyek	A számjegyeket decimális értékként értelmezze. Ha a rögzítési csoport létezik, értelmezze a kifejezést visszautalásként. Ellenkező esetben értelmezze a kezdő oktális számjegyeket a 377-ig; azaz csak az érték alacsony 8 bites értékeit vegye figyelembe. A fennmaradó számjegyeket literálként értelmezze. Ha például a kifejezésben `\3000` a 300-as csoport létezik, akkor háttérhivatkozásként kell értelmezni; ha a 300-as csoport nem létezik, akkor oktális 300, majd 0 következik.	Értelmezze háttérként, ha a lehető legtöbb számjegyet decimális értékké konvertálja, amely egy rögzítésre hivatkozhat. Ha nem lehet számjegyeket konvertálni, oktálisként értelmezze a vezető oktális számjegyeket 377-ig; a fennmaradó számjegyeket pedig literálként értelmezze.

Összehasonlítás az invariáns kultúra használatával

Alapértelmezés szerint, amikor a reguláris kifejezésmotor kis- és nagybetűk érzéketlen összehasonlítását hajtja végre, az aktuális kultúra burkolati konvencióit használja az egyenértékű nagybetűk és kisbetűk meghatározásához.

Ez a viselkedés azonban bizonyos típusú összehasonlítások esetében nem kívánatos, különösen akkor, ha a felhasználói bemenetet a rendszererőforrások nevével, például jelszavakkal, fájlokkal vagy URL-címekkel hasonlítja össze. Az alábbi példa egy ilyen forgatókönyvet mutat be. A kód célja, hogy letiltsa a hozzáférést minden olyan erőforráshoz, amelynek URL-címe előtaggal rendelkezik FILE://. A reguláris kifejezés a kis- és nagybetűket nem érzékenyítő egyezést kísérel meg a szöveggel, a reguláris kifejezés $FILE:// használatával. Ha azonban a jelenlegi rendszerkultúra tr-TR (Turkish-Türkiye), az "I" nem az "i" nagybetűs megfelelője. Ennek eredményeképpen a Regex.IsMatch metódus hívása visszatér false, és a fájlhoz való hozzáférés engedélyezett.

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 ({Thread.CurrentThread.CurrentCulture.Name} culture)...");
if (Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase))
    Console.WriteLine("URLs that access files are not allowed.");
else
    Console.WriteLine($"Access to {input} is allowed.");

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.

Feljegyzés

A kis- és nagybetűk megkülönböztetésével és az invariáns kultúrát használó sztring-összehasonlításokkal kapcsolatos további információkért tekintse meg a sztringek használatának ajánlott eljárásait.

Ahelyett, hogy a jelenlegi kultúra kis- és nagybetűkre érzéketlen összehasonlításait használná, megadhatja a RegexOptions.CultureInvariant lehetőséget, hogy figyelmen kívül hagyja a nyelvi kulturális különbségeket, és az invariáns kultúra konvencióit alkalmazza.

Feljegyzés

Az invariáns kultúra összehasonlítása csak úgy érhető el, ha egy osztálykonstruktor vagy statikus mintaegyeztetési módszer RegexOptions.CultureInvariant paraméteréhez a options értéket adjuk meg. Beágyazott beállításként nem érhető el.

Az alábbi példa megegyezik az előző példával, azzal a kivétellel, hogy a statikus Regex.IsMatch(String, String, RegexOptions) metódust olyan beállításokkal hívja meg, amelyek tartalmazzák a következőket RegexOptions.CultureInvariant: . Még akkor is, ha a jelenlegi kultúra török (Türkiye) értékre van állítva, a reguláris kifejezésmotor sikeresen megfelel a "FILE" és a "file" értéknek, és letiltja a fájlerőforráshoz való hozzáférést.

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 {input} is allowed.");

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.

Nem-visszakövető mód

Alapértelmezés szerint .NET regex motorja backtracking használatával próbálja megtalálni a mintaegyezéseket. A visszakövetési motor egy olyan motor, amely megpróbál megegyezni egy mintával, és ha ez nem sikerül, visszalép, és megpróbál megegyezni egy másik mintával, és így tovább. A visszakövetési motor nagyon gyors a tipikus esetekhez, de lelassul a minta váltakozásainak számának növekedésével, ami katasztrofális visszakövetéshez vezethet. A .NET 7-ben bevezetett RegexOptions.NonBacktracking lehetőség nem használ visszakövetést, és elkerüli ezt a legrosszabb esetet. Célja, hogy következetesen jó viselkedést biztosítson, függetlenül a keresett bemenettől.

Warning

A .NET regex motor feltételezi, hogy a minta megbízható. A NonBacktracking mód nem változtat ezen a feltételezésen: a költségesbemenet ellen véd, nem pedig az aktív rosszindulatú minták ellen. További információ: Megbízható minták használata.

A RegexOptions.NonBacktracking lehetőség nem támogat mindent, amit a többi beépített motor támogat. A beállítás különösen nem használható együtt a RegexOptions.RightToLeft, RegexOptions.ECMAScript vagy RegexOptions.AnyNewLine opciókkal. Nem engedélyezi a következő szerkezeteket a mintában:

Atomi csoportok
Háttérrendszerek
Csoportok kiegyensúlyozása
Feltételesek
Megkerülő megoldások
Horgonyok indítása (\G)

RegexOptions.NonBacktracking a végrehajtás tekintetében is van egy apró különbség. Ha egy rögzítési csoport hurokban van, a legtöbb (nem .NET) regex motor csak az utolsó egyeztetett értéket adja meg a rögzítéshez. .NET regex motorja azonban nyomon követi a hurokban rögzített összes értéket, és hozzáférést biztosít azokhoz. Ez RegexOptions.NonBacktracking a lehetőség a legtöbb regex-implementációhoz hasonlóan csak a végleges rögzítést támogatja.

A visszakövetéssel kapcsolatos további információkért lásd : Visszakövetés reguláris kifejezésekben.

AnyNewLine mód

Alapértelmezés szerint .NET reguláris kifejezésmotorja csak \n kezel újvonalas karakterként. A horgonyok ^ és $ (RegexOptions.Multiline módban), \Z, valamint a helyettesítő karakter . mind egyetlen \n mint sorhatár használják. Ez azt jelenti, hogy $ nem egyezik \r\n előtt (Windows-stílusú sorvégződések), és . egyezik \r-mal, de nem \n-vel, hacsak RegexOptions.Singleline nincs engedélyezve, ebben az esetben . egyezik az összes karakterrel. Ez gyakori hibákhoz vezet, amikor a szöveget vegyes vagy nem-Unix sorvégződésekkel dolgozzák fel.

A RegexOptions.AnyNewLine lehetőség, amely a .NET 11-ben került bevezetésre, ezek a szerkezetek felismerik az összes gyakori sortörés formátumot: \r\n (CR+LF), \r (CR), \n (LF), \u0085 (NEL), \u2028 (LS) és \u2029 (PS). Ez összhangban van a Unicode TR18 RL1.6-tal.

Például AnyNewLine nélkül a karakterláncok Windows sorvégződésekkel való egyeztetéséhez manuális megoldások, mint például \r?$ szükségesek.

// BUG: .+$ captures trailing \r on Windows line endings
var match = Regex.Match("foo\r\nbar", @".+$", RegexOptions.Multiline);
Console.WriteLine(match.Value); // "foo\r" -- not "foo"!

A AnyNewLine horgonyok automatikusan kezelik az összes újsor típust:

var match = Regex.Match("foo\r\nbar", @".+$",
    RegexOptions.Multiline | RegexOptions.AnyNewLine);
Console.WriteLine(match.Value); // "foo"

Az alábbi táblázat összefoglalja, hogyan AnyNewLine hat az egyes szerkezetekre:

Épít	Alapértelmezett viselkedés	Val `AnyNewLine`
`.` (alapértelmezett)	Bármely karaktert megfeleltet, kivéve `\n`	Bármely karakterhez megfelel, kivéve `\r`, `\n`, `\u0085`, `\u2028`, `\u2029`
`$` (Többsoros)	Egyezések korábban `\n`	`\r\n`Korábbi egyezések , `\r`, `\n`, `\u0085`, `\u2028\u2029`
`^` (Többsoros)	Találatok a következő után: `\n`	Egyezések a következő után `\r\n`, `\r`, `\n`, `\u0085`, `\u2028`, `\u2029`
`$` (alapértelmezett) / `\Z`	Egyezések a karakterlánc végén a `\n` előtt	Egyezések a sztring végén lévő új sorütemezések előtt

Főbb tervezési pontok:

\r\n atomi módon van kezelve: $ a teljes \r\n sorozat előtt egyezik, soha sem \r és \n között.
Singleline elsőbbséget élvez: . mind a Singleline, mind a AnyNewLine minden karakterrel (beleértve az új sorokat is) egyezik meg, következetesen Singleline meglévő viselkedésével.
\A és \z változatlanok maradnak: Az abszolút kezdő- és végpozíciós horgonyok a karakterláncban nem változnak.
Inkompatibilis beállítások: AnyNewLine nem kombinálható a következővel RegexOptions.NonBacktracking : vagy RegexOptions.ECMAScript. Ennek megkísérlése kivált egy ArgumentOutOfRangeException.

Lásd még

Reguláris kifejezés nyelve – rövid útmutató

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-04-15

Reguláris kifejezés beállításai

Beállítások megadása

Beállítások meghatározása

Alapértelmezett beállítások

Kis- és nagybetűk megkülönböztetése

Többsoros mód

Egysoros mód

Csak explicit rögzítések

Lefordított reguláris kifejezések

Üres terület figyelmen kívül hagyása

Jobbról balra irányultság

Példa

Kiértékelési sorrend

Lookahead és lookbehind állítások

ECMAScript-egyeztetési viselkedés

Összehasonlítás az invariáns kultúra használatával

Nem-visszakövető mód

AnyNewLine mód

Lásd még

Visszajelzés

További források