RegexCompilationInfo.MatchTimeout Özellik

Tanım

Ad Alanı:

System.Text.RegularExpressions

Bütünleştirilmiş Kod:

System.Text.RegularExpressions.dll

Kaynak:

RegexCompilationInfo.cs

Normal ifadenin varsayılan zaman aşımı aralığını alır veya ayarlar.

public:
 property TimeSpan MatchTimeout { TimeSpan get(); void set(TimeSpan value); };

public TimeSpan MatchTimeout { get; set; }

member this.MatchTimeout : TimeSpan with get, set

Public Property MatchTimeout As TimeSpan

Özellik Değeri

TimeSpan

Bir desen eşleştirme işleminde bir oluşturmadan InfiniteMatchTimeout önce veya zaman aşımları devre dışı bırakılmadan önce RegexMatchTimeoutException geçen varsayılan en uzun zaman aralığıdır.

Örnekler

Aşağıdaki örnek, bir giriş dizesinde aynı karakterin iki veya daha fazla örneğini tanımlayan adlı DuplicateChars tek bir derlenmiş normal ifadeyi tanımlar. Derlenen normal ifadenin varsayılan zaman aşımı süresi 2 saniyedir. Örneği yürütürken, derlenmiş normal ifadeyi içeren RegexLib.dll adlı bir sınıf kitaplığı oluşturur.

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

public class Example
{
   public static void Main()
   {
        // Match two or more occurrences of the same character.
        string pattern = @"(\w)\1+";
        
        // Use case-insensitive matching. 
        var rci = new RegexCompilationInfo(pattern, RegexOptions.IgnoreCase,
                                           "DuplicateChars", "CustomRegexes", 
                                           true, TimeSpan.FromSeconds(2));

        // Define an assembly to contain the compiled regular expression.
        var an = new AssemblyName();
        an.Name = "RegexLib";
        RegexCompilationInfo[] rciList = { rci };

        // Compile the regular expression and create the assembly.
        Regex.CompileToAssembly(rciList, an);
   }
}

Imports System.Reflection
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
        ' Match two or more occurrences of the same character.
        Dim pattern As String = "(\w)\1+"
        
        ' Use case-insensitive matching. 
        Dim rci As New RegexCompilationInfo(pattern, RegexOptions.IgnoreCase,
                                            "DuplicateChars", "CustomRegexes", 
                                            True, TimeSpan.FromSeconds(2))

        ' Define an assembly to contain the compiled regular expression.
        Dim an As New AssemblyName()
        an.Name = "RegexLib"
        Dim rciList As RegexCompilationInfo() = New RegexCompilationInfo() { rci }

        ' Compile the regular expression and create the assembly.
        Regex.CompileToAssembly(rciList, an)
   End Sub
End Module

Normal ifade deseni (\w)\1+ aşağıdaki tabloda gösterildiği gibi tanımlanır.

Desen	Description
(\w)	Herhangi bir sözcük karakterini eşleştirin ve ilk yakalama grubuna atayın.
\1+	Yakalanan ilk grubun değerinin bir veya daha fazla örneğini eşleştirin.

Aşağıdaki örnek, bir dize dizisindeki DuplicatedChars yinelenen karakterleri tanımlamak için normal ifadeyi kullanır. Oluşturucuyu DuplicatedChars çağırdığında zaman aşımı aralığını 0,5 saniye olarak değiştirir.

