RegexCompilationInfo.MatchTimeout Eigenschap

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

Waarde van eigenschap

Het standaard maximale tijdsinterval dat kan worden verstreken in een patroonvergelijkingsbewerking voordat een RegexMatchTimeoutException bewerking wordt gegenereerd, of InfiniteMatchTimeout als time-outs zijn uitgeschakeld.

Voorbeelden

In het volgende voorbeeld wordt één gecompileerde reguliere expressie gedefinieerd die DuplicateChars twee of meer exemplaren van hetzelfde teken in een invoertekenreeks identificeert. De gecompileerde reguliere expressie heeft een standaardtime-out van 2 seconden. Wanneer u het voorbeeld uitvoert, wordt er een klassebibliotheek gemaakt met de naam RegexLib.dll die de gecompileerde reguliere expressie bevat.

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

Het reguliere expressiepatroon (\w)\1+ wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

In het volgende voorbeeld wordt de DuplicatedChars reguliere expressie gebruikt om dubbele tekens in een tekenreeksmatrix te identificeren. Wanneer de DuplicatedChars constructor wordt aanroepen, wordt het time-outinterval gewijzigd in 0,5 seconden.

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

Opmerkingen

De MatchTimeout eigenschap definieert het standaardtime-outinterval voor de gecompileerde reguliere expressie. Deze waarde vertegenwoordigt de geschatte hoeveelheid tijd die door een gecompileerde reguliere expressie één overeenkomende bewerking wordt uitgevoerd voordat er een time-out optreedt en de reguliere expressie-engine een RegexMatchTimeoutException uitzondering genereert tijdens de volgende tijdscontrole.

U kunt op een van de volgende manieren een standaardtime-outwaarde toewijzen aan een RegexCompilationInfo object:

• Door de methode aan AppDomain.SetData te roepen en de tekenreeksweergave van een TimeSpan waarde voor de eigenschap 'REGEX_DEFAULT_MATCH_TIMEOUT' op te geven.

• Door de RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan) constructor aan te roepen en een waarde op te geven voor de matchTimeout parameter.

• Door de waarde van deze eigenschap in te stellen.

Als u een redelijk time-outinterval wilt instellen, moet u rekening houden met de volgende factoren:

• De lengte en complexiteit van het reguliere expressiepatroon. Langere en complexere reguliere expressies vereisen meer tijd dan kortere en eenvoudigere expressies.

• De verwachte computerbelasting. Verwerking kost meer tijd op systemen met een hoog CPU- en geheugengebruik.

Zie ook

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