Normal ifade seçenekleri

Varsayılan olarak, giriş dizesinin normal ifade desenindeki değişmez karakterlerle karşılaştırılması büyük/küçük harfe duyarlıdır, normal ifade desenindeki boşluk değişmez boşluk karakterleri olarak yorumlanır ve normal ifadedeki grupları yakalama işlemi örtük olarak ve açıkça adlandırılır. Normal ifade seçeneklerini belirterek bunları ve varsayılan normal ifade davranışının diğer çeşitli yönlerini değiştirebilirsiniz. Aşağıdaki tabloda listelenen bu seçeneklerden bazıları normal ifade deseninin bir parçası olarak satır içi olarak eklenebilir veya bir sınıf oluşturucusunda veya sabit listesi değeri olarak System.Text.RegularExpressions.RegexOptions statik desen eşleştirme yöntemine System.Text.RegularExpressions.Regex sağlanabilir.

Seçenekleri belirtme

Normal ifadeler için seçenekleri üç yoldan biriyle belirtebilirsiniz:

• options Veya gibi Regex(String, RegexOptions) Regex.Match(String, String, RegexOptions)bir System.Text.RegularExpressions.Regex sınıf oluşturucusunun veya statik (SharedVisual Basic'te) desen eşleştirme yönteminin parametresinde. options parametresi, numaralandırılmış değerlerin System.Text.RegularExpressions.RegexOptions bit düzeyinde VEYA birleşimidir.

  Bir sınıf oluşturucusunun options parametresi kullanılarak bir Regex örneğe seçenekler sağlandığında, seçenekler özelliğine System.Text.RegularExpressions.RegexOptions atanır. Ancak, System.Text.RegularExpressions.RegexOptions özelliği normal ifade desenindeki satır içi seçenekleri yansıtmaz.

  Aşağıdaki örnek, bir gösterim sağlar. Büyük/küçük harfe duyarsız eşleştirmeyi etkinleştirmek ve "d" harfiyle başlayan sözcükleri tanımlarken desen boşluklarını yoksaymak için yönteminin parametresini Regex.Match(String, String, RegexOptions) kullanıroptions.

  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.      
  

• Söz dizimi (?imnsx-imnsx)ile normal ifade deseninde satır içi seçenekleri uygulayarak. seçenek, seçeneğin tanımlandığı noktadan desenin sonuna veya seçeneğin başka bir satır içi seçenek tarafından tanımlanmadığı noktaya kadar desene uygulanır. Örneğin Regex özelliğinin System.Text.RegularExpressions.RegexOptions bu satır içi seçenekleri yansıtmadığını unutmayın. Daha fazla bilgi için Çeşitli Yapılar konusuna bakın.

  Aşağıdaki örnek, bir gösterim sağlar. Büyük/küçük harfe duyarsız eşleştirmeyi etkinleştirmek ve "d" harfiyle başlayan sözcükleri tanımlarken desen boşluklarını yoksaymak için satır içi seçenekleri kullanır.

  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.      
  

• Belirli bir gruplandırma yapısında satır içi seçenekleri, söz dizimi (?imnsx-imnsx:alt) ifadesiyle normal bir ifade düzeninde uygulayarak. Bir dizi seçenek, kümeyi açmadan önce hiçbir işaret yoktur; bir dizi seçenek ayarı kapatmadan önce eksi işareti. (? dil yapısının söz diziminin, seçeneklerin etkin veya devre dışı olması fark etmeksizin gerekli olan sabit bir parçasıdır.) bu seçenek yalnızca bu grup için geçerlidir. Daha fazla bilgi için bkz . Gruplandırma Yapıları.

  Aşağıdaki örnek, bir gösterim sağlar. Büyük/küçük harfe duyarsız eşleştirmeyi etkinleştirmek ve "d" harfiyle başlayan sözcükleri tanımlarken desen boşluklarını yoksaymak için bir gruplandırma yapısındaki satır içi seçenekleri kullanır.

  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.      
  

Seçenekler satır içinde belirtilirse, bir seçenek veya seçenek kümesinden önce bir eksi işareti (-) bu seçenekleri kapatır. Örneğin, satır içi yapısı (?ix-ms) ve seçeneklerini açar RegexOptions.IgnoreCase ve ve RegexOptions.Singleline seçeneklerini kapatır RegexOptions.Multiline RegexOptions.IgnorePatternWhitespace. Tüm normal ifade seçenekleri varsayılan olarak kapalıdır.

Aşağıdaki beş normal ifade seçeneği hem options parametresi hem de satır içi ile ayarlanabilir:

• RegexOptions.IgnoreCase

• RegexOptions.Multiline

• RegexOptions.Singleline

• RegexOptions.ExplicitCapture

• RegexOptions.IgnorePatternWhitespace

Aşağıdaki beş normal ifade seçeneği parametresi kullanılarak options ayarlanabilir ancak satır içinde ayarlanamaz:

• RegexOptions.None

• RegexOptions.Compiled

• RegexOptions.RightToLeft

• RegexOptions.CultureInvariant

• RegexOptions.ECMAScript

Seçenekleri belirleme

Salt okunur Regex.Options özelliğin değerini alarak bir Regex nesnenin örneği oluşturulduğunda hangi seçeneklerin sağlandığını belirleyebilirsiniz.

dışında RegexOptions.Noneherhangi bir seçeneğin varlığını test etmek için, özelliğin Regex.Options değeri ve RegexOptions ilgilendiğiniz değerle bir AND işlemi gerçekleştirin. Ardından sonucun bu RegexOptions değere eşit olup olmadığını test edin. Aşağıdaki örnek, seçeneğin ayarlanıp ayarlanmadığını RegexOptions.IgnoreCase sınar.

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

için test etmek için RegexOptions.None, aşağıdaki örnekte gösterildiği gibi özelliğinin değerinin Regex.Options değerine eşit RegexOptions.Noneolup olmadığını belirleyin.

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

Aşağıdaki bölümlerde.NET'te normal ifade tarafından desteklenen seçenekler listelenmiştir.

Varsayılan seçenekler

RegexOptions.None seçeneği, hiçbir seçeneğin belirtilmediğinden ve normal ifade altyapısının varsayılan davranışını kullandığını gösterir. Bunlar arasında aşağıdakiler yer alır:

• Desen, ECMAScript normal ifadesi yerine kurallı olarak yorumlanır.

• Normal ifade deseni, giriş dizesinde soldan sağa eşleştirilir.

• Karşılaştırmalar büyük/küçük harfe duyarlıdır.

• ^ ve $ dil öğeleri giriş dizesinin başlangıcını ve sonunu gösterir. Giriş dizesinin sonu, sondaki yeni satır \n karakteri olabilir.

• . Dil öğesi dışındaki \nher karakterle eşleşir.

• Normal ifade desenindeki boşluklar değişmez boşluk karakteri olarak yorumlanır.

• Geçerli kültürün kuralları, desen giriş dizesiyle karşılaştırılırken kullanılır.

• Normal ifade desenindeki grupları yakalama örtük ve açıktır.

RegexOptions.None seçeneği normal ifade altyapısının varsayılan davranışını temsil ettiğinden, yöntem çağrısında nadiren belirtilir. Bunun yerine parametresi olmayan bir options oluşturucu veya statik desen eşleştirme yöntemi çağrılır.

Büyük/küçük harfe duyarlı olmayan eşleştirme

seçeneği IgnoreCase veya i satır içi seçeneği büyük/küçük harfe duyarsız eşleştirme sağlar. Varsayılan olarak, geçerli kültürün büyük/küçük harf kuralları kullanılır.

Aşağıdaki örnek, \bthe\w*\b"the" ile başlayan tüm sözcüklerle eşleşen bir normal ifade deseni tanımlar. yöntemine Match yapılan ilk çağrı varsayılan büyük/küçük harfe duyarlı karşılaştırmayı kullandığından çıkış, cümleyi başlayan "The" dizesinin eşleşmediğini gösterir. yöntemi olarak ayarlanmış IgnoreCaseseçeneklerle çağrıldığında Match eşleştirilir.

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.

Aşağıdaki örnek, büyük/küçük harfe duyarsız karşılaştırma sağlamak için parametresi yerine satır içi seçenekleri kullanmak üzere önceki örnekteki options normal ifade desenini değiştirir. İlk desen, yalnızca "the" dizesindeki "t" harfine uygulanan bir gruplandırma yapısında büyük/küçük harfe duyarsız seçeneğini tanımlar. Seçenek yapısı desenin başında gerçekleştiğinden, ikinci desen büyük/küçük harfe duyarsız seçeneğini normal ifadenin tamamına uygular.

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.

Çok satırlı mod

RegexOptions.Multiline seçeneği veya m satır içi seçeneği, normal ifade altyapısının birden çok satırdan oluşan bir giriş dizesini işlemesini sağlar. ve $ dil öğelerinin yorumunu^, giriş dizesinin başlangıcı ve sonu yerine bir satırın başlangıcını ve sonunu gösterecek şekilde değiştirir.

Varsayılan olarak, $ yalnızca giriş dizesinin sonundan memnun kalır. Seçeneğini belirtirseniz RegexOptions.Multiline , yeni satır karakteri (\n) veya giriş dizesinin sonu tarafından karşılanır.

Her iki durumda da satır başı/satır besleme karakter bileşimini (\r\n ) tanımaz$. $ her zaman herhangi bir satır başı (\r) yoksayar. Eşleşmenizi veya \r\n \nile sonlandırmak için yalnızca $yerine alt ifadeyi \r?$ kullanın. Bunun, eşleşmenin \r bir kısmını oluşturacağını unutmayın.

Aşağıdaki örnek, kasecilerin adlarını ve puanlarını ayıklar ve bunları azalan düzende sıralayan bir SortedList<TKey,TValue> koleksiyona ekler. Matches yöntemi iki kez çağrılır. İlk yöntem çağrısında normal ifadedir ^(\w+)\s(\d+)$ ve hiçbir seçenek ayarlanmadı. Çıktıda gösterildiği gibi, normal ifade altyapısı giriş dizesinin başlangıcı ve sonuyla birlikte giriş deseniyle eşleşemediğinden eşleşme bulunmaz. İkinci yöntem çağrısında normal ifade olarak ^(\w+)\s(\d+)\r?$ değiştirilir ve seçenekler olarak RegexOptions.Multilineayarlanır. Çıktıda gösterildiği gibi, adlar ve puanlar başarıyla eşleştirilir ve puanlar azalan sırada görüntülenir.

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

Normal ifade deseni ^(\w+)\s(\d+)\r*$ aşağıdaki tabloda gösterildiği gibi tanımlanır.

Aşağıdaki örnek, çok satırlı seçeneği ayarlamak için satır içi seçeneğini (?m) kullanması dışında öncekine eşdeğerdir.

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

Tek satırlı mod

RegexOptions.Singleline seçeneği veya s satır içi seçeneği, normal ifade altyapısının giriş dizesini tek bir satırdan oluşuyor gibi ele almasına neden olur. Bunu, nokta (.) dil öğesinin davranışını değiştirerek, yeni satır karakteri dışındaki her karakterle eşleştirmek yerine her karakterle \neşleşmesini sağlar.

Aşağıdaki örnekte, seçeneğini kullandığınızda dil öğesinin davranışının . nasıl değiştiği gösterilmektedir RegexOptions.Singleline . Normal ifade ^.+ dizenin başında başlar ve her karakterle eşleşir. Varsayılan olarak, eşleşme ilk satırın sonunda biter; normal ifade deseni satır başı karakteriyle \reşleşir, ancak ile eşleşmiyor \n. RegexOptions.Singleline seçeneği giriş dizesinin tamamını tek bir satır olarak yorumladığı için, dahil olmak üzere \ngiriş dizesindeki her karakterle eşleşir.

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

Aşağıdaki örnek, tek satır modunu etkinleştirmek için satır içi seçeneğini (?s) kullanması dışında öncekine eşdeğerdir.

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

Yalnızca açık yakalamalar

Varsayılan olarak, yakalama grupları normal ifade deseninde parantezlerin kullanılmasıyla tanımlanır. Adlandırılmış gruplara ad alt ifade) dili seçeneği tarafından(?< bir ad>veya sayı atanırken, adsız gruplara dizin tarafından erişilebilir. nesnesinde GroupCollection , adlandırılmamış gruplar adlandırılmış grupların önünde yer alır.

Gruplandırma yapıları genellikle yalnızca birden çok dil öğesine niceleyici uygulamak için kullanılır ve yakalanan alt dizeler ilgi çekici değildir. Örneğin, aşağıdaki normal ifade:

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

yalnızca bir belgeden nokta, ünlem işareti veya soru işaretiyle biten tümceleri ayıklamak için tasarlanmıştır; yalnızca sonuçta elde edilen tümce (nesne tarafından Match temsil edilir) ilgi çekicidir. Koleksiyondaki tek tek sözcükler değildir.

Normal ifade altyapısının hem hem CaptureCollection de GroupCollection koleksiyon nesnelerini doldurması gerektiğinden, daha sonra kullanılmayan grupları yakalamak pahalı olabilir. Alternatif olarak, yalnızca geçerli yakalamaların ad alt ifade) yapısı tarafından (?<>belirlenen açıkça adlandırılmış veya numaralandırılmış gruplar olduğunu belirtmek için seçeneğini veya n satır içi seçeneğini kullanabilirsinizRegexOptions.ExplicitCapture.

Aşağıdaki örnek, yöntem ile ve seçeneği olmadan RegexOptions.ExplicitCapture çağrıldığında normal ifade deseni Match tarafından \b\(?((\w+),?\s?)+[\.!?]\)? döndürülen eşleşmeler hakkında bilgi görüntüler. İlk yöntem çağrısının çıkışında gösterildiği gibi, normal ifade altyapısı ve CaptureCollection koleksiyon nesnelerini yakalanan alt dizeler hakkındaki bilgilerle tamamen doldururGroupCollection. İkinci yöntem olarak ayarlanmış RegexOptions.ExplicitCaptureolarak çağrıldığındanoptions, gruplarla ilgili bilgileri yakalamaz.

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.

Normal ifade deseni\b\(?((?>\w+),?\s?)+[\.!?]\)? aşağıdaki tabloda gösterildiği gibi tanımlanır.

Otomatik yakalamaları (?n) engellemek için satır içi öğesini de kullanabilirsiniz. Aşağıdaki örnek, önceki normal ifade desenini (?n) seçeneği yerine satır içi öğesini kullanacak şekilde RegexOptions.ExplicitCapture değiştirir.

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.

Son olarak, grup halinde otomatik yakalamaları engellemek için satır içi grup öğesini (?n:) kullanabilirsiniz. Aşağıdaki örnek, dış gruptaki ((?>\w+),?\s?)adsız yakalamaları engellemek için önceki deseni değiştirir. Bunun, iç gruptaki adsız yakalamaları da gizlediğini unutmayın.

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.

Derlenmiş normal ifadeler

Varsayılan olarak, .NET'teki normal ifadeler yorumlanır. Bir Regex nesne örneği başlatıldığında veya statik Regex bir yöntem çağrıldığında, normal ifade deseni bir özel işlem kodları kümesine ayrıştırılır ve yorumlayıcı bu işlem kodlarını kullanarak normal ifadeyi çalıştırır. Bu bir dengeyi içerir: normal ifade altyapısını başlatma maliyeti, çalışma zamanı performansı pahasına en aza indirilir.

seçeneğini kullanarak, yorumlanmış normal ifadeler yerine derlenmiş kullanabilirsiniz RegexOptions.Compiled . Bu durumda, bir desen normal ifade altyapısına geçirildiğinde, bir dizi işlem koduna ayrıştırılır ve ardından doğrudan ortak dil çalışma zamanına geçirilebilen ortak ara dile (CIL) dönüştürülür. Derlenmiş normal ifadeler, başlatma süresi pahasına çalışma zamanı performansını en üst düzeye çıkarır.

Hem statik hem de örnek normal ifadelerine yönelik çağrılarda derlenmiş normal ifadeleri kullanabilirsiniz. Statik normal ifadelerde, RegexOptions.Compiled seçeneği normal ifade desen eşleştirme yönteminin parametresine options geçirilir. Örneğin normal ifadeler, sınıf oluşturucusunun options parametresine Regex geçirilir. Her iki durumda da performansın artırılmasına neden olur.

Ancak, performanstaki bu iyileştirme yalnızca aşağıdaki koşullar altında gerçekleşir:

• Regex Belirli bir normal ifadeyi temsil eden bir nesne, normal ifade desen eşleştirme yöntemlerine yapılan birden çok çağrıda kullanılır.

• Nesnenin Regex kapsam dışına çıkmalarına izin verilmiyor, bu nedenle yeniden kullanılabilir.

• Statik normal ifade, normal ifade desen eşleştirme yöntemlerine yapılan birden çok çağrıda kullanılır. (Statik yöntem çağrılarında kullanılan normal ifadeler normal ifade altyapısı tarafından önbelleğe alındığından performans iyileştirmesi mümkündür.)

Boşluğu yoksay

Varsayılan olarak, normal ifade desenindeki boşluk önemlidir; normal ifade altyapısını giriş dizesindeki bir boşluk karakteriyle eşleşmeye zorlar. Bu nedenle, "\b\w+\s" ve " " "\b\w+ normal ifadeleri kabaca eşdeğer normal ifadelerdir. Buna ek olarak, normal ifade deseninde sayı işareti (#) ile karşılaşıldığında, eşleştirilecek değişmez karakter olarak yorumlanır.

seçeneği RegexOptions.IgnorePatternWhitespace veya x satır içi seçeneği, bu varsayılan davranışı aşağıdaki gibi değiştirir:

• Normal ifade desenindeki boşaltılmamış boşluk yoksayılır. Normal ifade deseninin bir parçası olmak için boşluk karakterlerinin kaçış karakteri (örneğin, " veya \s "\ ") olması gerekir.

• Sayı işareti (#), değişmez karakter yerine açıklamanın başlangıcı olarak yorumlanır. Normal ifade desenindeki karakterden # sonraki \n karaktere veya dizenin sonuna kadar olan tüm metinler açıklama olarak yorumlanır.

Ancak, aşağıdaki durumlarda, seçeneğini kullansanız RegexOptions.IgnorePatternWhitespace bile normal ifadedeki boşluk karakterleri yoksayılamaz:

• Karakter sınıfı içindeki boşluklar her zaman tam anlamıyla yorumlanır. Örneğin, normal ifade deseni [ .,;:] herhangi bir tek boşluk karakteri, nokta, virgül, noktalı virgül veya iki nokta üst üste ile eşleşir.

• Köşeli ayraçlı niceleyici içinde n, {n},} ve {n,m} gibi {boşluklara izin verilmez. Örneğin, normal ifade deseni \d{1, 3} boşluk karakteri içerdiğinden bir ile üç basamak arasındaki basamak dizileriyle eşleşemez.

• Dil öğesini tanıtırken karakter dizisinde boşluk olmasına izin verilmez. Örneğin:

  • Dil öğesi (?:alt ifadesi) , kapsüllenmeyen bir grubu temsil eder ve (?: öğenin bölümünde eklenmiş boşluk olamaz. Normal ifade altyapısı deseni ayrıştıramadığından ve desen (? :alt) ifadesi alt ifadeyle eşleşmediğinden, desen ( ?:alt) ifadesi çalışma zamanında bir ArgumentException oluşturur.

  • Unicode kategorisini veya adlandırılmış bloğu temsil eden dil öğesi \p{adı}, öğenin bölümüne eklenmiş boşluklar \p{ içeremez. Boşluk eklerseniz, öğesi çalışma zamanında bir ArgumentException oluşturur.

Bu seçeneğin etkinleştirilmesi, genellikle ayrıştırılması ve anlaşılması zor olan normal ifadeleri basitleştirmeye yardımcı olur. Okunabilirliği artırır ve normal ifadeyi belgelemesini mümkün kılar.

Aşağıdaki örnek aşağıdaki normal ifade desenini tanımlar:

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

Bu desen, yalnızca Açık Yakalamalar bölümünde tanımlanan desene benzer, ancak desen boşluklarını RegexOptions.IgnorePatternWhitespace yoksayma seçeneğini kullanır.

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.

Aşağıdaki örnek, desen boşluklarını yoksaymak için satır içi seçeneğini (?x) kullanır.

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.

Sağdan sola modu

Varsayılan olarak, normal ifade altyapısı soldan sağa arar. seçeneğini kullanarak RegexOptions.RightToLeft arama yönünü tersine çevirebilirsiniz. Sağdan sola arama otomatik olarak dizenin son karakter konumunda başlar. gibi Regex.Match(String, Int32)bir başlangıç konumu parametresi içeren desen eşleştirme yöntemleri için, belirtilen başlangıç konumu, aramanın başlayacağı en sağdaki karakter konumunun dizinidir.

Örnek

Normal ifade \bb\w+\s , "b" harfiyle başlayan ve ardından boşluk karakteri gelen iki veya daha fazla karakter içeren sözcüklerle eşleşir. Aşağıdaki örnekte, giriş dizesi bir veya daha fazla "b" karakteri içeren üç sözcük içerir. birinci ve ikinci sözcükler "b" ile başlar ve üçüncü sözcük "b" ile biter. Sağdan sola arama örneğinden elde edilen çıktıda gösterildiği gibi, normal ifade deseniyle yalnızca birinci ve ikinci sözcükler eşleşir ve ikinci sözcük önce eşleştirilir.

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.

Değerlendirme sırası

seçeneği RegexOptions.RightToLeft arama yönünü değiştirir ve ayrıca normal ifade deseninin değerlendirilme sırasını tersine çevirir. Sağdan sola aramada arama düzeni sağdan sola okunur. Yakalama grupları ve geri başvurular gibi öğeleri etkileyebildiği için bu ayrım önemlidir. Örneğin, ifade Regex.Match("abcabc", @"\1(abc)", RegexOptions.RightToLeft) bir eşleşme abcabcbulur, ancak soldan sağa aramada ()Regex.Match("abcabc", @"\1(abc)", RegexOptions.None) eşleşme bulunmaz. Bunun nedeni, bir eşleşmenin (abc) bulunması için numaralandırılmış yakalama grubu öğesinden (\1) önce öğesinin değerlendirilmesi gerekir.

Lookahead ve lookbehind onayları

Bir lookahead () veya lookbehind ((?=subexpression)(?<=subexpression)) onayı için eşleşmenin konumu sağdan sola aramada değişmez. Lookahead onayları geçerli eşleşme konumunun sağındakine bakar; lookbehind onayları geçerli eşleşme konumunun soluna bakar.

Örneğin, normal ifade (?<=\d{1,2}\s)\w+,\s\d{4} bir ay adından önceki bir tarihi test etmek için lookbehind onayını kullanır. Ardından normal ifade ay ve yıl ile eşleşir. Lookahead ve lookbehind onayları hakkında bilgi için bkz . Yapıları Gruplandırma.

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.

Normal ifade deseni aşağıdaki tabloda gösterildiği gibi tanımlanır.

ECMAScript eşleştirme davranışı

Varsayılan olarak, normal ifade altyapısı normal ifade desenini metin girişiyle eşleştirirken kurallı davranış kullanır. Ancak, seçeneği belirterek RegexOptions.ECMAScript normal ifade altyapısına ECMAScript eşleştirme davranışını kullanmasını belirtebilirsiniz.

Bu RegexOptions.ECMAScript seçenek yalnızca ve RegexOptions.Multiline seçenekleriyle RegexOptions.IgnoreCase birleştirilebilir. Normal ifadede başka bir seçeneğin kullanılması sonucunda bir ArgumentOutOfRangeExceptionolur.

ECMAScript ve kurallı normal ifadelerin davranışı üç alanda farklılık gösterir: karakter sınıfı söz dizimi, kendi kendine başvuran yakalama grupları ve sekizli ve geri başvuru yorumu.

• Karakter sınıfı söz dizimi. Kurallı normal ifadeler Unicode'u desteklediği halde ECMAScript desteklemediğinden, ECMAScript'teki karakter sınıflarının söz dizimi daha sınırlıdır ve bazı karakter sınıfı dil öğeleri farklı anlamlara sahiptir. Örneğin, ECMAScript Unicode kategorisi veya blok öğeleri ve \Pgibi dil öğelerini \p desteklemez. Benzer şekilde, bir sözcük karakteriyle \w eşleşen öğesi, ECMAScript kullanılırken ve [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] kurallı davranış kullanılırken karakter sınıfıyla eşdeğerdir[a-zA-Z_0-9]. Daha fazla bilgi için bkz . Karakter Sınıfları.

  Aşağıdaki örnekte kurallı ve ECMAScript desen eşleştirme arasındaki fark gösterilmektedir. Ardından boşluk karakterleri gelen sözcüklerle eşleşen bir normal ifade \b(\w+\s*)+tanımlar. Giriş, biri Latin karakter kümesini, diğeri kiril karakter kümesini kullanan iki dizeden oluşur. Çıktıda gösterildiği gibi ECMAScript eşleştirmesi Regex.IsMatch(String, String, RegexOptions) kullanan yöntemine yapılan çağrı Kiril sözcüklerle eşleşemezken kurallı eşleştirme kullanan yöntem çağrısı bu sözcüklerle eşleşir.

  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.
  

• Kendi kendine başvuran yakalama grupları. Kendisine bir geri başvuru içeren normal ifade yakalama sınıfı, her yakalama yinelemesiyle güncelleştirilmelidir. Aşağıdaki örnekte gösterildiği gibi bu özellik, normal ifadenin ((a+)(\1) ?)+ ECMAScript kullanırken " aa aa aaaaaa " giriş dizesiyle eşleşmesini sağlar, ancak kurallı eşleştirme kullanılırken eşleşmez.

  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 '
  

  Normal ifade aşağıdaki tabloda gösterildiği gibi tanımlanır.

  Desen	Açıklama
  (a+)	"a" harfini bir veya daha fazla kez eşleştirin. Bu ikinci yakalama grubudur.
  (\1)	İlk yakalama grubu tarafından yakalanan alt dizeyi eşleştirin. Bu, üçüncü yakalama grubudur.
  ?	Sıfır veya bir boşluk karakteri eşleştirin.
  ((a+)(\1) ?) +	Bir veya daha fazla "a" karakterinin desenini ve ardından ilk yakalama grubuyla eşleşen bir dizeyi ve ardından sıfır veya bir boşluk karakterini bir veya daha fazla kez eşleştirin. Bu ilk yakalama grubudur.

• Sekizli kaçışlar ile geri başvurular arasındaki belirsizliklerin çözümü. Aşağıdaki tabloda kurallı ve ECMAScript normal ifadelerine göre sekizlik ve geri başvuru yorumlama arasındaki farklar özetlenir.

  Regular expression	Kurallı davranış	ECMAScript davranışı
  \0 ardından 0 ile 2 sekizli basamak	Sekizli olarak yorumla. Örneğin, \044 her zaman sekizlik değer olarak yorumlanır ve "$" anlamına gelir.	Aynı davranış.
  \ ve ardından 1 ile 9 arasından bir basamak ve ardından ek ondalık basamak yok,	Geri başvuru olarak yorumla. Örneğin, \9 dokuzuncu bir yakalama grubu olmasa bile her zaman geri başvuru 9 anlamına gelir. Yakalama grubu yoksa, normal ifade ayrıştırıcısı bir ArgumentExceptionoluşturur.	Tek bir ondalık basamak yakalama grubu varsa, bu rakama geri başvuru yapın. Aksi takdirde, değeri değişmez değer olarak yorumlar.
  \ ardından 1 ile 9 arasından bir basamak ve ardından ek ondalık basamaklar	Basamakları ondalık değer olarak yorumlama. Bu yakalama grubu varsa, ifadeyi geri başvuru olarak yorumla. Aksi takdirde, sekizli basamakları sekizlik 377'ye kadar yorumla; başka bir ifadeyle, değerin yalnızca düşük 8 bitini göz önünde bulundurun. Kalan basamakları değişmez değer olarak yorumla. Örneğin, ifadesinde \3000, 300 grubu yakalanıyorsa geri başvuru 300 olarak yorumla; 300 grubunu yakalama yoksa, sekizli 300 ve ardından 0 olarak yorumla.	Mümkün olduğunca çok basamağı yakalamaya başvurabilen ondalık bir değere dönüştürerek geri başvuru olarak yorumlayabilirsiniz. Hiçbir basamak dönüştürülemiyorsa, sekizlik 377'ye kadar olan baştaki sekizlik basamakları kullanarak sekizli olarak yorumlayabilirsiniz; kalan basamakları değişmez değer olarak yorumlar.

Sabit kültürü kullanarak karşılaştırma

Varsayılan olarak, normal ifade altyapısı büyük/küçük harfe duyarsız karşılaştırmalar gerçekleştirdiğinde, eşdeğer büyük ve küçük harf karakterlerini belirlemek için geçerli kültürün büyük/küçük harf kurallarını kullanır.

Ancak bu davranış, özellikle kullanıcı girişini parolalar, dosyalar veya URL'ler gibi sistem kaynaklarının adlarıyla karşılaştırırken bazı karşılaştırma türleri için istenmeyen bir davranıştır. Aşağıdaki örnekte bu tür bir senaryo gösterilmektedir. Kod, URL'si FILE:// ile önceden oluşturulmuş herhangi bir kaynağa erişimi engellemeye yöneliktir. Normal ifade, normal ifadesini $FILE://kullanarak dizeyle büyük/küçük harfe duyarlı olmayan bir eşleşme dener. Ancak mevcut sistem kültürü tr-TR (Türk-Türkiye) olduğunda "i" büyük harfle eşdeğer değildir. Sonuç olarak, yöntemine Regex.IsMatch yapılan çağrı döndürür falseve dosyaya erişime izin verilir.

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.

Geçerli kültürün büyük/küçük harfe duyarsız karşılaştırmalarını kullanmak yerine, dildeki kültürel farklılıkları yoksayma ve sabit kültürün kurallarını kullanma seçeneğini belirtebilirsiniz RegexOptions.CultureInvariant .

Aşağıdaki örnek, statik Regex.IsMatch(String, String, RegexOptions) yöntemi içeren seçeneklerle RegexOptions.CultureInvariantçağrılmaları dışında önceki örnekle aynıdır. Geçerli kültür Türkçe (Türkiye) olarak ayarlandığında bile normal ifade altyapısı "DOSYA" ve "dosya" ile başarıyla eşleşip dosya kaynağına erişimi engelleyebilir.

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.

Geri izleme modu

Varsayılan olarak, . NET'in regex altyapısı, desen eşleşmelerini bulmaya çalışmak için geri izlemeyi kullanır. Geri izleme altyapısı, tek bir desenle eşleşmeye çalışan altyapıdır ve bu başarısız olursa geri gider ve alternatif bir desenle eşleştirmeye çalışır, vb. Geri izleme altyapısı tipik durumlar için çok hızlıdır, ancak desen değişimlerinin sayısı arttıkça yavaşlar ve bu da yıkıcı geri dönüşlere yol açabilir. RegexOptions.NonBacktracking.NET 7'de sunulan seçenek geri izleme kullanmaz ve en kötü senaryoyu önler. Amacı, aranan girişe bakılmaksızın tutarlı bir şekilde iyi davranış sağlamaktır.

Bu RegexOptions.NonBacktracking seçenek, diğer yerleşik altyapıların desteklediği her şeyi desteklemez. Özellikle, seçeneği veya RegexOptions.ECMAScriptile RegexOptions.RightToLeft birlikte kullanılamaz. Ayrıca, desende aşağıdaki yapılara izin vermez:

• Atomik gruplar
• Geri Başvurular
• Dengeleme grupları
• Koşullar
• Aramalar
• Başlangıç tutturucuları (\G)

RegexOptions.NonBacktracking ayrıca yürütmeyle ilgili olarak küçük bir fark vardır. Yakalama grubu bir döngüdeyse, çoğu (non-.NET) regex altyapısı yalnızca bu yakalama için son eşleşen değeri sağlar. Fakat. NET'in regex altyapısı bir döngü içinde yakalanan tüm değerleri izler ve bunlara erişim sağlar. Seçeneği RegexOptions.NonBacktracking diğer çoğu regex uygulamasına benzer ve yalnızca son yakalamayı sağlamayı destekler.

Geri izleme hakkında daha fazla bilgi için bkz . Normal ifadelerde geri izleme.

Ayrıca bkz.

• Normal İfade Dili - Hızlı Başvuru