using CustomRegexes;
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      var rgx = new DuplicateChars(TimeSpan.FromSeconds(.5));
      
      string[] values = { "Greeeeeat", "seed", "deed", "beam", 
                          "loop", "Aardvark" };
      // Display regex information.
      Console.WriteLine("Regular Expression Pattern: {0}", rgx);
      Console.WriteLine("Regex timeout value: {0} seconds\n", 
                        rgx.MatchTimeout.TotalSeconds);
      
      // Display matching information.
      foreach (var value in values) {
         Match m = rgx.Match(value);
         if (m.Success)
            Console.WriteLine("'{0}' found in '{1}' at positions {2}-{3}",
                              m.Value, value, m.Index, m.Index + m.Length - 1);
         else
            Console.WriteLine("No match found in '{0}'", value);
      }                                                         
   }
}
// The example displays the following output:
//       Regular Expression Pattern: (\w)\1+
//       Regex timeout value: 0.5 seconds
//       
//       //eeeee// found in //Greeeeeat// at positions 2-6
//       //ee// found in //seed// at positions 1-2
//       //ee// found in //deed// at positions 1-2
//       No match found in //beam//
//       //oo// found in //loop// at positions 1-2
//       //Aa// found in //Aardvark// at positions 0-1

Imports CustomRegexes
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim rgx As New DuplicateChars(TimeSpan.FromSeconds(.5))
      
      Dim values() As String = { "Greeeeeat", "seed", "deed", "beam", 
                                 "loop", "Aardvark" }
      ' Display regex information.
      Console.WriteLine("Regular Expression Pattern: {0}", rgx)
      Console.WriteLine("Regex timeout value: {0} seconds", 
                        rgx.MatchTimeout.TotalSeconds)
      Console.WriteLine()
      
      ' Display matching information.
      For Each value In values
         Dim m As Match = rgx.Match(value)
         If m.Success Then
            Console.WriteLine("'{0}' found in '{1}' at positions {2}-{3}",
                              m.Value, value, m.Index, m.Index + m.Length - 1)
         Else
            Console.WriteLine("No match found in '{0}'", value)
         End If   
      Next                                                         
   End Sub
End Module
' The example displays the following output:
'       Regular Expression Pattern: (\w)\1+
'       Regex timeout value: 0.5 seconds
'       
'       'eeeee' found in 'Greeeeeat' at positions 2-6
'       'ee' found in 'seed' at positions 1-2
'       'ee' found in 'deed' at positions 1-2
'       No match found in 'beam'
'       'oo' found in 'loop' at positions 1-2
'       'Aa' found in 'Aardvark' at positions 0-1

Açıklamalar

özelliği, MatchTimeout derlenen normal ifade için varsayılan zaman aşımı aralığını tanımlar. Bu değer, derlenmiş bir normal ifadenin işlem zaman aşımına uğramadan ve normal ifade altyapısı bir sonraki zamanlama denetimi sırasında özel durum oluşturmadan önce tek bir RegexMatchTimeoutException eşleştirme işlemi yürütmesi için gereken yaklaşık süreyi temsil eder.

Önemli

Derlenmiş normal ifade için her zaman varsayılan bir zaman aşımı değeri ayarlamanızı öneririz. Normal ifade kitaplığınızın tüketicileri, derlenen normal ifadenin sınıf oluşturucusunun yeni zaman aşımı aralığını temsil eden bir TimeSpan değer geçirerek bu zaman aşımı değerini geçersiz kılabilir.

Aşağıdaki yollardan herhangi birini kullanarak bir RegexCompilationInfo nesneye varsayılan bir zaman aşımı değeri atayabilirsiniz:

• yöntemini çağırarak AppDomain.SetData ve "REGEX_DEFAULT_MATCH_TIMEOUT" özelliği için bir TimeSpan değerin dize gösterimini sağlayarak.

• Oluşturucuyu RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan) çağırarak ve parametresi için matchTimeout bir değer sağlayarak.

• Bu özelliğin değerini ayarlayarak.

Makul bir zaman aşımı aralığı ayarlamak için aşağıdaki faktörleri göz önünde bulundurun:

• Normal ifade deseninin uzunluğu ve karmaşıklığı. Daha uzun ve daha karmaşık normal ifadeler, daha kısa ve basit ifadelerden daha fazla zaman gerektirir.

• Beklenen makine yükü. İşleme, yüksek CPU ve bellek kullanımına sahip sistemlerde daha fazla zaman alır.

Ayrıca bkz.

• RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan)