.NET'te normal ifadeler için en iyi yöntemler

.NET'teki normal ifade altyapısı, metinleri karşılaştırmak ve değişmez metin eşleştirmek yerine desen eşleşmelerine göre işleyen güçlü, tam özellikli bir araçtır. Çoğu durumda desen eşleme işlemini hızlı ve verimli şekilde yapar. Ancak bazı durumlarda normal ifade altyapısı yavaş görünebilir. Aşırı durumlarda saatler ve hatta günler boyunca görece küçük bir girişi işlerken yanıt vermeyi durdurmuş gibi bile görünebilir.

Bu makalede, geliştiricilerin normal ifadelerinin en iyi performansa ulaşmasını sağlamak için benimseyebileceği en iyi uygulamalardan bazıları özetlenmiştir.

Uyarı

Güvenilmeyen girişi işlemek için kullanırken System.Text.RegularExpressions bir zaman aşımı geçirin. Kötü amaçlı bir kullanıcı için giriş RegularExpressionssağlayabilir ve bu da Hizmet Reddi saldırısına neden olabilir. ASP.NET Zaman aşımı kullanan RegularExpressions Core framework API'leri.

Giriş kaynağını göz önünde bulundurun

Genelde normal ifadeler iki tür giriş kabul edebilir: sınırlandırılmış ya da sınırlandırılmamış. Kısıtlanmış giriş, bilinen veya güvenilir bir kaynaktan gelen ve önceden tanımlanmış bir biçimi izleyen bir metindir. Kısıtlanmamış giriş, web kullanıcısı gibi güvenilir olmayan bir kaynaktan gelen ve önceden tanımlanmış veya beklenen bir biçimi izlemeyebilen bir metindir.

Normal ifade desenleri genellikle geçerli girişle eşleşecek şekilde yazılır. Diğer bir deyişle, geliştiriciler eşleştirmek istedikleri metni inceler ve bu metinle eşleşen normal bir ifade deseni yazarlar. Geliştiriciler daha sonra bu desenin düzeltme ya da daha fazla ayrıntı gerektirip gerektirmediğini, birden çok geçerli giriş öğesini test ederek belirler. Desen tüm varsayılan geçerli girişlerle eşleştiğinde üretime hazır olduğu bildirilir ve serbest bırakılmış bir uygulamaya dahil edilebilir. Bu yaklaşım, normal ifade desenini kısıtlanmış girişi eşleştirmek için uygun hale getirir. Ancak, kısıtlanmamış girişi eşleştirmek için uygun hale getirmez.

Kısıtlanmamış girişi eşleştirmek için normal ifadenin üç tür metni verimli bir şekilde işlemesi gerekir:

• Normal ifade deseniyle eşleşen metin.
• Normal ifade deseni ile eşleşmeyen metin.
• Normal ifade deseniyle neredeyse eşleşen metin.

Son metin türü, sınırlandırılmış girdi işlemek üzere yazılmış bir normal ifade için özellikle sorunludur. Bu normal ifade kapsamlı geri izlemeyi de kullanıyorsa, normal ifade altyapısı zararsız görünen metinleri işlemek için normal olmayan bir süre (bazı durumlarda, birkaç saat veya gün) geçirebilir.

Uyarı

Aşağıdaki örnek, aşırı geri göndermeye eğilimli ve geçerli e-posta adreslerini reddetme olasılığı olan normal bir ifade kullanır. Bunu bir e-posta doğrulama yordamında kullanmamalısınız. E-posta adreslerini doğrulayan normal bir ifade istiyorsanız bkz . Nasıl yapılır: Dizelerin Geçerli E-posta Biçiminde Olduğunu Doğrulama.

Örneğin, bir e-posta adresinin diğer adını doğrulamak için yaygın olarak kullanılan ancak sorunlu bir normal ifade düşünün. Normal ifade ^[0-9A-Z]([-.\w]*[0-9A-Z])*$ , geçerli bir e-posta adresi olarak kabul edilenleri işlemek için yazılır. Geçerli bir e-posta adresi alfasayısal karakterden ve ardından alfasayısal, nokta veya kısa çizgi olabilecek sıfır veya daha fazla karakterden oluşur. Normal ifade, alfasayısal bir karakterle bitmelidir. Ancak, aşağıdaki örnekte gösterildiği gibi, bu normal ifade geçerli girişi kolayca işlese de, neredeyse geçerli girişi işlerken performansı verimsizdir:

using System;
using System.Diagnostics;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Stopwatch sw;
      string[] addresses = { "AAAAAAAAAAA@contoso.com",
                             "AAAAAAAAAAaaaaaaaaaa!@contoso.com" };
      // The following regular expression should not actually be used to
      // validate an email address.
      string pattern = @"^[0-9A-Z]([-.\w]*[0-9A-Z])*$";
      string input;

      foreach (var address in addresses) {
         string mailBox = address.Substring(0, address.IndexOf("@"));
         int index = 0;
         for (int ctr = mailBox.Length - 1; ctr >= 0; ctr--) {
            index++;

            input = mailBox.Substring(ctr, index);
            sw = Stopwatch.StartNew();
            Match m = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
            sw.Stop();
            if (m.Success)
               Console.WriteLine("{0,2}. Matched '{1,25}' in {2}",
                                 index, m.Value, sw.Elapsed);
            else
               Console.WriteLine("{0,2}. Failed  '{1,25}' in {2}",
                                 index, input, sw.Elapsed);
         }
         Console.WriteLine();
      }
   }
}

// The example displays output similar to the following:
//     1. Matched '                        A' in 00:00:00.0007122
//     2. Matched '                       AA' in 00:00:00.0000282
//     3. Matched '                      AAA' in 00:00:00.0000042
//     4. Matched '                     AAAA' in 00:00:00.0000038
//     5. Matched '                    AAAAA' in 00:00:00.0000042
//     6. Matched '                   AAAAAA' in 00:00:00.0000042
//     7. Matched '                  AAAAAAA' in 00:00:00.0000042
//     8. Matched '                 AAAAAAAA' in 00:00:00.0000087
//     9. Matched '                AAAAAAAAA' in 00:00:00.0000045
//    10. Matched '               AAAAAAAAAA' in 00:00:00.0000045
//    11. Matched '              AAAAAAAAAAA' in 00:00:00.0000045
//
//     1. Failed  '                        !' in 00:00:00.0000447
//     2. Failed  '                       a!' in 00:00:00.0000071
//     3. Failed  '                      aa!' in 00:00:00.0000071
//     4. Failed  '                     aaa!' in 00:00:00.0000061
//     5. Failed  '                    aaaa!' in 00:00:00.0000081
//     6. Failed  '                   aaaaa!' in 00:00:00.0000126
//     7. Failed  '                  aaaaaa!' in 00:00:00.0000359
//     8. Failed  '                 aaaaaaa!' in 00:00:00.0000414
//     9. Failed  '                aaaaaaaa!' in 00:00:00.0000758
//    10. Failed  '               aaaaaaaaa!' in 00:00:00.0001462
//    11. Failed  '              aaaaaaaaaa!' in 00:00:00.0002885
//    12. Failed  '             Aaaaaaaaaaa!' in 00:00:00.0005780
//    13. Failed  '            AAaaaaaaaaaa!' in 00:00:00.0011628
//    14. Failed  '           AAAaaaaaaaaaa!' in 00:00:00.0022851
//    15. Failed  '          AAAAaaaaaaaaaa!' in 00:00:00.0045864
//    16. Failed  '         AAAAAaaaaaaaaaa!' in 00:00:00.0093168
//    17. Failed  '        AAAAAAaaaaaaaaaa!' in 00:00:00.0185993
//    18. Failed  '       AAAAAAAaaaaaaaaaa!' in 00:00:00.0366723
//    19. Failed  '      AAAAAAAAaaaaaaaaaa!' in 00:00:00.1370108
//    20. Failed  '     AAAAAAAAAaaaaaaaaaa!' in 00:00:00.1553966
//    21. Failed  '    AAAAAAAAAAaaaaaaaaaa!' in 00:00:00.3223372

