RegexCompilationInfo.MatchTimeout Propriété

  • Référence

Définition

Espace de noms:
System.Text.RegularExpressions
Assembly:
System.Text.RegularExpressions.dll
Assembly:
System.dll
Source:
RegexCompilationInfo.cs
Source:
RegexCompilationInfo.cs
Source:
RegexCompilationInfo.cs

Obtient ou définit le délai d'attente par défaut de l'expression régulière.

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

Valeur de propriété

TimeSpan

Intervalle maximum par défaut qui peut s'écouler lors d'une opération de correspondance de modèles avant qu'une exception RegexMatchTimeoutException soit levée, ou InfiniteMatchTimeout si les délais d'attente sont désactivés.

Exemples

L’exemple suivant définit une seule expression régulière compilée nommée DuplicateChars qui identifie au moins deux occurrences du même caractère dans une chaîne d’entrée. L’expression régulière compilée a un délai d’expiration par défaut de 2 secondes. Lorsque vous exécutez l’exemple, il crée une bibliothèque de classes nommée RegexLib.dll qui contient l’expression régulière compilée.

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

Le modèle d'expression régulière (\w)\1+ est défini comme indiqué dans le tableau suivant.

Modèle Description
(\w) Faites correspondre n’importe quel caractère de mot et affectez-le au premier groupe de capture.
\1+ Faire correspondre une ou plusieurs occurrences de la valeur du premier groupe capturé.

L’exemple suivant utilise l’expression DuplicatedChars régulière pour identifier les caractères en double dans un tableau de chaînes. Lorsqu’il appelle le DuplicatedChars constructeur, il modifie l’intervalle de délai d’attente en .5 secondes.

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

Remarques

La MatchTimeout propriété définit l’intervalle de délai d’attente par défaut pour l’expression régulière compilée. Cette valeur représente la durée approximative pendant laquelle une expression régulière compilée exécute une seule opération de correspondance avant que l’opération expire et que le moteur d’expression régulière lève une RegexMatchTimeoutException exception lors de son case activée de minutage suivant.

Important

Nous vous recommandons de toujours définir une valeur de délai d’attente par défaut pour une expression régulière compilée. Les consommateurs de votre bibliothèque d’expressions régulières peuvent remplacer cette valeur de délai d’attente en transmettant une TimeSpan valeur qui représente le nouvel intervalle de délai d’attente au constructeur de classe de l’expression régulière compilée.

Vous pouvez affecter une valeur de délai d’attente par défaut à un RegexCompilationInfo objet de l’une des manières suivantes :

Pour définir un intervalle de délai d’attente raisonnable, tenez compte des facteurs suivants :

  • Longueur et complexité du modèle d’expression régulière. Les expressions régulières plus longues et plus complexes nécessitent plus de temps que les expressions plus courtes et plus simples.

  • Charge de machine attendue. Le traitement prend plus de temps sur les systèmes avec une utilisation élevée du processeur et de la mémoire.

S’applique à

Voir aussi