Regex Constructeurs

Référence

Définition

Espace de noms:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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 des options qui modifient le modèle et une valeur qui spécifie la durée pendant laquelle une méthode de correspondance de modèle doit tenter une correspondance avant d’expirer.

Regex()

Source:: Regex.cs

Source:: Regex.cs

Source:: Regex.cs

Initialise une nouvelle instance de la classe Regex.

protected:
 Regex();

protected Regex ();

Protected Sub New ()

Remarques

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

S’applique à

Regex(String)

Source:: Regex.cs

Source:: Regex.cs

Source:: Regex.cs

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

ArgumentException

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

ArgumentNullException

pattern est null.

Exemples

L’exemple suivant montre comment utiliser ce constructeur pour instancier une expression régulière qui correspond à tout 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 ne respectant pas la casse, consultez le constructeur Regex(String, RegexOptions).

Remarques

Avertissement

Lorsque vous utilisez System.Text.RegularExpressions pour traiter les entrées non approuvées, transmettez une valeur de délai d’attente pour empêcher les utilisateurs malveillants d’entraîner une attaque par déni de service . Une valeur de délai d’attente spécifie la durée pendant laquelle une méthode de correspondance de modèle doit essayer de trouver une correspondance avant d’expirer.

Le paramètre pattern 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 - Informations de référence rapide.

L’appel du constructeur Regex(String) équivaut à appeler le constructeur Regex(String, RegexOptions) avec une valeur de None pour l’argument options.

Un objet Regex est immuable, ce qui signifie qu’il ne peut être utilisé que 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 sans respect de la casse, utilisez le constructeur Regex.Regex(String, RegexOptions).

Notes pour les appelants

Ce constructeur crée un objet Regex qui utilise la valeur de délai d’attente par défaut du domaine d’application dans lequel il est créé. Si une valeur de délai d’attente n’a pas é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 objet Regex est Regex(String, RegexOptions, TimeSpan), ce qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

éléments de langage d’expression régulière

S’applique à

Regex(SerializationInfo, StreamingContext)

Source:: Regex.cs

Source:: Regex.cs

Source:: Regex.cs

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: ObsoleteAttribute

Exceptions

ArgumentException

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

ArgumentNullException

Le modèle que info contient est null.

ArgumentOutOfRangeException

info contient un indicateur de RegexOptions non valide.

S’applique à

Regex(String, RegexOptions)

Source:: Regex.cs

Source:: Regex.cs

Source:: Regex.cs

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 des valeurs d’énumération qui modifient l’expression régulière.

Exceptions

ArgumentException

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

ArgumentNullException

pattern est null.

ArgumentOutOfRangeException

options contient un indicateur non valide.

Exemples

L’exemple suivant montre comment utiliser ce constructeur pour instancier une expression régulière qui correspond à tout 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 paramètre options a défini des comparaisons qui ne respectent pas la casse.

Remarques

Avertissement

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

Notes pour les appelants

Voir aussi

éléments de langage d’expression régulière

S’applique à

Regex(String, RegexOptions, TimeSpan)

Source:: Regex.cs

Source:: Regex.cs

Source:: Regex.cs

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 et une valeur qui spécifie la durée pendant laquelle une méthode de correspondance de modèle doit tenter une correspondance avant d’expirer.

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 des 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

ArgumentException

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

ArgumentNullException

pattern est null.

ArgumentOutOfRangeException

options n’est pas une valeur de RegexOptions valide.

-ou-

matchTimeout est négatif, zéro ou supérieur à environ 24 jours.

Exemples

L’exemple suivant appelle le constructeur Regex(String, RegexOptions, TimeSpan) pour instancier un objet Regex 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 à un retour arrière excessif. Si une RegexMatchTimeoutException est levée, l’exemple augmente la valeur de 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 paramètre matchTimeout spécifie la durée pendant laquelle une méthode de correspondance de modèle doit essayer de trouver une correspondance avant qu’elle expire. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode de correspondance de modèle lève une exception RegexMatchTimeoutException. 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 méthodes de correspondance de modèle d’instance qui observent l’intervalle de délai d’attente matchTimeout sont les suivantes :

La définition d’un intervalle de délai d’attente empêche les expressions régulières qui s’appuient sur un retour arrière excessif d’apparaître pour cesser de répondre lorsqu’elles traitent les entrées qui contiennent des correspondances proches. Pour plus d’informations, consultez Meilleures pratiques pour les expressions régulières et retour arrière. 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 des expressions plus courtes et plus simples.
Charge de la 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 paramètre matchTimeout 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 qui a été entré dynamiquement par les utilisateurs.
Lorsque le modèle d’expression régulière a été soigneusement 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 un retour arrière excessif lors du traitement d’une correspondance proche.

Voir aussi

S’applique à

Partage via

Regex Constructeurs

Définition

Surcharges

Regex()

Remarques

S’applique à

Regex(String)

Paramètres

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

Regex(SerializationInfo, StreamingContext)

Paramètres

Exceptions

S’applique à

Regex(String, RegexOptions)

Paramètres

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

Regex(String, RegexOptions, TimeSpan)

Paramètres

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

Commentaires

Ressources supplémentaires