Imports System.Diagnostics
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim sw As Stopwatch
        Dim addresses() As String = {"AAAAAAAAAAA@contoso.com",
                                   "AAAAAAAAAAaaaaaaaaaa!@contoso.com"}
        ' The following regular expression should not actually be used to 
        ' validate an email address.
        Dim pattern As String = "^[0-9A-Z]([-.\w]*[0-9A-Z])*$"
        Dim input As String

        For Each address In addresses
            Dim mailBox As String = address.Substring(0, address.IndexOf("@"))
            Dim index As Integer = 0
            For ctr As Integer = mailBox.Length - 1 To 0 Step -1
                index += 1
                input = mailBox.Substring(ctr, index)
                sw = Stopwatch.StartNew()
                Dim m As Match = Regex.Match(input, pattern, RegexOptions.IgnoreCase)
                sw.Stop()
                if m.Success Then
                    Console.WriteLine("{0,2}. Matched '{1,25}' in {2}",
                                      index, m.Value, sw.Elapsed)
                Else
                    Console.WriteLine("{0,2}. Failed  '{1,25}' in {2}",
                                      index, input, sw.Elapsed)
                End If
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays output similar to the following:
'     1. Matched '                        A' in 00:00:00.0007122
'     2. Matched '                       AA' in 00:00:00.0000282
'     3. Matched '                      AAA' in 00:00:00.0000042
'     4. Matched '                     AAAA' in 00:00:00.0000038
'     5. Matched '                    AAAAA' in 00:00:00.0000042
'     6. Matched '                   AAAAAA' in 00:00:00.0000042
'     7. Matched '                  AAAAAAA' in 00:00:00.0000042
'     8. Matched '                 AAAAAAAA' in 00:00:00.0000087
'     9. Matched '                AAAAAAAAA' in 00:00:00.0000045
'    10. Matched '               AAAAAAAAAA' in 00:00:00.0000045
'    11. Matched '              AAAAAAAAAAA' in 00:00:00.0000045
'    
'     1. Failed  '                        !' in 00:00:00.0000447
'     2. Failed  '                       a!' in 00:00:00.0000071
'     3. Failed  '                      aa!' in 00:00:00.0000071
'     4. Failed  '                     aaa!' in 00:00:00.0000061
'     5. Failed  '                    aaaa!' in 00:00:00.0000081
'     6. Failed  '                   aaaaa!' in 00:00:00.0000126
'     7. Failed  '                  aaaaaa!' in 00:00:00.0000359
'     8. Failed  '                 aaaaaaa!' in 00:00:00.0000414
'     9. Failed  '                aaaaaaaa!' in 00:00:00.0000758
'    10. Failed  '               aaaaaaaaa!' in 00:00:00.0001462
'    11. Failed  '              aaaaaaaaaa!' in 00:00:00.0002885
'    12. Failed  '             Aaaaaaaaaaa!' in 00:00:00.0005780
'    13. Failed  '            AAaaaaaaaaaa!' in 00:00:00.0011628
'    14. Failed  '           AAAaaaaaaaaaa!' in 00:00:00.0022851
'    15. Failed  '          AAAAaaaaaaaaaa!' in 00:00:00.0045864
'    16. Failed  '         AAAAAaaaaaaaaaa!' in 00:00:00.0093168
'    17. Failed  '        AAAAAAaaaaaaaaaa!' in 00:00:00.0185993
'    18. Failed  '       AAAAAAAaaaaaaaaaa!' in 00:00:00.0366723
'    19. Failed  '      AAAAAAAAaaaaaaaaaa!' in 00:00:00.1370108
'    20. Failed  '     AAAAAAAAAaaaaaaaaaa!' in 00:00:00.1553966
'    21. Failed  '    AAAAAAAAAAaaaaaaaaaa!' in 00:00:00.3223372

Yukarıdaki örnekte gösterilen çıktıda gösterildiği gibi, normal ifade altyapısı geçerli e-posta diğer adını uzunluğuna bakılmaksızın yaklaşık aynı zaman aralığında işler. Öte yandan, neredeyse geçerli e-posta adresinin beşten fazla karakteri olduğunda, işlem süresi dizedeki her fazladan karakter için yaklaşık olarak iki katına çıkarır. Bu nedenle, neredeyse geçerli bir 28 karakterlik dizenin işlenmesi bir saatten fazla sürebilir ve neredeyse geçerli bir 33 karakterlik dizenin işlenmesi yaklaşık bir gün sürebilir.

Bu normal ifade yalnızca eşleştirilecek giriş biçimi dikkate alınarak geliştirildiğinden, desenle eşleşmeyen girişi dikkate alamaz. Bu gözetim de performansı önemli ölçüde düşürmek için normal ifade deseni ile neredeyse eşleşen kısıtlanmamış girişlere izin verebilir.

Bu sorunu çözmek için, şunları yapabilirsiniz:

• Bir desen geliştirirken, özellikle de normal ifadeniz sınırlandırılmamış girdiyi işlemek üzere tasarlandıysa, geri dönüşün normal ifade altyapısının performansını nasıl etkileyeceğini düşünmelisiniz. Daha fazla bilgi için Geri İzlemenin Sorumluluğunu Alma bölümüne bakın.

• Geçersiz, neredeyse geçerli ve geçerli giriş kullanarak normal ifadenizi kapsamlı bir şekilde test edin. Rex'i kullanarak belirli bir normal ifade için rastgele giriş oluşturabilirsiniz. Rex , Microsoft Research tarafından sağlanan normal bir ifade araştırma aracıdır.

Nesne örneklemesini uygun şekilde işleme

öğesinin merkezinde. NET'in normal ifade nesne modeli, normal ifade altyapısını System.Text.RegularExpressions.Regex temsil eden sınıfıdır. Genellikle, normal ifade performansını etkileyen tek büyük faktör, altyapının Regex kullanılma şeklidir. Normal bir ifadeyi tanımlama, normal ifade motorunu bir normal ifade deseni ile sıkı şekilde eşlemeyi içerir. İster oluşturucusunun normal ifade desenini geçirerek bir nesnenin örneğini Regex oluşturmayı ister normal ifade desenini ve analiz edilecek dizeyi geçirerek statik bir yöntemi çağırmayı içeren bu bağlama işlemi, pahalı bir nesnenin gerekli olmasıdır.

Not

Yorumlanmış ve derlenmiş normal ifadeleri kullanmanın performans üzerindeki etkileri hakkında ayrıntılı bilgi için BCL Ekibi blogundaki Normal İfade Performansını İyi hale getirme, Bölüm II: Geri İzlemenin Sorumluluğunu Alma başlıklı makaleye bakın.

Normal ifade altyapısını belirli bir normal ifade deseniyle eşleştirebilir ve ardından altyapıyı kullanarak metni çeşitli yollarla eşleştirebilirsiniz:

• gibi Regex.Match(String, String)statik desen eşleştirme yöntemini çağırabilirsiniz. Bu yöntem normal ifade nesnesinin örneğini oluşturmayı gerektirmez.

• Bir Regex nesne örneği oluşturabilir ve normal ifade altyapısını normal ifade desenine bağlamak için varsayılan yöntem olan yorumlanmış normal ifadenin örnek desen eşleştirme yöntemini çağırabilirsiniz. Bir nesnenin örneği bayrağını içeren bir options bağımsız değişken olmadan başlatıldığında sonuçlanır.CompiledRegex

• Bir Regex nesne örneği oluşturabilir ve derlenmiş normal ifadenin örnek desen eşleştirme yöntemini çağırabilirsiniz. Normal ifade nesneleri, bir nesne bayrağını içeren bir Regexoptions bağımsız değişkenle örneklendiğinde derlenmiş desenleri temsil eder Compiled .

• Belirli bir normal ifade deseniyle sıkı bir şekilde birleştirilmiş özel amaçlı Regex bir nesne oluşturabilir, derleyebilir ve tek başına bir derlemeye kaydedebilirsiniz. Derlemek Regex.CompileToAssembly ve kaydetmek için yöntemini çağırabilirsiniz.

Normal ifade eşleştirme yöntemlerini çağırmanın belirli bir yolu uygulamanızın performansını etkileyebilir. Aşağıdaki bölümler, uygulamanızın performansını iyileştirmek için statik yöntem çağrılarının, yorumlanan normal ifadelerin ve derlenmiş normal ifadelerin ne zaman kullanılacağını tartışmaktadır.

Önemli

Yöntem çağrılarında aynı normal ifade tekrar tekrar kullanılıyorsa veya uygulama normal ifade nesnelerini yoğun olarak kullanıyorsa, yöntem çağrısının biçimi (statik, yorumlanan, derlenmiş) performansı etkiler.

Statik normal ifadeler

Statik normal ifade yöntemleri, bir normal ifade nesnesine aynı normal ifadeyi tekrar tekrar ön değer olarak atamaya alternatif olarak önerilir. Normal ifade nesneleri tarafından kullanılan normal ifade desenlerinden farklı olarak, statik yöntem çağrılarında kullanılan desenlerden işlem kodları veya derlenmiş ortak ara dil (CIL) normal ifade altyapısı tarafından dahili olarak önbelleğe alınır.

