Regex Constructeurs

Définition

Initialise une nouvelle instance de la classe Regex.

Surcharges

Regex()

Initialise une nouvelle instance de la classe Regex.

Regex(String)

Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée.

Regex(SerializationInfo, StreamingContext)
Obsolète.

Initialise une nouvelle instance de la classe Regex à l'aide de données sérialisées.

Regex(String, RegexOptions)

Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée, avec des options qui modifient le modèle.

Regex(String, RegexOptions, TimeSpan)

Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée, avec les options qui modifient le modèle et une valeur qui spécifie la durée pendant laquelle une méthode de modèle doit tenter une correspondance avant son expiration.

Regex()

Initialise une nouvelle instance de la classe Regex.

protected:
 Regex();
protected Regex ();
Protected Sub New ()

Remarques

Notez que ce constructeur est protégé ; il ne peut être appelé que par des classes dérivées de la Regex classe .

S’applique à

Regex(String)

Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée.

public:
 Regex(System::String ^ pattern);
public Regex (string pattern);
new System.Text.RegularExpressions.Regex : string -> System.Text.RegularExpressions.Regex
Public Sub New (pattern As String)

Paramètres

pattern
String

Modèle d’expression régulière à mettre en correspondance.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.

pattern a la valeur null.

Exemples

L’exemple suivant montre comment utiliser ce constructeur pour instancier une expression régulière qui correspond à n’importe quel mot commençant par les lettres « a » ou « t ».

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex defaultRegex = new Regex(pattern);
      // Get matches of pattern in text
      matches = defaultRegex.Matches(text);
      Console.WriteLine("Parsing '{0}'", text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//       Parsing 'The threaded application ate up the thread pool as it executed.'
//       0. threaded
//       1. application
//       2. ate
//       3. the
//       4. thread
//       5. as
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim defaultRegex As New Regex(pattern)
      ' Get matches of pattern in text
      matches = defaultRegex.Matches(text)
      Console.WriteLine("Parsing '{0}'", text)
      ' Iterate matches
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Parsing 'The threaded application ate up the thread pool as it executed.'
'       0. threaded
'       1. application
'       2. ate
'       3. the
'       4. thread
'       5. as

Notez que le modèle d’expression régulière ne peut pas correspondre au mot « The » au début du texte, car les comparaisons respectent la casse par défaut. Pour obtenir un exemple de comparaison qui ne respecte pas la casse, consultez le Regex(String, RegexOptions) constructeur .

Remarques

Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à mettre en correspondance. Pour plus d’informations sur les expressions régulières, consultez les rubriques Expressions régulières .NET et Langage d’expression régulière - Référence rapide .

Appeler le Regex(String) constructeur revient à appeler le Regex(String, RegexOptions) constructeur avec la valeur pour None l’argument options .

Un Regex objet est immuable, ce qui signifie qu’il peut être utilisé uniquement pour le modèle de correspondance que vous définissez lorsque vous le créez. Toutefois, il peut être utilisé n’importe quel nombre de fois sans être recompilé.

Ce constructeur instancie un objet d’expression régulière qui tente une correspondance respectant la casse de tous les caractères alphabétiques définis dans pattern. Pour une correspondance qui ne respecte pas la casse, utilisez le Regex.Regex(String, RegexOptions) constructeur .

Notes pour les appelants

Ce constructeur crée un Regex objet qui utilise la valeur de délai d’attente par défaut du domaine d’application dans lequel il est créé. Si aucune valeur de délai d’attente n’a été définie pour le domaine d’application, l’objet Regex utilise la valeur InfiniteMatchTimeout, ce qui empêche l’opération d’expirer. Le constructeur recommandé pour la création d’un Regex objet est Regex(String, RegexOptions, TimeSpan), ce qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

S’applique à

Regex(SerializationInfo, StreamingContext)

Attention

This API supports obsolete formatter-based serialization. It should not be called or extended by application code.

Initialise une nouvelle instance de la classe Regex à l'aide de données sérialisées.

protected:
 Regex(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);
protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
[System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex
[<System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex
Protected Sub New (info As SerializationInfo, context As StreamingContext)

Paramètres

info
SerializationInfo

Objet qui contient un modèle sérialisé et des informations RegexOptions.

context
StreamingContext

Destination de cette sérialisation. (Ce paramètre n'est pas utilisé ; spécifiez null).

Attributs

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.

Le modèle contenu par info est null.

info contient un indicateur RegexOptions non valide.

S’applique à

Regex(String, RegexOptions)

Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée, avec des options qui modifient le modèle.

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options);
new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Regex
Public Sub New (pattern As String, options As RegexOptions)

Paramètres

pattern
String

Modèle d’expression régulière à mettre en correspondance.

options
RegexOptions

Combinaison de bits de valeurs d'énumération qui modifient l'expression régulière.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.

pattern a la valeur null.

options contient un indicateur non valide.

Exemples

L’exemple suivant montre comment utiliser ce constructeur pour instancier une expression régulière qui correspond à n’importe quel mot commençant par les lettres « a » ou « t ».

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.Compiled;
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex optionRegex = new Regex(pattern, options);
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString());
      // Get matches of pattern in text
      matches = optionRegex.Matches(text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//    Parsing 'The threaded application ate up the thread pool as it executed.'
//        with options IgnoreCase, Compiled:
//    0. The
//    1. threaded
//    2. application
//    3. ate
//    4. the
//    5. thread
//    6. as
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.Compiled
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim optionRegex As New Regex(pattern, options)
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString())
      ' Get matches of pattern in text
      matches = optionRegex.Matches(text)
      ' Iterate matches   
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    Parsing 'The threaded application ate up the thread pool as it executed.'
'       with options IgnoreCase, Compiled:
'    0. The
'    1. threaded
'    2. application
'    3. ate
'    4. the
'    5. thread
'    6. as

Notez que la collection de correspondances inclut le mot « The » qui commence le texte, car le options paramètre a défini des comparaisons ne respectant pas la casse.

Remarques

Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à mettre en correspondance. Pour plus d’informations sur les expressions régulières, consultez les rubriques Expressions régulières .NET et Langage d’expression régulière - Référence rapide .

Un Regex objet est immuable, ce qui signifie qu’il peut être utilisé uniquement pour les paramètres de correspondance que vous définissez lorsque vous le créez. Toutefois, il peut être utilisé n’importe quel nombre de fois sans être recompilé.

Notes pour les appelants

Ce constructeur crée un Regex objet qui utilise la valeur de délai d’attente par défaut du domaine d’application dans lequel il est créé. Si aucune valeur de délai d’attente n’a été définie pour le domaine d’application, l’objet Regex utilise la valeur InfiniteMatchTimeout, ce qui empêche l’opération d’expirer. Le constructeur recommandé pour la création d’un Regex objet est Regex(String, RegexOptions, TimeSpan), ce qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

S’applique à

Regex(String, RegexOptions, TimeSpan)

Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée, avec les options qui modifient le modèle et une valeur qui spécifie la durée pendant laquelle une méthode de modèle doit tenter une correspondance avant son expiration.

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Regex
Public Sub New (pattern As String, options As RegexOptions, matchTimeout As TimeSpan)

Paramètres

pattern
String

Modèle d’expression régulière à mettre en correspondance.

options
RegexOptions

Combinaison de bits de valeurs d'énumération qui modifient l'expression régulière.

matchTimeout
TimeSpan

Intervalle de délai d’attente ou InfiniteMatchTimeout pour indiquer que la méthode ne doit pas expirer.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.

pattern a la valeur null.

options n’est pas une valeur de RegexOptions valide.

- ou -

matchTimeout a une valeur négative, nulle ou supérieure à environ 24 jours.

Exemples

L’exemple suivant appelle le Regex(String, RegexOptions, TimeSpan) constructeur pour instancier un Regex objet avec une valeur de délai d’attente d’une seconde. Le modèle d'expression régulière (a+)+$, qui correspond à une ou plusieurs séquences d'un ou plusieurs caractères « a » à la fin d'une ligne, est soumis à une rétroaction excessive. Si un RegexMatchTimeoutException est levée, l’exemple augmente la valeur du délai d’attente jusqu’à la valeur maximale de trois secondes. Sinon, il abandonne la tentative de correspondance avec le modèle.

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;
using System.Text.RegularExpressions;
using System.Threading; 

public class Example
{
   const int MaxTimeoutInSeconds = 3;

   public static void Main()
   {
      string pattern = @"(a+)+$";    // DO NOT REUSE THIS PATTERN.
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1));       
      Stopwatch sw = null;
      
      string[] inputs= { "aa", "aaaa>", 
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                         "aaaaaaaaaaaaaaaaaaaaaa>",
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" };
                                 
      foreach (var inputValue in inputs) {
         Console.WriteLine("Processing {0}", inputValue);
         bool timedOut = false;
         do { 
            try {
               sw = Stopwatch.StartNew();
               // Display the result.
               if (rgx.IsMatch(inputValue)) {
                  sw.Stop();
                  Console.WriteLine(@"Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed); 
               }
               else {
                  sw.Stop();
                  Console.WriteLine(@"'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed);
               }
            }
            catch (RegexMatchTimeoutException e) {   
               sw.Stop();
               // Display the elapsed time until the exception.
               Console.WriteLine(@"Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed);
               Thread.Sleep(1500);       // Pause for 1.5 seconds.

               // Increase the timeout interval and retry.
               TimeSpan timeout = e.MatchTimeout.Add(TimeSpan.FromSeconds(1));
               if (timeout.TotalSeconds > MaxTimeoutInSeconds) {
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds);
                  timedOut = false;
               }
               else {               
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout); 
                  rgx = new Regex(pattern, RegexOptions.IgnoreCase, timeout);
                  timedOut = true;
               }
            }
         } while (timedOut);
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following :
//    Processing aa
//    Valid: 'aa' (00.0000779 seconds)
//    
//    Processing aaaa>
//    'aaaa>' is not a valid string. (00.00005 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
//    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
//    Changing the timeout interval to 00:00:02
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
//    Changing the timeout interval to 00:00:03
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
//    Maximum timeout interval of 3 seconds exceeded.
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
//    Maximum timeout interval of 3 seconds exceeded.
Imports System.ComponentModel
Imports System.Diagnostics
Imports System.Security
Imports System.Text.RegularExpressions
Imports System.Threading 

Module Example
   Const MaxTimeoutInSeconds As Integer = 3
   
   Public Sub Main()
      Dim pattern As String = "(a+)+$"    ' DO NOT REUSE THIS PATTERN.
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1))       
      Dim sw As Stopwatch = Nothing
      
      Dim inputs() As String = { "aa", "aaaa>", 
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                                 "aaaaaaaaaaaaaaaaaaaaaa>",
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" }
                                 
      For Each inputValue In inputs
         Console.WriteLine("Processing {0}", inputValue)
         Dim timedOut As Boolean = False
         Do 
            Try
               sw = Stopwatch.StartNew()
               ' Display the result.
               If rgx.IsMatch(inputValue) Then
                  sw.Stop()
                  Console.WriteLine("Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed) 
               Else
                  sw.Stop()
                  Console.WriteLine("'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed)
               End If
            Catch e As RegexMatchTimeoutException   
               sw.Stop()
               ' Display the elapsed time until the exception.
               Console.WriteLine("Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed)
               Thread.Sleep(1500)       ' Pause for 1.5 seconds.

               ' Increase the timeout interval and retry.
               Dim timeout As TimeSpan = e.MatchTimeout.Add(TimeSpan.FromSeconds(1))
               If timeout.TotalSeconds > MaxTimeoutInSeconds Then
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds)
                  timedOut = False
               Else                
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout) 
                  rgx = New Regex(pattern, RegexOptions.IgnoreCase, timeout)
                  timedOut = True
               End If
            End Try
         Loop While timedOut
         Console.WriteLine()
      Next   
   End Sub 
End Module
' The example displays output like the following:
'    Processing aa
'    Valid: 'aa' (00.0000779 seconds)
'    
'    Processing aaaa>
'    'aaaa>' is not a valid string. (00.00005 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
'    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
'    Changing the timeout interval to 00:00:02
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
'    Changing the timeout interval to 00:00:03
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
'    Maximum timeout interval of 3 seconds exceeded.
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
'    Maximum timeout interval of 3 seconds exceeded.

Remarques

Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à mettre en correspondance. Pour plus d’informations sur les expressions régulières, consultez les rubriques Expressions régulières .NET et Langage d’expression régulière - Référence rapide .

Un Regex objet est immuable, ce qui signifie qu’il peut être utilisé uniquement pour le modèle de correspondance que vous définissez lorsque vous le créez. Toutefois, il peut être utilisé n’importe quel nombre de fois sans être recompilé.

Le matchTimeout paramètre spécifie la durée pendant laquelle une méthode de correspondance de modèle doit essayer de trouver une correspondance avant son expiration. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode de correspondance de modèle lève une RegexMatchTimeoutException exception. matchTimeout remplace toute valeur de délai d’attente par défaut définie pour le domaine d’application dans lequel l’objet Regex est créé. Les instance méthodes de correspondance de modèle qui observent l’intervalle matchTimeout de délai d’attente sont les suivantes :

La définition d’un intervalle de délai d’attente empêche les expressions régulières qui reposent sur un retour arrière excessif de s’arrêter de répondre lorsqu’elles traitent des entrées qui contiennent des correspondances proches. Pour plus d’informations, consultez Meilleures pratiques pour les expressions régulières et la rétroaction. 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 qui ont une utilisation élevée du processeur et de la mémoire.

Notes pour les appelants

Nous vous recommandons de définir le matchTimeout paramètre sur une valeur appropriée, par exemple deux secondes. Si vous désactivez les délais d’attente en spécifiant InfiniteMatchTimeout, le moteur d’expression régulière offre des performances légèrement meilleures. Toutefois, vous devez désactiver les délais d’attente uniquement dans les conditions suivantes :

  • Lorsque l’entrée traitée par une expression régulière est dérivée d’une source connue et approuvée ou se compose de texte statique. Cela exclut le texte entré dynamiquement par les utilisateurs.

  • Lorsque le modèle d’expression régulière a été minutieusement testé pour s’assurer qu’il gère efficacement les correspondances, les non-correspondances et les correspondances proches.

  • Lorsque le modèle d’expression régulière ne contient aucun élément de langage connu pour provoquer une rétroaction excessive lors du traitement d’une quasi-correspondance.

Voir aussi

S’applique à