RegexCompilationInfo.MatchTimeout Vlastnost

  • Reference

Definice

Obor názvů:
System.Text.RegularExpressions
Sestavení:
System.Text.RegularExpressions.dll
Sestavení:
System.dll
Source:
RegexCompilationInfo.cs
Source:
RegexCompilationInfo.cs
Source:
RegexCompilationInfo.cs

Získá nebo nastaví výchozí interval časového limitu regulárního výrazu.

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

Hodnota vlastnosti

TimeSpan

Výchozí maximální časový interval, který může uplynout v operaci porovnávání vzorů před vyvolání objektu RegexMatchTimeoutException nebo InfiniteMatchTimeout před zakázáním časového limitu.

Příklady

Následující příklad definuje jeden kompilovaný regulární výraz s názvem DuplicateChars , který identifikuje dva nebo více výskytů stejného znaku ve vstupním řetězci. Zkompilovaný regulární výraz má výchozí časový limit 2 sekundy. Při spuštění příkladu se vytvoří knihovna tříd s názvem RegexLib.dll, která obsahuje zkompilovaný regulární výraz.

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

Vzor (\w)\1+ regulárního výrazu je definovaný tak, jak je znázorněno v následující tabulce.

Vzor Description
(\w) Porovná libovolný znak slova a přiřadí ho první zachycené skupině.
\1+ Porovná jeden nebo více výskytů hodnoty první zachycené skupiny.

Následující příklad používá DuplicatedChars regulární výraz k identifikaci duplicitních znaků v řetězcovém poli. Při volání konstruktoru DuplicatedChars změní časový limit na 0,5 sekundy.

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

Poznámky

Vlastnost MatchTimeout definuje výchozí interval časového limitu pro zkompilovaný regulární výraz. Tato hodnota představuje přibližnou dobu, po kterou kompilovaný regulární výraz provede jednu odpovídající operaci před vypršením časového limitu operace a modul regulárních výrazů RegexMatchTimeoutException vyvolá výjimku při další kontrole časování.

Důležité

Doporučujeme vždy nastavit výchozí hodnotu časového limitu pro zkompilovaný regulární výraz. Příjemci knihovny regulárních výrazů mohou přepsat hodnotu časového limitu předáním TimeSpan hodnoty, která představuje nový interval časového limitu do konstruktoru třídy kompilovaného regulárního výrazu.

Výchozí hodnotu časového limitu můžete objektu RegexCompilationInfo přiřadit některým z následujících způsobů:

Pokud chcete nastavit přiměřený interval časového limitu, zvažte následující faktory:

  • Délka a složitost vzoru regulárního výrazu. Delší a složitější regulární výrazy vyžadují více času než kratší a jednodušší výrazy.

  • Očekávané zatížení počítače. Zpracování trvá déle v systémech s vysokým využitím procesoru a paměti.

Platí pro

Viz také