Örneğin bir olay işleyicisi, kullanıcı girişini onaylamak için sık sık başka bir yöntem çağırır. Bu örnek, Button bir denetimin Click olayının adlı IsValidCurrencybir yöntemi çağırmak için kullanıldığı ve kullanıcının en az bir ondalık basamak ile bir para birimi simgesi girip girmediğini denetleyen aşağıdaki koda yansıtılır.

public void OKButton_Click(object sender, EventArgs e)
{
   if (! String.IsNullOrEmpty(sourceCurrency.Text))
      if (RegexLib.IsValidCurrency(sourceCurrency.Text))
         PerformConversion();
      else
         status.Text = "The source currency value is invalid.";
}

Public Sub OKButton_Click(sender As Object, e As EventArgs) _
           Handles OKButton.Click

    If Not String.IsNullOrEmpty(sourceCurrency.Text) Then
        If RegexLib.IsValidCurrency(sourceCurrency.Text) Then
            PerformConversion()
        Else
            status.Text = "The source currency value is invalid."
        End If
    End If
End Sub

Aşağıdaki örnekte yönteminin IsValidCurrency verimsiz bir uygulaması gösterilmiştir:

Not

Her yöntem çağrısı aynı desene sahip bir Regex nesneyi yeniden doğrular. Bu ise normal ifade deseninin yöntem her çağrıldığında tekrar derlenmesi gerektiği anlamına gelir.

using System;
using System.Text.RegularExpressions;

public class RegexLib
{
   public static bool IsValidCurrency(string currencyValue)
   {
      string pattern = @"\p{Sc}+\s*\d+";
      Regex currencyRegex = new Regex(pattern);
      return currencyRegex.IsMatch(currencyValue);
   }
}

Imports System.Text.RegularExpressions

Public Module RegexLib
    Public Function IsValidCurrency(currencyValue As String) As Boolean
        Dim pattern As String = "\p{Sc}+\s*\d+"
        Dim currencyRegex As New Regex(pattern)
        Return currencyRegex.IsMatch(currencyValue)
    End Function
End Module

Önceki verimsiz kodu statik Regex.IsMatch(String, String) yönteme yapılan bir çağrıyla değiştirmeniz gerekir. Bu yaklaşım, desen eşleştirme yöntemini her çağırmak istediğinizde bir Regex nesnenin örneğini oluşturma gereksinimini ortadan kaldırır ve normal ifade altyapısının normal ifadenin derlenmiş bir sürümünü önbelleğinden almasını sağlar.

using System;
using System.Text.RegularExpressions;

public class RegexLib
{
   public static bool IsValidCurrency(string currencyValue)
   {
      string pattern = @"\p{Sc}+\s*\d+";
      return Regex.IsMatch(currencyValue, pattern);
   }
}

Imports System.Text.RegularExpressions

Public Module RegexLib
    Public Function IsValidCurrency(currencyValue As String) As Boolean
        Dim pattern As String = "\p{Sc}+\s*\d+"
        Return Regex.IsMatch(currencyValue, pattern)
    End Function
End Module

Varsayılan olarak, en son kullanılan 15 statik normal ifade deseni önbelleğe alınır. Daha fazla sayıda önbelleğe alınmış statik normal ifade gerektiren uygulamalar için, özelliği ayarlanarak Regex.CacheSize önbelleğin boyutu ayarlanabilir.

Bu örnekte kullanılan normal ifade \p{Sc}+\s*\d+ , giriş dizesinin para birimi simgesi ve en az bir ondalık basamak olduğunu doğrular. Desen aşağıdaki tabloda gösterildiği gibi tanımlanır:

Desen	Açıklama
\p{Sc}+	Unicode Simgesi, Para Birimi kategorisindeki bir veya daha fazla karakterle eşleşir.
\s*	Sıfır veya daha fazla boşluk karakteriyle eşleşir.
\d+	Bir veya daha fazla ondalık basamakla eşleşir.

Yorumlanmış ve derlenmiş normal ifadeler karşılaştırması

Seçeneğin belirtimi Compiled aracılığıyla normal ifade altyapısına bağlı olmayan normal ifade desenleri yorumlanır. Bir normal ifade nesnesi örneği oluşturulduğunda, normal ifade altyapısı normal ifadeyi bir dizi işlem koduna dönüştürür. Bir örnek yöntemi çağrıldığında, işlem kodları CIL'ye dönüştürülür ve JIT derleyicisi tarafından yürütülür. Benzer şekilde, statik bir normal ifade yöntemi çağrıldığında ve normal ifade önbellekte bulunamadığında, normal ifade altyapısı normal ifadeyi bir dizi işlem koduna dönüştürür ve bunları önbellekte depolar. Ardından JIT derleyicisinin yürütebilmesi için bu işlem kodlarını CIL'ye dönüştürür. Yorumlanmış normal ifadeler, daha yavaş yürütme sürelerine karşın açılış süresini azaltır. Bu işlem nedeniyle, normal ifade az sayıda yöntem çağrısında kullanıldığında veya normal ifade yöntemlerine yapılan çağrıların tam sayısı bilinmiyorsa ancak küçük olması bekleniyorsa en iyi şekilde kullanılırlar. Yöntem çağrıları arttıkça performans kazancı daha az başlangıç saatinden sayısı daha yavaş yürütme hızını outstripped gibi.

Seçeneğin belirtimi Compiled aracılığıyla normal ifade altyapısına bağlı normal ifade desenleri derlenir. Bu nedenle, bir normal ifade nesnesi örneği oluşturulduğunda veya statik bir normal ifade yöntemi çağrıldığında ve normal ifade önbellekte bulunamadığında, normal ifade altyapısı normal ifadeyi bir aracı işlem kodları kümesine dönüştürür. Bu kodlar daha sonra CIL'ye dönüştürülür. Bir yöntem çağrıldığında, JIT derleyicisi CIL'yi yürütür. Yorumlanmış normal ifadelerin aksine, derlenmiş normal ifadeler açılış süresini artırır ancak ayrı desen eşleme yöntemlerini daha hızlı yürütür. Sonuç olarak normal ifade derlemekten kaynaklanan sonuçlardan yararlanan performans çağrılan normal ifade yöntemlerinin sayısı oranında artar.

Özetlemek gerekirse, normal ifade yöntemlerini belirli bir normal ifadeyle nispeten ender olarak çağırıyorsanız, yorumlanan normal ifadeler kullanmanızı öneririz. Normal ifade yöntemlerinizi oldukça sık olarak belirli bir normal ifadeyle çağırıyorsanız, derlenmiş normal ifadeler kullanmalısınız. Yorumlanan normal ifadelerin daha yavaş yürütme hızlarının düşük başlangıç sürelerinden elde edilen kazançlara veya derlenmiş normal ifadelerin daha yavaş başlangıç sürelerinin daha yüksek yürütme hızlarından daha ağır bastığı eşiği belirlemek zordur. Normal ifadenin karmaşıklığı ve işlediği belirli veriler de dahil olmak üzere çeşitli faktörlere bağlıdır. Yorumlanmış veya derlenmiş normal ifadelerin belirli bir uygulama senaryonuz için en iyi performansı sunup sunmadığını belirlemek için, sınıfını Stopwatch kullanarak yürütme sürelerini karşılaştırabilirsiniz.

Aşağıdaki örnek, ilk 10 cümleyi okurken ve Theodore Dreiser'ın The Financier metnindeki tüm cümleleri okurken derlenmiş ve yorumlanmış normal ifadelerin performansını karşılaştırır. Örnekteki çıktıda gösterildiği gibi, normal ifade eşleştirme yöntemlerine yalnızca 10 çağrı yapıldığında, yorumlanan normal ifade derlenmiş normal ifadeden daha iyi performans sunar. Ancak derlenmiş bir normal ifade, daha fazla sayıda çağrı yapıldığında (bu örnekte 13.000'den fazla) daha iyi performans gösterir.

using System;
using System.Diagnostics;
using System.IO;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+((\r?\n)|,?\s))*\w+[.?:;!]";
      Stopwatch sw;
      Match match;
      int ctr;

      StreamReader inFile = new StreamReader(@".\Dreiser_TheFinancier.txt");
      string input = inFile.ReadToEnd();
      inFile.Close();

      // Read first ten sentences with interpreted regex.
      Console.WriteLine("10 Sentences with Interpreted Regex:");
      sw = Stopwatch.StartNew();
      Regex int10 = new Regex(pattern, RegexOptions.Singleline);
      match = int10.Match(input);
      for (ctr = 0; ctr <= 9; ctr++) {
         if (match.Success)
            // Do nothing with the match except get the next match.
            match = match.NextMatch();
         else
            break;
      }
      sw.Stop();
      Console.WriteLine("   {0} matches in {1}", ctr, sw.Elapsed);

      // Read first ten sentences with compiled regex.
      Console.WriteLine("10 Sentences with Compiled Regex:");
      sw = Stopwatch.StartNew();
      Regex comp10 = new Regex(pattern,
                   RegexOptions.Singleline | RegexOptions.Compiled);
      match = comp10.Match(input);
      for (ctr = 0; ctr <= 9; ctr++) {
         if (match.Success)
            // Do nothing with the match except get the next match.
            match = match.NextMatch();
         else
            break;
      }
      sw.Stop();
      Console.WriteLine("   {0} matches in {1}", ctr, sw.Elapsed);

      // Read all sentences with interpreted regex.
      Console.WriteLine("All Sentences with Interpreted Regex:");
      sw = Stopwatch.StartNew();
      Regex intAll = new Regex(pattern, RegexOptions.Singleline);
      match = intAll.Match(input);
      int matches = 0;
      while (match.Success) {
         matches++;
         // Do nothing with the match except get the next match.
         match = match.NextMatch();
      }
      sw.Stop();
      Console.WriteLine("   {0:N0} matches in {1}", matches, sw.Elapsed);

      // Read all sentences with compiled regex.
      Console.WriteLine("All Sentences with Compiled Regex:");
      sw = Stopwatch.StartNew();
      Regex compAll = new Regex(pattern,
                      RegexOptions.Singleline | RegexOptions.Compiled);
      match = compAll.Match(input);
      matches = 0;
      while (match.Success) {
         matches++;
         // Do nothing with the match except get the next match.
         match = match.NextMatch();
      }
      sw.Stop();
      Console.WriteLine("   {0:N0} matches in {1}", matches, sw.Elapsed);
   }
}
// The example displays the following output:
//       10 Sentences with Interpreted Regex:
//          10 matches in 00:00:00.0047491
//       10 Sentences with Compiled Regex:
//          10 matches in 00:00:00.0141872
//       All Sentences with Interpreted Regex:
//          13,443 matches in 00:00:01.1929928
//       All Sentences with Compiled Regex:
//          13,443 matches in 00:00:00.7635869
//
//       >compare1
//       10 Sentences with Interpreted Regex:
//          10 matches in 00:00:00.0046914
//       10 Sentences with Compiled Regex:
//          10 matches in 00:00:00.0143727
//       All Sentences with Interpreted Regex:
//          13,443 matches in 00:00:01.1514100
//       All Sentences with Compiled Regex:
//          13,443 matches in 00:00:00.7432921

Imports System.Diagnostics
Imports System.IO
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\w+((\r?\n)|,?\s))*\w+[.?:;!]"
        Dim sw As Stopwatch
        Dim match As Match
        Dim ctr As Integer

        Dim inFile As New StreamReader(".\Dreiser_TheFinancier.txt")
        Dim input As String = inFile.ReadToEnd()
        inFile.Close()

        ' Read first ten sentences with interpreted regex.
        Console.WriteLine("10 Sentences with Interpreted Regex:")
        sw = Stopwatch.StartNew()
        Dim int10 As New Regex(pattern, RegexOptions.SingleLine)
        match = int10.Match(input)
        For ctr = 0 To 9
            If match.Success Then
                ' Do nothing with the match except get the next match.
                match = match.NextMatch()
            Else
                Exit For
            End If
        Next
        sw.Stop()
        Console.WriteLine("   {0} matches in {1}", ctr, sw.Elapsed)

        ' Read first ten sentences with compiled regex.
        Console.WriteLine("10 Sentences with Compiled Regex:")
        sw = Stopwatch.StartNew()
        Dim comp10 As New Regex(pattern,
                     RegexOptions.SingleLine Or RegexOptions.Compiled)
        match = comp10.Match(input)
        For ctr = 0 To 9
            If match.Success Then
                ' Do nothing with the match except get the next match.
                match = match.NextMatch()
            Else
                Exit For
            End If
        Next
        sw.Stop()
        Console.WriteLine("   {0} matches in {1}", ctr, sw.Elapsed)

        ' Read all sentences with interpreted regex.
        Console.WriteLine("All Sentences with Interpreted Regex:")
        sw = Stopwatch.StartNew()
        Dim intAll As New Regex(pattern, RegexOptions.SingleLine)
        match = intAll.Match(input)
        Dim matches As Integer = 0
        Do While match.Success
            matches += 1
            ' Do nothing with the match except get the next match.
            match = match.NextMatch()
        Loop
        sw.Stop()
        Console.WriteLine("   {0:N0} matches in {1}", matches, sw.Elapsed)

        ' Read all sentences with compiled regex.
        Console.WriteLine("All Sentences with Compiled Regex:")
        sw = Stopwatch.StartNew()
        Dim compAll As New Regex(pattern,
                       RegexOptions.SingleLine Or RegexOptions.Compiled)
        match = compAll.Match(input)
        matches = 0
        Do While match.Success
            matches += 1
            ' Do nothing with the match except get the next match.
            match = match.NextMatch()
        Loop
        sw.Stop()
        Console.WriteLine("   {0:N0} matches in {1}", matches, sw.Elapsed)
    End Sub
End Module
' The example displays output like the following:
'       10 Sentences with Interpreted Regex:
'          10 matches in 00:00:00.0047491
'       10 Sentences with Compiled Regex:
'          10 matches in 00:00:00.0141872
'       All Sentences with Interpreted Regex:
'          13,443 matches in 00:00:01.1929928
'       All Sentences with Compiled Regex:
'          13,443 matches in 00:00:00.7635869
'       
'       >compare1
'       10 Sentences with Interpreted Regex:
'          10 matches in 00:00:00.0046914
'       10 Sentences with Compiled Regex:
'          10 matches in 00:00:00.0143727
'       All Sentences with Interpreted Regex:
'          13,443 matches in 00:00:01.1514100
'       All Sentences with Compiled Regex:
'          13,443 matches in 00:00:00.7432921

örneğinde \b(\w+((\r?\n)|,?\s))*\w+[.?:;!]kullanılan normal ifade deseni aşağıdaki tabloda gösterildiği gibi tanımlanır:

Desen	Açıklama
\b	Bir sözcük sınırında eşleşmeye başla.
\w+	Bir veya daha fazla sözcük karakteriyle eşleşir.
(\r?\n)|,?\s)	Sıfır veya bir satır başı ve ardından yeni satır karakteri ya da sıfır veya bir virgül ve ardından boşluk karakteri ile eşleşir.
(\w+((\r?\n)|,?\s))*	Bir veya daha fazla sözcük karakterinin sıfır veya bir satır başı ve yeni satır karakteri ya da sıfır ya da bir virgül ve ardından boşluk karakteri gelen sıfır veya daha fazla oluşumuyla eşleşir.
\w+	Bir veya daha fazla sözcük karakteriyle eşleşir.
[.?:;!]	Nokta, soru işareti, iki nokta üst üste, noktalı virgül veya ünlem işaretiyle eşleşir.

Normal ifadeler: Derlemeye derlenmiş

.NET ayrıca derlenmiş normal ifadeler içeren bir derleme oluşturmanıza da olanak tanır. Bu özellik, normal ifade derlemesinin performans isabetini çalışma zamanından tasarım zamanına taşır. Ancak, bazı ek çalışmalar da içerir. Normal ifadeleri önceden tanımlamanız ve bunları bir derlemeye derlemeniz gerekir. Derleyici daha sonra derlemenin normal ifadelerini kullanan kaynak kodu derlerken bu derlemeye başvurabilir. Derlemedeki her derlenmiş normal ifade, öğesinden Regextüretilen bir sınıfla temsil edilir.

Normal ifadeleri bir derlemeye derlemek için yöntemini çağırır Regex.CompileToAssembly(RegexCompilationInfo[], AssemblyName) ve bir RegexCompilationInfo nesne dizisi ile AssemblyName geçirirsiniz. RegexCompilationInfo Nesneler derlenecek normal ifadeleri ve AssemblyName oluşturulacak derleme hakkında bilgi içeren nesneyi temsil eder.

Aşağıdaki durumlarda normal ifadeleri bütünleşik bir dosyaya derlemenizi öneririz:

• Yeniden kullanılabilir normal ifadeler kitaplığı oluşturmak isteyen bir bileşen geliştiricisiyseniz.
• Normal ifadenizin desen eşleştirme yöntemlerinin belirsiz sayıda çağrılmasını bekliyorsanız (bir veya iki ile binler arası veya on binlerce kez). Derlenen veya yorumlanan normal ifadelerden farklı olarak, ayrı derlemeler için derlenen normal ifadeler, yöntem çağrılarının sayısından bağımsız olarak tutarlı bir performans sunar.

Performansı iyileştirmek için derlenmiş normal ifadeler kullanıyorsanız, derlemeyi oluşturmak, normal ifade altyapısını yüklemek ve desen eşleştirme yöntemlerini yürütmek için yansıma kullanmamalısınız. Yansımayı önlemek için normal ifade desenlerini dinamik olarak oluşturmamanızı ve derleme oluşturulurken büyük/küçük harfe duyarsız desen eşleştirme gibi desen eşleştirme seçeneklerini belirtmeniz gerekir. Ayrıca derlemeyi, normal ifadeyi kullanan koddan oluşturan kodu ayırmanızı gerektirir.

Aşağıdaki örnek, derlenmiş bir normal ifade içeren bir derlemenin nasıl oluşturulacağını göstermektedir. Tek bir normal ifade sınıfı SentencePatternolan adlı RegexLib.dll bir derleme oluşturur. Bu sınıf, Yorumlanmış ve Derlenmiş Normal İfadeler bölümünde kullanılan tümce eşleşen normal ifade desenini içerir.

using System;
using System.Reflection;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      RegexCompilationInfo SentencePattern =
                           new RegexCompilationInfo(@"\b(\w+((\r?\n)|,?\s))*\w+[.?:;!]",
                                                    RegexOptions.Multiline,
                                                    "SentencePattern",
                                                    "Utilities.RegularExpressions",
                                                    true);
      RegexCompilationInfo[] regexes = { SentencePattern };
      AssemblyName assemName = new AssemblyName("RegexLib, Version=1.0.0.1001, Culture=neutral, PublicKeyToken=null");
      Regex.CompileToAssembly(regexes, assemName);
   }
}

Imports System.Reflection
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim SentencePattern As New RegexCompilationInfo("\b(\w+((\r?\n)|,?\s))*\w+[.?:;!]",
                                                        RegexOptions.Multiline,
                                                        "SentencePattern",
                                                        "Utilities.RegularExpressions",
                                                        True)
        Dim regexes() As RegexCompilationInfo = {SentencePattern}
        Dim assemName As New AssemblyName("RegexLib, Version=1.0.0.1001, Culture=neutral, PublicKeyToken=null")
        Regex.CompileToAssembly(regexes, assemName)
    End Sub
End Module

Örnek yürütülebilir bir dosyaya derlenip çalıştırıldığında adlı RegexLib.dllbir derleme oluşturur. Utilities.RegularExpressions.SentencePattern öğesinden Regex türetilen bir sınıf normal ifadeyi temsil eder. Aşağıdaki örnek daha sonra Derlenmiş normal ifadeyi kullanarak Theodore Dreiser'ın The Financier metninin tümcelerini ayıklar:

using System;
using System.IO;
using System.Text.RegularExpressions;
using Utilities.RegularExpressions;

public class Example
{
   public static void Main()
   {
      SentencePattern pattern = new SentencePattern();
      StreamReader inFile = new StreamReader(@".\Dreiser_TheFinancier.txt");
      string input = inFile.ReadToEnd();
      inFile.Close();

      MatchCollection matches = pattern.Matches(input);
      Console.WriteLine("Found {0:N0} sentences.", matches.Count);
   }
}
// The example displays the following output:
//      Found 13,443 sentences.

Imports System.IO
Imports System.Text.RegularExpressions
Imports Utilities.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As New SentencePattern()
        Dim inFile As New StreamReader(".\Dreiser_TheFinancier.txt")
        Dim input As String = inFile.ReadToEnd()
        inFile.Close()

        Dim matches As MatchCollection = pattern.Matches(input)
        Console.WriteLine("Found {0:N0} sentences.", matches.Count)
    End Sub
End Module
' The example displays the following output:
'      Found 13,443 sentences.

Geri izlemenin sorumluluğunu üstlenme

Sıradan şekilde, normal ifade motoru bir giriş dizsi içinde ilerlemek ve bunu bir normal ifade deseni ile karşılaştırmak için doğrusal ilerlemeyi kullanır. Ancak, , ve ? gibi *+belirsiz niceleyiciler normal ifade deseninde kullanıldığında, normal ifade altyapısı başarılı kısmi eşleşmelerin bir bölümünü verebilir ve desenin tamamı için başarılı bir eşleşme aramak için daha önce kaydedilmiş bir duruma geri dönebilir. Bu işlem geri dönüş olarak bilinir.

İpucu

Geri izleme hakkında daha fazla bilgi için bkz . Normal ifade davranışının ayrıntıları ve Geri İzleme. Geri izleme hakkında ayrıntılı tartışmalar için .NET 7'de Normal İfade geliştirmeleri ve Normal İfade Performansını İyileştirme blog gönderilerine bakın.

Geri dönüş için destek, normal ifadelere güç ve esneklik kazandırır. Ayrıca normal ifade motorunun çalışmasının denetlenmesini sorumluluğunu normal ifade geliştiricisine teslim eder. Geliştiriciler genelde bu sorumluluğun farkında olmadığından, geri dönüşü yanlış kullanmaları ya da aşırı geri dönüşe bağımlılıkları genelde normal ifade performansının düşmesinde önemli bir rol oynar. En kötü senaryoda yürütme süresi girdi dizesinde her ek karakter ile iki katına çıkar. Aslında, geri izlemeyi aşırı derecede kullanarak, giriş normal ifade deseni ile neredeyse eşleşiyorsa sonsuz döngünün programlı eşdeğerini oluşturmak kolaydır. Normal ifade altyapısının nispeten kısa bir giriş dizesini işlemesi saatler, hatta günler sürebilir.

Genellikle, bir eşleşme için geri izleme gerekli olmasa da uygulamalar geri izleme kullanmak için bir performans cezası öder. Örneğin, normal ifade \b\p{Lu}\w*\b , aşağıdaki tabloda gösterildiği gibi büyük harfle başlayan tüm sözcüklerle eşleşir:

Desen	Açıklama
\b	Bir sözcük sınırında eşleşmeye başla.
\p{Lu}	Büyük harf karakterle eşleşir.
\w*	Sıfır veya daha fazla sözcük karakteriyle eşleşir.
\b	Eşlemeyi bir sözcük sınırında sonlandır.

Sözcük sınırı, bir sözcük karakteriyle aynı veya bir alt kümesi olmadığından, normal ifade altyapısının sözcük karakterleri eşleştirirken sözcük sınırını aşma olasılığı yoktur. Bu nedenle bu normal ifade için geri izleme hiçbir eşleşmenin genel başarısına katkıda bulunamayacaktır. Yalnızca normal ifade altyapısı bir sözcük karakterinin her başarılı ön eşleşmesi için durumunu kaydetmeye zorlandığından performansı düşürebilir.

Geri izlemenin gerekli olmadığını belirlerseniz, bunu birkaç yolla devre dışı bırakabilirsiniz:

• seçeneğini ayarlayarak RegexOptions.NonBacktracking (.NET 7'de kullanıma sunulmuştur). Daha fazla bilgi için bkz . Geri izleme modu.

• Atomik grup olarak bilinen dil öğesini kullanarak (?>subexpression) . Aşağıdaki örnek, bir girdi dizesini iki normal ifade kullanarak ayrıştırmaktadır. İlki, \b\p{Lu}\w*\bgeri izlemeye dayanır. İkincisi, \b\p{Lu}(?>\w*)\bgeri izlemeyi devre dışı bırakır. Örnekteki çıktıda gösterildiği gibi, ikisi de aynı sonucu üretir:

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string input = "This this word Sentence name Capital";
        string pattern = @"\b\p{Lu}\w*\b";
        foreach (Match match in Regex.Matches(input, pattern))
           Console.WriteLine(match.Value);
  
        Console.WriteLine();
  
        pattern = @"\b\p{Lu}(?>\w*)\b";
        foreach (Match match in Regex.Matches(input, pattern))
           Console.WriteLine(match.Value);
     }
  }
  // The example displays the following output:
  //       This
  //       Sentence
  //       Capital
  //
  //       This
  //       Sentence
  //       Capital
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim input As String = "This this word Sentence name Capital"
          Dim pattern As String = "\b\p{Lu}\w*\b"
          For Each match As Match In Regex.Matches(input, pattern)
              Console.WriteLine(match.Value)
          Next
          Console.WriteLine()
  
          pattern = "\b\p{Lu}(?>\w*)\b"
          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
  '       Sentence
  '       Capital
  '       
  '       This
  '       Sentence
  '       Capital
  

Birçok durumda, geri izleme bir normal ifade desenini giriş metnine eşlemek için gereklidir. Ancak aşırı geri izleme performansı ciddi şekilde azaltabilir ve uygulamanın yanıt vermediği izlenimine yol açabilir. Özellikle bu sorun, niceleyiciler iç içe yerleştirildiğinde ve dış alt ifadeyle eşleşen metin, iç alt ifadeyle eşleşen metnin bir alt kümesi olduğunda ortaya çıkar.

Uyarı

Aşırı geri izlemeden kaçınmanın yanı sıra, aşırı geri izlemenin normal ifade performansını ciddi ölçüde düşürmediğinden emin olmak için zaman aşımı özelliğini kullanmanız gerekir. Daha fazla bilgi için Zaman aşımı değerlerini kullanma bölümüne bakın.

Örneğin, normal ifade deseni ^[0-9A-Z]([-.\w]*[0-9A-Z])*\$$ en az bir alfasayısal karakterden oluşan bir parça numarasıyla eşleşmeye yöneliktir. Bir ek karakter bir alfasayısal karakter, bir ayırma çizgisi, bir alt çizgi ya da bir nokta olabilir, ancak son karakter alfasayısal olmalıdır. Bir dolar işareti parça numarasını sonlandırır. Bazı durumlarda, nicelleyiciler iç içe yerleştirildiğinden ve alt ifade [0-9A-Z] alt ifadenin bir alt kümesi olduğundan bu normal ifade deseni [-.\w]*düşük performans sergileyebilir.

Bu durumlarda, yuvalanan miktar niceleyicileri kaldırarak ve dış alt ifadeyi sıfır genişliğinde bir ileriye dönük ya da geriye dönük onay ile değiştirerek normal ifade performansını en iyi hale getireceksiniz. Lookahead ve lookbehind onayları yer işaretidir. Bunlar, işaretçiyi giriş dizesinde taşımaz, ancak belirtilen koşulun karşılanıp karşılanmadığını denetlemek için ileriye veya arkaya bakar. Örneğin, normal parça numarası ifadesi olarak ^[0-9A-Z][-.\w]*(?<=[0-9A-Z])\$$yeniden yazılabilir. Bu normal ifade düzeni aşağıdaki tabloda gösterildiği gibi tanımlanır:

Desen	Açıklama
^	Giriş dizesinin başında eşleşmeye başla.
[0-9A-Z]	Alfasayısal bir karakterle eşleştirin Parça numarası en azından bu karakteri içermelidir.
[-.\w]*	Herhangi bir sözcük karakteri, kesme ya da noktanın sıfır ya da daha fazla oluşumunu eşleyin.
\$	Bir dolar işareti eşleyin.
(?<=[0-9A-Z])	Önceki karakterin alfasayısal olduğundan emin olmak için bitiş doları işaretinin arkasına bakın.
$	Giriş dizesinin sonunda eşleşmeyi bitir.

Aşağıdaki örnekte, bu normal ifadenin olası parça numaraları içeren bir diziyle eşleşecek şekilde kullanılması gösterilmektedir:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^[0-9A-Z][-.\w]*(?<=[0-9A-Z])\$$";
      string[] partNos = { "A1C$", "A4", "A4$", "A1603D$", "A1603D#" };

      foreach (var input in partNos) {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
         else
            Console.WriteLine("Match not found.");
      }
   }
}
// The example displays the following output:
//       A1C$
//       Match not found.
//       A4$
//       A1603D$
//       Match not found.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^[0-9A-Z][-.\w]*(?<=[0-9A-Z])\$$"
        Dim partNos() As String = {"A1C$", "A4", "A4$", "A1603D$",
                                    "A1603D#"}

        For Each input As String In partNos
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then
                Console.WriteLine(match.Value)
            Else
                Console.WriteLine("Match not found.")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       A1C$
'       Match not found.
'       A4$
'       A1603D$
'       Match not found.

.NET'teki normal ifade dili, iç içe niceleyicileri ortadan kaldırmak için kullanabileceğiniz aşağıdaki dil öğelerini içerir. Daha fazla bilgi için bkz . Yapıları gruplandırma.

Dil öğesi	Açıklama
(?= subexpression )	Sıfır genişlikli pozitif ileriye yönelik onay. Giriş dizesiyle eşleşip eşleşmediğini subexpression belirlemek için geçerli konumun önüne bakar.
(?! subexpression )	Sıfır genişlikli negatif ileriye yönelik onay. Giriş dizesiyle eşleşmediğini subexpression belirlemek için geçerli konumun önüne bakar.
(?<= subexpression )	Sıfır genişlikli pozitif geriye yönelik onay. Giriş dizesiyle eşleşip eşleşmediğini subexpression belirlemek için geçerli konumun arkasına bakar.
(?<! subexpression )	Sıfır genişlikli negatif geriye yönelik onay. Giriş dizesiyle eşleşmediğini subexpression belirlemek için geçerli konumun arkasına bakar.

Zaman aşımı değerlerini kullanma

Normal ifadeleriniz, normal ifade deseniyle neredeyse eşleşen girişleri işleme alıyorsa, sıkça aşırı geri izlemeye dayanıyor olabilir, bu da performansı önemli ölçüde etkiler. Geri izleme kullanımınızı ve normal ifadeyi yakın eşleşen girişe karşı test etmeyi dikkatle düşünmenin yanı sıra, aşırı geri izlemenin etkisini en aza indirmek için her zaman bir zaman aşımı değeri ayarlamanız gerekir.

Normal ifade zaman aşımı aralığı, normal ifade altyapısının zaman aşımına uğramadan önce tek bir eşleşme arayacağı süreyi tanımlar. Normal ifade düzenine ve giriş metnine bağlı olarak, yürütme süresi belirtilen zaman aşımı aralığını aşabilir, ancak belirtilen zaman aşımı aralığından daha fazla geri izleme harcamaz. Varsayılan zaman aşımı aralığı olur Regex.InfiniteMatchTimeout. Bu, normal ifadenin zaman aşımına olmayacağı anlamına gelir. Bu değeri geçersiz kılabilir ve aşağıdaki gibi bir zaman aşımı aralığı tanımlayabilirsiniz:

• Bir nesne örneği Regex(String, RegexOptions, TimeSpan) oluştururken Regex zaman aşımı değeri sağlamak için oluşturucuyu çağırın.

• Veya gibi Regex.Match(String, String, RegexOptions, TimeSpan)Regex.Replace(String, String, String, RegexOptions, TimeSpan)bir parametre içeren matchTimeout statik desen eşleştirme yöntemini çağır.

• yöntemi çağrılarak oluşturulan derlenmiş normal ifadeler için tür TimeSpan parametresine sahip oluşturucuyu çağırın Regex.CompileToAssembly .

• gibi AppDomain.CurrentDomain.SetData("REGEX_DEFAULT_MATCH_TIMEOUT", TimeSpan.FromMilliseconds(100));bir kodla işlem genelinde veya AppDomain genelinde bir değer ayarlayın.

Zaman aşımı aralığı tanımladıysanız ve bu aralığın sonunda eşleşme bulunmazsa, normal ifade yöntemi bir RegexMatchTimeoutException özel durum oluşturur. Özel durum işleyicinizde, eşleşmeyi daha uzun bir zaman aşımı aralığıyla yeniden denemeyi, eşleşme denemesini bırakmayı ve eşleşme olmadığını varsaymayı veya eşleştirme denemesini bırakıp gelecekteki analiz için özel durum bilgilerini günlüğe kaydetmeyi seçebilirsiniz.

Aşağıdaki örnek, bir metin belgesindeki bir GetWordData sözcüğün sözcük sayısını ve ortalama karakter sayısını hesaplamak için 350 milisaniyelik zaman aşımı aralığıyla normal ifade örneği oluşturan bir yöntemi tanımlar. Eşleşen işlem zaman aşımına uğrıyorsa zaman aşımı aralığı 350 milisaniye artırılır ve Regex nesne yeniden oluşturulur. Yeni zaman aşımı aralığı bir saniyeyi aşarsa, yöntemi çağıranın özel durumunu yeniden oluşturur.

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

public class Example
{
   public static void Main()
   {
      RegexUtilities util = new RegexUtilities();
      string title = "Doyle - The Hound of the Baskervilles.txt";
      try {
         var info = util.GetWordData(title);
         Console.WriteLine("Words:               {0:N0}", info.Item1);
         Console.WriteLine("Average Word Length: {0:N2} characters", info.Item2);
      }
      catch (IOException e) {
         Console.WriteLine("IOException reading file '{0}'", title);
         Console.WriteLine(e.Message);
      }
      catch (RegexMatchTimeoutException e) {
         Console.WriteLine("The operation timed out after {0:N0} milliseconds",
                           e.MatchTimeout.TotalMilliseconds);
      }
   }
}

public class RegexUtilities
{
   public Tuple<int, double> GetWordData(string filename)
   {
      const int MAX_TIMEOUT = 1000;   // Maximum timeout interval in milliseconds.
      const int INCREMENT = 350;      // Milliseconds increment of timeout.

      List<string> exclusions = new List<string>( new string[] { "a", "an", "the" });
      int[] wordLengths = new int[29];        // Allocate an array of more than ample size.
      string input = null;
      StreamReader sr = null;
      try {
         sr = new StreamReader(filename);
         input = sr.ReadToEnd();
      }
      catch (FileNotFoundException e) {
         string msg = String.Format("Unable to find the file '{0}'", filename);
         throw new IOException(msg, e);
      }
      catch (IOException e) {
         throw new IOException(e.Message, e);
      }
      finally {
         if (sr != null) sr.Close();
      }

      int timeoutInterval = INCREMENT;
      bool init = false;
      Regex rgx = null;
      Match m = null;
      int indexPos = 0;
      do {
         try {
            if (! init) {
               rgx = new Regex(@"\b\w+\b", RegexOptions.None,
                               TimeSpan.FromMilliseconds(timeoutInterval));
               m = rgx.Match(input, indexPos);
               init = true;
            }
            else {
               m = m.NextMatch();
            }
            if (m.Success) {
               if ( !exclusions.Contains(m.Value.ToLower()))
                  wordLengths[m.Value.Length]++;

               indexPos += m.Length + 1;
            }
         }
         catch (RegexMatchTimeoutException e) {
            if (e.MatchTimeout.TotalMilliseconds < MAX_TIMEOUT) {
               timeoutInterval += INCREMENT;
               init = false;
            }
            else {
               // Rethrow the exception.
               throw;
            }
         }
      } while (m.Success);

      // If regex completed successfully, calculate number of words and average length.
      int nWords = 0;
      long totalLength = 0;

      for (int ctr = wordLengths.GetLowerBound(0); ctr <= wordLengths.GetUpperBound(0); ctr++) {
         nWords += wordLengths[ctr];
         totalLength += ctr * wordLengths[ctr];
      }
      return new Tuple<int, double>(nWords, totalLength/nWords);
   }
}

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

Module Example
    Public Sub Main()
        Dim util As New RegexUtilities()
        Dim title As String = "Doyle - The Hound of the Baskervilles.txt"
        Try
            Dim info = util.GetWordData(title)
            Console.WriteLine("Words:               {0:N0}", info.Item1)
            Console.WriteLine("Average Word Length: {0:N2} characters", info.Item2)
        Catch e As IOException
            Console.WriteLine("IOException reading file '{0}'", title)
            Console.WriteLine(e.Message)
        Catch e As RegexMatchTimeoutException
            Console.WriteLine("The operation timed out after {0:N0} milliseconds",
                              e.MatchTimeout.TotalMilliseconds)
        End Try
    End Sub
End Module

Public Class RegexUtilities
    Public Function GetWordData(filename As String) As Tuple(Of Integer, Double)
        Const MAX_TIMEOUT As Integer = 1000  ' Maximum timeout interval in milliseconds.
        Const INCREMENT As Integer = 350     ' Milliseconds increment of timeout.

        Dim exclusions As New List(Of String)({"a", "an", "the"})
        Dim wordLengths(30) As Integer        ' Allocate an array of more than ample size.
        Dim input As String = Nothing
        Dim sr As StreamReader = Nothing
        Try
            sr = New StreamReader(filename)
            input = sr.ReadToEnd()
        Catch e As FileNotFoundException
            Dim msg As String = String.Format("Unable to find the file '{0}'", filename)
            Throw New IOException(msg, e)
        Catch e As IOException
            Throw New IOException(e.Message, e)
        Finally
            If sr IsNot Nothing Then sr.Close()
        End Try

        Dim timeoutInterval As Integer = INCREMENT
        Dim init As Boolean = False
        Dim rgx As Regex = Nothing
        Dim m As Match = Nothing
        Dim indexPos As Integer = 0
        Do
            Try
                If Not init Then
                    rgx = New Regex("\b\w+\b", RegexOptions.None,
                                    TimeSpan.FromMilliseconds(timeoutInterval))
                    m = rgx.Match(input, indexPos)
                    init = True
                Else
                    m = m.NextMatch()
                End If
                If m.Success Then
                    If Not exclusions.Contains(m.Value.ToLower()) Then
                        wordLengths(m.Value.Length) += 1
                    End If
                    indexPos += m.Length + 1
                End If
            Catch e As RegexMatchTimeoutException
                If e.MatchTimeout.TotalMilliseconds < MAX_TIMEOUT Then
                    timeoutInterval += INCREMENT
                    init = False
                Else
                    ' Rethrow the exception.
                    Throw
                End If
            End Try
        Loop While m.Success

        ' If regex completed successfully, calculate number of words and average length.
        Dim nWords As Integer
        Dim totalLength As Long

        For ctr As Integer = wordLengths.GetLowerBound(0) To wordLengths.GetUpperBound(0)
            nWords += wordLengths(ctr)
            totalLength += ctr * wordLengths(ctr)
        Next
        Return New Tuple(Of Integer, Double)(nWords, totalLength / nWords)
    End Function
End Class

Yalnızca gerektiğinde yakala

.NET'teki normal ifadeler, normal ifade desenini bir veya daha fazla alt ifadede gruplandırmanıza olanak tanıyan gruplandırma yapılarını destekler. .NET normal ifade dilinde (en yaygın kullanılan gruplandırma yapıları, numaralandırılmış bir yakalama grubunu tanımlayan alt) ifade ve(?< adlandırılmış bir yakalama grubunu tanımlayan ad>alt) ifadesidir. Yapı birimlerini gruplamak geri başvuruları oluşturmak ve bir miktar niceleyicinin uygulandığı bir alt ifade tanımlamak için gereklidir.

Ancak bu dil öğelerinin kullanılmasının bir maliyeti vardır. Özelliği tarafından döndürülen nesnenin GroupCollectionMatch.Groups en son adlandırılmamış veya adlandırılmış yakalamalarla doldurulmasına neden olurlar. Tek bir gruplandırma yapısı giriş dizesinde birden çok alt dize yakalamışsa, belirli bir yakalama grubunun özelliği tarafından Group.Captures döndürülen nesneyi de birden çok Capture nesneyle doldururCaptureCollection.

Gruplandırma yapıları genellikle yalnızca normal ifadede kullanılır, böylece niceleyiciler bunlara uygulanabilir. Bu alt ifadeler tarafından yakalanan gruplar daha sonra kullanılmaz. Örneğin, normal ifade \b(\w+[;,]?\s?)+[.?!] tümceyi yakalamak için tasarlanmıştır. Aşağıdaki tabloda, bu normal ifade desenindeki dil öğeleri ve bunların nesnenin MatchMatch.Groups ve Group.Captures koleksiyonları üzerindeki etkisi açıklanmaktadır:

Desen	Açıklama
\b	Bir sözcük sınırında eşleşmeye başla.
\w+	Bir veya daha fazla sözcük karakteriyle eşleşir.
[;,]?	Sıfır veya bir virgül veya noktalı virgülle eşleşir.
\s?	Sıfır veya bir boşluk karakteriyle eşleşir.
(\w+[;,]?\s?)+	Bir veya daha fazla sözcük karakterinin bir veya daha fazla tekrarını, ardından isteğe bağlı virgül veya noktalı virgül ve ardından isteğe bağlı boşluk karakteriyle eşleşir. Bu desen, birden çok sözcük karakterinin (başka bir deyişle, bir sözcük) ve ardından isteğe bağlı bir noktalama simgesinin birleşiminin normal ifade altyapısı cümlenin sonuna ulaşana kadar yinelenmesi için gerekli olan ilk yakalama grubunu tanımlar.
[.?!]	Nokta, soru işareti veya ünlem işaretiyle eşleşir.

Aşağıdaki örnekte gösterildiği gibi, bir eşleşme bulunduğunda GroupCollection hem hem de CaptureCollection nesneleri eşleşmeden alınan yakalamalarla doldurulur. Bu durumda, niceleyicinin + uygulanabilmesi için yakalama grubu (\w+[;,]?\s?) vardır ve bu da normal ifade deseninin tümcedeki her sözcükle eşleşmesini sağlar. Aksi halde bir cümledeki son sözcüğü eşleyebilir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is one sentence. This is another.";
      string pattern = @"\b(\w+[;,]?\s?)+[.?!]";

      foreach (Match match in Regex.Matches(input, pattern)) {
         Console.WriteLine("Match: '{0}' at index {1}.",
                           match.Value, match.Index);
         int grpCtr = 0;
         foreach (Group grp in match.Groups) {
            Console.WriteLine("   Group {0}: '{1}' at index {2}.",
                              grpCtr, grp.Value, grp.Index);
            int capCtr = 0;
            foreach (Capture cap in grp.Captures) {
               Console.WriteLine("      Capture {0}: '{1}' at {2}.",
                                 capCtr, cap.Value, cap.Index);
               capCtr++;
            }
            grpCtr++;
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       Match: 'This is one sentence.' at index 0.
//          Group 0: 'This is one sentence.' at index 0.
//             Capture 0: 'This is one sentence.' at 0.
//          Group 1: 'sentence' at index 12.
//             Capture 0: 'This ' at 0.
//             Capture 1: 'is ' at 5.
//             Capture 2: 'one ' at 8.
//             Capture 3: 'sentence' at 12.
//
//       Match: 'This is another.' at index 22.
//          Group 0: 'This is another.' at index 22.
//             Capture 0: 'This is another.' at 22.
//          Group 1: 'another' at index 30.
//             Capture 0: 'This ' at 22.
//             Capture 1: 'is ' at 27.
//             Capture 2: 'another' at 30.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "This is one sentence. This is another."
        Dim pattern As String = "\b(\w+[;,]?\s?)+[.?!]"

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Match: '{0}' at index {1}.",
                              match.Value, match.Index)
            Dim grpCtr As Integer = 0
            For Each grp As Group In match.Groups
                Console.WriteLine("   Group {0}: '{1}' at index {2}.",
                                  grpCtr, grp.Value, grp.Index)
                Dim capCtr As Integer = 0
                For Each cap As Capture In grp.Captures
                    Console.WriteLine("      Capture {0}: '{1}' at {2}.",
                                      capCtr, cap.Value, cap.Index)
                    capCtr += 1
                Next
                grpCtr += 1
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       Match: 'This is one sentence.' at index 0.
'          Group 0: 'This is one sentence.' at index 0.
'             Capture 0: 'This is one sentence.' at 0.
'          Group 1: 'sentence' at index 12.
'             Capture 0: 'This ' at 0.
'             Capture 1: 'is ' at 5.
'             Capture 2: 'one ' at 8.
'             Capture 3: 'sentence' at 12.
'       
'       Match: 'This is another.' at index 22.
'          Group 0: 'This is another.' at index 22.
'             Capture 0: 'This is another.' at 22.
'          Group 1: 'another' at index 30.
'             Capture 0: 'This ' at 22.
'             Capture 1: 'is ' at 27.
'             Capture 2: 'another' at 30.

Alt ifadeleri yalnızca niceleyicileri bunlara uygulamak için kullandığınızda ve yakalanan metinle ilgilenmediğinizde, grup yakalamalarını devre dışı bırakmanız gerekir. Örneğin, (?:subexpression) dil öğesi, uygulandığı grubun eşleşen alt dizeleri yakalamasını engeller. Aşağıdaki örnekte, önceki örnekteki normal ifade deseni olarak \b(?:\w+[;,]?\s?)+[.?!]değiştirilmiştir. Çıktıda gösterildiği gibi, normal ifade altyapısının ve CaptureCollection koleksiyonlarını doldurmasını GroupCollection engeller:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is one sentence. This is another.";
      string pattern = @"\b(?:\w+[;,]?\s?)+[.?!]";

      foreach (Match match in Regex.Matches(input, pattern)) {
         Console.WriteLine("Match: '{0}' at index {1}.",
                           match.Value, match.Index);
         int grpCtr = 0;
         foreach (Group grp in match.Groups) {
            Console.WriteLine("   Group {0}: '{1}' at index {2}.",
                              grpCtr, grp.Value, grp.Index);
            int capCtr = 0;
            foreach (Capture cap in grp.Captures) {
               Console.WriteLine("      Capture {0}: '{1}' at {2}.",
                                 capCtr, cap.Value, cap.Index);
               capCtr++;
            }
            grpCtr++;
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       Match: 'This is one sentence.' at index 0.
//          Group 0: 'This is one sentence.' at index 0.
//             Capture 0: 'This is one sentence.' at 0.
//
//       Match: 'This is another.' at index 22.
//          Group 0: 'This is another.' at index 22.
//             Capture 0: 'This is another.' at 22.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "This is one sentence. This is another."
        Dim pattern As String = "\b(?:\w+[;,]?\s?)+[.?!]"

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Match: '{0}' at index {1}.",
                              match.Value, match.Index)
            Dim grpCtr As Integer = 0
            For Each grp As Group In match.Groups
                Console.WriteLine("   Group {0}: '{1}' at index {2}.",
                                  grpCtr, grp.Value, grp.Index)
                Dim capCtr As Integer = 0
                For Each cap As Capture In grp.Captures
                    Console.WriteLine("      Capture {0}: '{1}' at {2}.",
                                      capCtr, cap.Value, cap.Index)
                    capCtr += 1
                Next
                grpCtr += 1
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       Match: 'This is one sentence.' at index 0.
'          Group 0: 'This is one sentence.' at index 0.
'             Capture 0: 'This is one sentence.' at 0.
'       
'       Match: 'This is another.' at index 22.
'          Group 0: 'This is another.' at index 22.
'             Capture 0: 'This is another.' at 22.

Tutmayı, şu yöntemlerden biriyle devre dışı bırakabilirsiniz:

• (?:subexpression) Dil öğesini kullanın. Bu öğe, geçerli olduğu gruptaki eşleşen alt dizelerin tutulmasını engeller. İç içe gruplardaki alt dize yakalamalarını devre dışı bırakmaz.

• ExplicitCapture seçeneğini kullanın. Normal ifade deseninde tüm adlandırılmamış ya da örtük yakalamaları devre dışı bırakır. Bu seçeneği kullandığınızda, yalnızca dil öğesiyle tanımlanan adlandırılmış gruplarla (?<name>subexpression) eşleşen alt dizeler yakalanabilir. bayrağı, ExplicitCapture bir Regex sınıf oluşturucusunun options parametresine veya statik eşleştirme yönteminin parametresine optionsRegex geçirilebilir.

• n dil öğesinde (?imnsx) seçeneğini kullanın. Bu seçenek, tutulan tüm adlandırılmamış veya örtük öğeleri, öğenin normal ifade deseninde ortaya çıktığı noktadan başlayarak devre dışı bırakır. Yakalamalar, desenin sonuna kadar veya seçenek adsız veya örtük yakalamaları etkinleştirene kadar (-n) devre dışı bırakılır. Daha fazla bilgi için bkz . Çeşitli Yapılar.

• n dil öğesinde (?imnsx:subexpression) seçeneğini kullanın. Bu seçenek içindeki subexpressiontüm adsız veya örtük yakalamaları devre dışı bırakır. Yakalamalar adlandırılmamış ya da örtük yuvalı yakalama grupları tarafından devre dışı bırakılır.

İlgili makaleler

Ünvan	Açıklama
Normal İfade Davranışının Ayrıntıları	.NET'te normal ifade altyapısının uygulanmasını inceler. Makale, normal ifadelerin esnekliğine odaklanır ve geliştiricinin normal ifade altyapısının verimli ve sağlam çalışmasını sağlama sorumluluğunu açıklar.
Geri Dönüş	Geri izlemenin ne olduğunu ve bunun normal ifade performansını nasıl etkilediği açıklar ve geri izlemeye alternatifler sağlayan dil öğelerini inceler.
Normal İfade Dili - Hızlı Başvuru	.NET'te normal ifade dilinin öğelerini açıklar ve her dil öğesi için ayrıntılı belgelere bağlantılar sağlar.