Regex Classe

Définition

Représente une expression régulière immuable.Represents an immutable regular expression.

public ref class Regex : System::Runtime::Serialization::ISerializable
[System.Serializable]
public class Regex : System.Runtime.Serialization.ISerializable
type Regex = class
    interface ISerializable
Public Class Regex
Implements ISerializable
Héritage
Regex
Dérivé
Attributs
Implémente

Exemples

L’exemple suivant utilise une expression régulière pour rechercher des occurrences répétées de mots dans une chaîne.The following example uses a regular expression to check for repeated occurrences of words in a string. L'expression régulière \b(?<word>\w+)\s+(\k<word>)\b peut être interprétée comme indiqué dans le tableau suivant.The regular expression \b(?<word>\w+)\s+(\k<word>)\b can be interpreted as shown in the following table.

MotifPattern DescriptionDescription
\b Démarrer la correspondance à la limite d’un mot.Start the match at a word boundary.
(?<word>\w+) Faire correspondre un ou plusieurs caractères alphabétiques jusqu’à une limite de mot.Match one or more word characters up to a word boundary. Nommez ce groupe capturé word.Name this captured group word.
\s+ Correspond à un ou plusieurs espaces blancs.Match one or more white-space characters.
(\k<word>) Correspond au groupe capturé nommé word.Match the captured group that is named word.
\b Mettre en correspondance la limite d'un mot.Match a word boundary.
#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
   // Define a regular expression for repeated words.
   Regex^ rx = gcnew Regex( "\\b(?<word>\\w+)\\s+(\\k<word>)\\b",static_cast<RegexOptions>(RegexOptions::Compiled | RegexOptions::IgnoreCase) );

   // Define a test string.        
   String^ text = "The the quick brown fox  fox jumps over the lazy dog dog.";

   // Find matches.
   MatchCollection^ matches = rx->Matches( text );

   // Report the number of matches found.
   Console::WriteLine( "{0} matches found.", matches->Count );

   // Report on each match.
   for each (Match^ match in matches)
   {
      String^ word = match->Groups["word"]->Value;
      int index = match->Index;
      Console::WriteLine("{0} repeated at position {1}", word, index);   
   }
}
using System;
using System.Text.RegularExpressions;

public class Test
{

    public static void Main ()
    {

        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.        
        string text = "The the quick brown fox  fox jumps over the lazy dog dog.";
        
        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}", 
                          matches.Count, 
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",  
                              groups["word"].Value, 
                              groups[0].Index, 
                              groups[1].Index);
        }
    }
}
// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54
Imports System.Text.RegularExpressions

Public Module Test

    Public Sub Main()
        ' Define a regular expression for repeated words.
        Dim rx As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches.
        Dim matches As MatchCollection = rx.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
    End Sub
End Module
' The example produces the following output to the console:
'       3 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'The' repeated at positions 0 and 4
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 50 and 54

L’exemple suivant illustre l’utilisation d’une expression régulière pour vérifier si une chaîne représente une valeur monétaire ou a le format correct pour représenter une valeur monétaire.The following example illustrates the use of a regular expression to check whether a string either represents a currency value or has the correct format to represent a currency value. Dans ce cas, l’expression régulière est créée dynamiquement à partir des propriétés NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSignet NumberFormatInfo.PositiveSign pour la culture actuelle de l’utilisateur.In this case, the regular expression is built dynamically from the NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign, and NumberFormatInfo.PositiveSign properties for the user's current culture. Si la culture actuelle du système est en-US, l’expression régulière résultante est ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$.If the system's current culture is en-US, the resulting regular expression is ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Cette expression régulière peut être interprétée comme indiqué dans le tableau suivant.This regular expression can be interpreted as shown in the following table.

MotifPattern DescriptionDescription
^ Commencer au début de la chaîne.Start at the beginning of the string.
\s* Correspond à zéro, un ou plusieurs espaces blancs.Match zero or more white-space characters.
[\+-]? Correspond à zéro ou à une occurrence du signe positif ou du signe négatif.Match zero or one occurrence of either the positive sign or the negative sign.
\s? Mettre en correspondance zéro ou un espace blanc.Match zero or one white-space character.
\$? Correspond à zéro ou à une occurrence du signe dollar.Match zero or one occurrence of the dollar sign.
\s? Mettre en correspondance zéro ou un espace blanc.Match zero or one white-space character.
\d* Met en correspondance zéro ou plusieurs chiffres décimaux.Match zero or more decimal digits.
\.? Correspond à zéro ou à un symbole de virgule décimale.Match zero or one decimal point symbol.
\d{2}? Faire correspondre deux chiffres décimaux zéro ou une fois.Match two decimal digits zero or one time.
(\d*\.?\d{2}?){1} Faire correspondre au moins une fois le modèle de chiffres intégraux et fractionnaires séparés par un symbole de virgule décimale.Match the pattern of integral and fractional digits separated by a decimal point symbol at least one time.
$ Mettre en correspondance la fin de la chaîne.Match the end of the string.

Dans ce cas, l’expression régulière suppose qu’une chaîne de devise valide ne contient pas de symboles de séparateur de groupes et qu’elle n’a pas de chiffres fractionnaires ou le nombre de chiffres fractionnaires définis par la propriété CurrencyDecimalDigits de la culture actuelle.In this case, the regular expression assumes that a valid currency string does not contain group separator symbols, and that it has either no fractional digits or the number of fractional digits defined by the current culture's CurrencyDecimalDigits property.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get the current NumberFormatInfo object to build the regular 
      // expression pattern dynamically.
      NumberFormatInfo nfi = NumberFormatInfo.CurrentInfo;

      // Define the regular expression pattern.
      string pattern; 
      pattern = @"^\s*[";
      // Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + @"]?\s?";
      // Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + @"?\s?";
      // Add integral digits to the pattern.
      pattern += @"(\d*";
      // Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?";
      // Add the fractional digits.
      pattern += @"\d{";
      // Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "}?){1}$";
      
      Regex rgx = new Regex(pattern);

      // Define some test strings.
      string[] tests = { "-42", "19.99", "0.001", "100 USD", 
                         ".34", "0.34", "1,052.21", "$10.62", 
                         "+1.43", "-$0.23" };

      // Check each test string against the regular expression.
      foreach (string test in tests)
      {
         if (rgx.IsMatch(test))
            Console.WriteLine("{0} is a currency value.", test);
         else
            Console.WriteLine("{0} is not a currency value.", test);
      }
   }
}
// The example displays the following output:
//       -42 is a currency value.
//       19.99 is a currency value.
//       0.001 is not a currency value.
//       100 USD is not a currency value.
//       .34 is a currency value.
//       0.34 is a currency value.
//       1,052.21 is not a currency value.
//       $10.62 is a currency value.
//       +1.43 is a currency value.
//       -$0.23 is a currency value.
Imports System.Globalization
Imports System.Text.RegularExpressions

Public Module Example
   Public Sub Main()
      ' Get the current NumberFormatInfo object to build the regular 
      ' expression pattern dynamically.
      Dim nfi As NumberFormatInfo = NumberFormatInfo.CurrentInfo

      ' Define the regular expression pattern.
      Dim pattern As String 
      pattern = "^\s*["
      ' Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + "]?\s?"
      ' Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + "?\s?"
      ' Add integral digits to the pattern.
      pattern += "(\d*"
      ' Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?"
      ' Add the fractional digits.
      pattern += "\d{"
      ' Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "}?){1}$"
      
      Dim rgx As New Regex(pattern)

      ' Define some test strings.
      Dim tests() As String = {"-42", "19.99", "0.001", "100 USD", _
                               ".34", "0.34", "1,052.21", "$10.62", _
                               "+1.43", "-$0.23" }

      ' Check each test string against the regular expression.
      For Each test As String In tests
         If rgx.IsMatch(test) Then
            Console.WriteLine("{0} is a currency value.", test)
         Else
            Console.WriteLine("{0} is not a currency value.", test)
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       -42 is a currency value.
'       19.99 is a currency value.
'       0.001 is not a currency value.
'       100 USD is not a currency value.
'       .34 is a currency value.
'       0.34 is a currency value.
'       1,052.21 is not a currency value.
'       $10.62 is a currency value.
'       +1.43 is a currency value.
'       -$0.23 is a currency value.

Étant donné que l’expression régulière de cet exemple est créée dynamiquement, nous ne savons pas au moment de la conception si le symbole monétaire, le signe décimal ou les signes positif et négatif de la culture actuelle risquent d’être mal interprétés par le moteur d’expression régulière comme standard opérateurs de langage d’expression.Because the regular expression in this example is built dynamically, we do not know at design time whether the current culture's currency symbol, decimal sign, or positive and negative signs might be misinterpreted by the regular expression engine as regular expression language operators. Pour éviter toute mauvaise interprétation, l’exemple passe chaque chaîne générée dynamiquement à la méthode Escape.To prevent any misinterpretation, the example passes each dynamically generated string to the Escape method.

Remarques

La classe Regex représente le moteur d’expression régulière du .NET Framework.The Regex class represents the .NET Framework's regular expression engine. Il peut être utilisé pour analyser rapidement de grandes quantités de texte pour rechercher des modèles de caractères spécifiques. pour extraire, modifier, remplacer ou supprimer des sous-chaînes de texte ; et pour ajouter les chaînes extraites à une collection afin de générer un rapport.It can be used to quickly parse large amounts of text to find specific character patterns; to extract, edit, replace, or delete text substrings; and to add the extracted strings to a collection to generate a report.

Notes

Si votre intérêt principal est de valider une chaîne en déterminant si elle est conforme à un modèle particulier, vous pouvez utiliser la classe System.Configuration.RegexStringValidator.If your primary interest is to validate a string by determining whether it conforms to a particular pattern, you can use the System.Configuration.RegexStringValidator class.

Pour utiliser des expressions régulières, vous définissez le modèle que vous souhaitez identifier dans un flux de texte à l’aide de la syntaxe documentée dans langage des expressions régulières-aide-mémoire.To use regular expressions, you define the pattern that you want to identify in a text stream by using the syntax documented in Regular Expression Language - Quick Reference. Ensuite, vous pouvez éventuellement instancier un objet Regex.Next, you can optionally instantiate a Regex object. Enfin, vous appelez une méthode qui effectue une opération, telle que le remplacement d’un texte qui correspond au modèle d’expression régulière, ou l’identification d’une correspondance de modèle.Finally, you call a method that performs some operation, such as replacing text that matches the regular expression pattern, or identifying a pattern match.

Notes

Pour certains modèles d’expressions régulières courants, consultez exemples d’expressions régulières.For some common regular expression patterns, see Regular Expression Examples. Il existe également un certain nombre de bibliothèques en ligne de modèles d’expressions régulières, tels que celui sur Regular-Expressions.info.There are also a number of online libraries of regular expression patterns, such as the one at Regular-Expressions.info.

Pour plus d’informations sur l’utilisation de la classe Regex, consultez les sections suivantes dans cette rubrique :For more information about using the Regex class, see the following sections in this topic:

Pour plus d'informations sur le langage d'expression régulière, consultez Langage des expressions régulières - Aide-mémoire ou téléchargez et imprimez l'une des brochures suivantes :For more information about the regular expression language, see Regular Expression Language - Quick Reference or download and print one of these brochures:

Aide-mémoire au format Word (.docx)Quick Reference in Word (.docx) format
Aide-mémoire au format PDF (.pdf)Quick Reference in PDF (.pdf) format

Méthodes Regex et StringRegex vs. String Methods

La classe System.String comprend plusieurs méthodes de recherche et de comparaison que vous pouvez utiliser pour effectuer des critères spéciaux avec du texte.The System.String class includes several search and comparison methods that you can use to perform pattern matching with text. Par exemple, les méthodes String.Contains, String.EndsWithet String.StartsWith déterminent si une instance de chaîne contient une sous-chaîne spécifiée ; et les méthodes String.IndexOf, String.IndexOfAny, String.LastIndexOfet String.LastIndexOfAny retournent la position de départ d’une sous-chaîne spécifiée dans une chaîne.For example, the String.Contains, String.EndsWith, and String.StartsWith methods determine whether a string instance contains a specified substring; and the String.IndexOf, String.IndexOfAny, String.LastIndexOf, and String.LastIndexOfAny methods return the starting position of a specified substring in a string. Utilisez les méthodes de la classe System.String lorsque vous recherchez une chaîne spécifique.Use the methods of the System.String class when you are searching for a specific string. Utilisez la classe Regex lorsque vous recherchez un modèle spécifique dans une chaîne.Use the Regex class when you are searching for a specific pattern in a string. Pour plus d’informations et d’exemples, consultez .NET Framework des expressions régulières.For more information and examples, see .NET Framework Regular Expressions.

Retour aux notesBack to Remarks

Méthodes statiques et méthodes d’instanceStatic vs. Instance Methods

Une fois que vous avez défini un modèle d’expression régulière, vous pouvez le fournir au moteur des expressions régulières de l’une des deux manières suivantes :After you define a regular expression pattern, you can provide it to the regular expression engine in either of two ways:

  • En instanciant un objet Regex qui représente l’expression régulière.By instantiating a Regex object that represents the regular expression. Pour ce faire, vous devez passer le modèle d’expression régulière à un constructeur Regex.To do this, you pass the regular expression pattern to a Regex constructor. Un objet Regex est immuable ; Lorsque vous instanciez un objet Regex avec une expression régulière, l’expression régulière de cet objet ne peut pas être modifiée.A Regex object is immutable; when you instantiate a Regex object with a regular expression, that object's regular expression cannot be changed.

  • En fournissant à la fois l’expression régulière et le texte à rechercher dans une static (Shared dans Visual Basic) Regex méthode.By supplying both the regular expression and the text to search to a static (Shared in Visual Basic) Regex method. Cela vous permet d’utiliser une expression régulière sans créer explicitement un objet Regex.This enables you to use a regular expression without explicitly creating a Regex object.

Toutes les méthodes d’identification de modèle de Regex incluent des surcharges statiques et d’instance.All Regex pattern identification methods include both static and instance overloads.

Le moteur des expressions régulières doit compiler un modèle particulier pour que le modèle puisse être utilisé.The regular expression engine must compile a particular pattern before the pattern can be used. Étant donné que les objets Regex sont immuables, il s’agit d’une procédure unique qui se produit lorsqu’un constructeur de classe Regex ou une méthode statique est appelé.Because Regex objects are immutable, this is a one-time procedure that occurs when a Regex class constructor or a static method is called. Pour éviter d’avoir à compiler à plusieurs reprises une seule expression régulière, le moteur d’expression régulière met en cache les expressions régulières compilées utilisées dans les appels de méthode statique.To eliminate the need to repeatedly compile a single regular expression, the regular expression engine caches the compiled regular expressions used in static method calls. Par conséquent, les méthodes de mise en correspondance de modèle d’expression régulière offrent des performances comparables pour les méthodes statiques et d’instance.As a result, regular expression pattern-matching methods offer comparable performance for static and instance methods.

Important

Dans les versions 1,0 et 1,1 de .NET Framework, toutes les expressions régulières compilées, qu’elles aient été utilisées dans des appels de méthode d’instance ou statiques, ont été mises en cache.In the .NET Framework versions 1.0 and 1.1, all compiled regular expressions, whether they were used in instance or static method calls, were cached. À partir de la .NET Framework 2,0, seules les expressions régulières utilisées dans les appels de méthode statique sont mises en cache.Starting with the .NET Framework 2.0, only regular expressions used in static method calls are cached.

Toutefois, la mise en cache peut nuire aux performances dans les deux cas suivants :However, caching can adversely affect performance in the following two cases:

  • Lorsque vous utilisez des appels de méthode statique avec un grand nombre d’expressions régulières.When you use static method calls with a large number of regular expressions. Par défaut, le moteur d’expression régulière met en cache les 15 expressions régulières statiques utilisées le plus récemment.By default, the regular expression engine caches the 15 most recently used static regular expressions. Si votre application utilise plus de 15 expressions régulières statiques, certaines expressions régulières doivent être recompilées.If your application uses more than 15 static regular expressions, some regular expressions must be recompiled. Pour éviter cette recompilation, vous pouvez augmenter la propriété Regex.CacheSize.To prevent this recompilation, you can increase the Regex.CacheSize property.

  • Lorsque vous instanciez de nouveaux objets Regex avec des expressions régulières qui ont été compilées précédemment.When you instantiate new Regex objects with regular expressions that have previously been compiled. Par exemple, le code suivant définit une expression régulière pour rechercher les mots en double dans un flux de texte.For example, the following code defines a regular expression to locate duplicated words in a text stream. Bien que l’exemple utilise une expression régulière unique, il instancie un nouvel objet Regex pour traiter chaque ligne de texte.Although the example uses a single regular expression, it instantiates a new Regex object to process each line of text. Cela entraîne la recompilation de l’expression régulière avec chaque itération de la boucle.This results in the recompilation of the regular expression with each iteration of the loop.

    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();   
    
    Dim sr As New StreamReader(filename)
    Dim input As String
    Dim pattern As String = "\b(\w+)\s\1\b"
    Do While sr.Peek() >= 0
       input = sr.ReadLine()
       Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
       Dim matches As MatchCollection = rgx.Matches(input)
       If matches.Count > 0 Then
          Console.WriteLine("{0} ({1} matches):", input, matches.Count)
          For Each match As Match In matches
             Console.WriteLine("   " + match.Value)
          Next   
       End If
    Loop
    sr.Close()   
    

    Pour empêcher la recompilation, vous devez instancier un objet Regex unique qui est accessible à l’ensemble du code qui l’exige, comme illustré dans l’exemple réécrit suivant.To prevent recompilation, you should instantiate a single Regex object that is accessible to all code that requires it, as shown in the following rewritten example.

    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
    
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();   
    
    Dim sr As New StreamReader(filename)
    Dim input As String
    Dim pattern As String = "\b(\w+)\s\1\b"
    Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
    Do While sr.Peek() >= 0
       input = sr.ReadLine()
       Dim matches As MatchCollection = rgx.Matches(input)
       If matches.Count > 0 Then
          Console.WriteLine("{0} ({1} matches):", input, matches.Count)
          For Each match As Match In matches
             Console.WriteLine("   " + match.Value)
          Next   
       End If
    Loop
    sr.Close()   
    

Retour aux notesBack to Remarks

Exécution d’opérations d’expressions régulièresPerforming Regular Expression Operations

Que vous décidiez d’instancier un objet Regex et d’appeler ses méthodes ou d’appeler des méthodes statiques, la classe Regex offre les fonctionnalités de critères spéciaux suivantes :Whether you decide to instantiate a Regex object and call its methods or call static methods, the Regex class offers the following pattern-matching functionality:

  • Validation d’une correspondance.Validation of a match. Vous appelez la méthode IsMatch pour déterminer si une correspondance est présente.You call the IsMatch method to determine whether a match is present.

  • Récupération d’une correspondance unique.Retrieval of a single match. Vous appelez la méthode Match pour récupérer un objet Match qui représente la première correspondance dans une chaîne ou dans une partie d’une chaîne.You call the Match method to retrieve a Match object that represents the first match in a string or in part of a string. Les correspondances suivantes peuvent être récupérées en appelant la méthode Match.NextMatch.Subsequent matches can be retrieved by calling the Match.NextMatch method.

  • Récupération de toutes les correspondances.Retrieval of all matches. Vous appelez la méthode Matches pour récupérer un objet System.Text.RegularExpressions.MatchCollection représentant toutes les correspondances trouvées dans une chaîne ou dans une partie d’une chaîne.You call the Matches method to retrieve a System.Text.RegularExpressions.MatchCollection object that represents all the matches found in a string or in part of a string.

  • Remplacement du texte correspondant.Replacement of matched text. Vous appelez la méthode Replace pour remplacer le texte correspondant.You call the Replace method to replace matched text. Le texte de remplacement peut également être défini par une expression régulière.The replacement text can also be defined by a regular expression. De plus, certaines des méthodes Replace incluent un paramètre MatchEvaluator qui vous permet de définir par programmation le texte de remplacement.In addition, some of the Replace methods include a MatchEvaluator parameter that enables you to programmatically define the replacement text.

  • Création d’un tableau de chaînes formé à partir de parties d’une chaîne d’entrée.Creation of a string array that is formed from parts of an input string. Vous appelez la méthode Split pour fractionner une chaîne d’entrée aux positions définies par l’expression régulière.You call the Split method to split an input string at positions that are defined by the regular expression.

En plus de ses méthodes de mise en correspondance de modèle, la classe Regex comprend plusieurs méthodes à usage spécial :In addition to its pattern-matching methods, the Regex class includes several special-purpose methods:

  • La méthode Escape échappe les caractères qui peuvent être interprétés comme des opérateurs d’expression régulière dans une expression régulière ou une chaîne d’entrée.The Escape method escapes any characters that may be interpreted as regular expression operators in a regular expression or input string.

  • La méthode Unescape supprime ces caractères d’échappement.The Unescape method removes these escape characters.

  • La méthode CompileToAssembly crée un assembly qui contient des expressions régulières prédéfinies.The CompileToAssembly method creates an assembly that contains predefined regular expressions. Le .NET Framework contient des exemples de ces assemblys à usage spécial dans l’espace de noms System.Web.RegularExpressions.The .NET Framework contains examples of these special-purpose assemblies in the System.Web.RegularExpressions namespace.

Retour aux notesBack to Remarks

Définition d’une valeur de délai d’attenteDefining a Time-Out Value

Le .NET Framework prend en charge un langage d’expression régulière complet qui fournit une puissance et une flexibilité substantielles dans les critères spéciaux.The .NET Framework supports a full-featured regular expression language that provides substantial power and flexibility in pattern matching. Toutefois, la puissance et la flexibilité ont un coût : le risque de mauvaises performances.However, the power and flexibility come at a cost: the risk of poor performance. Les expressions régulières qui s’exécutent mal sont étonnamment faciles à créer.Regular expressions that perform poorly are surprisingly easy to create. Dans certains cas, les opérations d’expressions régulières qui reposent sur une rétroaction excessive peuvent sembler cesser de répondre lorsqu’elles traitent du texte qui correspond presque au modèle d’expression régulière.In some cases, regular expression operations that rely on excessive backtracking can appear to stop responding when they process text that nearly matches the regular expression pattern. Pour plus d’informations sur le moteur d’expression régulière .NET Framework, consultez Détails du comportement des expressions régulières.For more information about the .NET Framework regular expression engine, see Details of Regular Expression Behavior. Pour plus d’informations sur la rétroaction excessive, consultez rétroaction.For more information about excessive backtracking, see Backtracking.

À partir de la .NET Framework 4.5.NET Framework 4.5, vous pouvez définir un intervalle de délai d’attente pour les correspondances d’expressions régulières.Starting with the .NET Framework 4.5.NET Framework 4.5, you can define a time-out interval for regular expression matches. Si le moteur d’expression régulière ne peut pas identifier une correspondance dans cet intervalle de temps, l’opération de correspondance lève une exception RegexMatchTimeoutException.If the regular expression engine cannot identify a match within this time interval, the matching operation throws a RegexMatchTimeoutException exception. Dans la plupart des cas, cela empêche le moteur d’expression régulière de gaspiller la puissance de traitement en tentant de faire correspondre du texte qui correspond presque au modèle d’expression régulière.In most cases, this prevents the regular expression engine from wasting processing power by trying to match text that nearly matches the regular expression pattern. Cela peut également indiquer que l’intervalle de délai d’attente a été défini sur une valeur trop faible ou que la charge de l’ordinateur actuel a entraîné une dégradation globale des performances.It also could indicate, however, that the timeout interval has been set too low, or that the current machine load has caused an overall degradation in performance.

La façon dont vous gérez l’exception dépend de la cause de l’exception.How you handle the exception depends on the cause of the exception. Si l’exception se produit parce que l’intervalle de délai d’attente est défini sur une valeur trop faible ou en raison d’une charge excessive de l’ordinateur, vous pouvez augmenter l’intervalle de délai d’attente et réessayer l’opération de correspondance.If the exception occurs because the time-out interval is set too low or because of excessive machine load, you can increase the time-out interval and retry the matching operation. Si l’exception se produit parce que l’expression régulière repose sur une rétroaction excessive, vous pouvez supposer qu’une correspondance n’existe pas et, éventuellement, vous pouvez consigner des informations qui vous aideront à modifier le modèle d’expression régulière.If the exception occurs because the regular expression relies on excessive backtracking, you can assume that a match does not exist, and, optionally, you can log information that will help you modify the regular expression pattern.

Vous pouvez définir un intervalle de délai d’attente en appelant le constructeur Regex(String, RegexOptions, TimeSpan) quand vous instanciez un objet d’expression régulière.You can set a time-out interval by calling the Regex(String, RegexOptions, TimeSpan) constructor when you instantiate a regular expression object. Pour les méthodes statiques, vous pouvez définir un intervalle de délai d’attente en appelant une surcharge d’une méthode correspondante qui a un paramètre matchTimeout.For static methods, you can set a time-out interval by calling an overload of a matching method that has a matchTimeout parameter. Si vous ne définissez pas explicitement une valeur de délai d’attente, la valeur par défaut du délai d’attente est déterminée comme suit :If you do not set a time-out value explicitly, the default time-out value is determined as follows:

  • À l’aide de la valeur du délai d’attente au niveau de l’application, le cas échéant.By using the application-wide time-out value, if one exists. Il peut s’agir de n’importe quelle valeur de délai d’attente qui s’applique au domaine d’application dans lequel l’objet Regex est instancié ou l’appel de méthode statique est effectué.This can be any time-out value that applies to the application domain in which the Regex object is instantiated or the static method call is made. Vous pouvez définir la valeur du délai d’attente au niveau de l’application en appelant la méthode AppDomain.SetData pour assigner la représentation sous forme de chaîne d’une valeur TimeSpan à la propriété « REGEX_DEFAULT_MATCH_TIMEOUT ».You can set the application-wide time-out value by calling the AppDomain.SetData method to assign the string representation of a TimeSpan value to the "REGEX_DEFAULT_MATCH_TIMEOUT" property.

  • En utilisant la valeur InfiniteMatchTimeout, si aucune valeur de délai d’attente à l’ensemble de l’application n’a été définie.By using the value InfiniteMatchTimeout, if no application-wide time-out value has been set.

Important

Nous vous recommandons de définir une valeur de délai d’attente dans toutes les opérations de mise en correspondance de modèle d’expression régulière.We recommend that you set a time-out value in all regular expression pattern-matching operations. Pour plus d’informations, consultez meilleures pratiques pour les expressions régulières.For more information, see Best Practices for Regular Expressions.

Retour aux notesBack to Remarks

Constructeurs

Regex()

Initialise une nouvelle instance de la classe Regex.Initializes a new instance of the Regex class.

Regex(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe Regex à l'aide de données sérialisées.Initializes a new instance of the Regex class by using serialized data.

Regex(String)

Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée.Initializes a new instance of the Regex class for the specified regular expression.

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.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern.

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.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern and a value that specifies how long a pattern matching method should attempt a match before it times out.

Champs

capnames

RegexUtilisé par un objet généré par la méthode CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

caps

RegexUtilisé par un objet généré par la méthode CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

capsize

RegexUtilisé par un objet généré par la méthode CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

capslist

RegexUtilisé par un objet généré par la méthode CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

factory

RegexUtilisé par un objet généré par la méthode CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

InfiniteMatchTimeout

Spécifie qu’une opération de critères spéciaux ne doit pas expirer.Specifies that a pattern-matching operation should not time out.

internalMatchTimeout

Durée maximale pouvant s’écouler lors d’une opération de correspondance de modèle avant que l’opération expire.The maximum amount of time that can elapse in a pattern-matching operation before the operation times out.

pattern

RegexUtilisé par un objet généré par la méthode CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

roptions

RegexUtilisé par un objet généré par la méthode CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

Propriétés

CacheSize

Obtient ou définit le nombre maximal d'entrées dans le cache statique actuel des expressions régulières compilées.Gets or sets the maximum number of entries in the current static cache of compiled regular expressions.

CapNames

Obtient ou définit un dictionnaire qui mappe des groupes de capture nommés à leurs valeurs d’index.Gets or sets a dictionary that maps named capturing groups to their index values.

Caps

Obtient ou définit un dictionnaire qui mappe des groupes de capture numérotés à leurs valeurs d’index.Gets or sets a dictionary that maps numbered capturing groups to their index values.

MatchTimeout

Obtient l'intervalle du délai d'attente de l'instance actuelle.Gets the time-out interval of the current instance.

Options

Obtient les options passées dans le constructeur Regex.Gets the options that were passed into the Regex constructor.

RightToLeft

Obtient une valeur qui indique si l'expression régulière cherche de droite à gauche.Gets a value that indicates whether the regular expression searches from right to left.

Méthodes

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Compile un ou plusieurs objets Regex spécifiés dans un assembly nommé.Compiles one or more specified Regex objects to a named assembly.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])

Compile un ou plusieurs objets Regex spécifiés dans un assembly nommé avec les attributs spécifiés.Compiles one or more specified Regex objects to a named assembly with the specified attributes.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)

Compile un ou plusieurs objets Regex spécifiés et un fichier de ressources spécifié dans un assembly nommé avec les attributs spécifiés.Compiles one or more specified Regex objects and a specified resource file to a named assembly with the specified attributes.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
Escape(String)

Échappe un ensemble minimal de caractères (\, *, +, ?, |, {, [, (,), ^, $, ., # et espace blanc) en les remplaçant par leur code d’échappement.Escapes a minimal set of characters (\, *, +, ?, |, {, [, (,), ^, $, ., #, and white space) by replacing them with their escape codes. Cela indique au moteur d'expressions régulières qu'il doit interpréter ces caractères littéralement, et non comme des métacaractères.This instructs the regular expression engine to interpret these characters literally rather than as metacharacters.

Finalize()

Ce membre substitue Finalize(). Une documentation plus complète est peut-être disponible dans cette rubrique.This member overrides Finalize(), and more complete documentation might be available in that topic.

Autorise Object à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant que Object soit récupéré par l'opération garbage collection.Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection.

GetGroupNames()

Retourne un tableau de noms de groupes de captures pour l'expression régulière.Returns an array of capturing group names for the regular expression.

GetGroupNumbers()

Retourne un tableau des numéros de groupes de captures qui correspondent aux noms de groupes d'un tableau.Returns an array of capturing group numbers that correspond to group names in an array.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
GroupNameFromNumber(Int32)

Obtient le nom de groupe qui correspond au numéro de groupe spécifié.Gets the group name that corresponds to the specified group number.

GroupNumberFromName(String)

Retourne le numéro de groupe qui correspond au nom de groupe spécifié.Returns the group number that corresponds to the specified group name.

InitializeReferences()

RegexUtilisé par un objet généré par la méthode CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

IsMatch(String)

Indique si l'expression régulière spécifiée dans le constructeur Regex cherche une correspondance dans une chaîne d'entrée spécifique.Indicates whether the regular expression specified in the Regex constructor finds a match in a specified input string.

IsMatch(String, Int32)

Indique si l'expression régulière spécifiée dans le constructeur Regex cherche une correspondance dans la chaîne d'entrée spécifiée, en commençant à la position de départ définie dans la chaîne.Indicates whether the regular expression specified in the Regex constructor finds a match in the specified input string, beginning at the specified starting position in the string.

IsMatch(String, String)

Indique si l'expression régulière spécifiée cherche une correspondance dans la chaîne d'entrée spécifiée.Indicates whether the specified regular expression finds a match in the specified input string.

IsMatch(String, String, RegexOptions)

Indique si l'expression régulière spécifiée cherche une correspondance dans la chaîne d'entrée spécifiée, en utilisant les options de correspondance spécifiées.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options.

IsMatch(String, String, RegexOptions, TimeSpan)

Indique si l'expression régulière spécifiée trouve une correspondance dans la chaîne d'entrée spécifiée, en utilisant les options de correspondance et un intervalle de délai d'attente spécifiés.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options and time-out interval.

Match(String)

Recherche dans la chaîne d'entrée spécifiée la première occurrence de l'expression régulière spécifiée dans le constructeur Regex.Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

Match(String, Int32)

Recherche dans la chaîne d'entrée la première occurrence d'une expression régulière, en commençant à la position de départ spécifiée dans la chaîne.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

Match(String, Int32, Int32)

Recherche dans la chaîne d'entrée la première occurrence d'une expression régulière, en commençant à la position de départ spécifiée et en recherchant uniquement le nombre spécifié de caractères.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

Match(String, String)

Recherche dans la chaîne d'entrée spécifiée la première occurrence de l'expression régulière spécifiée.Searches the specified input string for the first occurrence of the specified regular expression.

Match(String, String, RegexOptions)

Recherche dans la chaîne d'entrée la première occurrence de l'expression régulière spécifiée, en utilisant les options de correspondance spécifiées.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

Match(String, String, RegexOptions, TimeSpan)

Recherche dans la chaîne d'entrée la première occurrence de l'expression régulière spécifiée, en utilisant les options de correspondance et l'intervalle de délai d'attente spécifiés.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

Matches(String)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière.Searches the specified input string for all occurrences of a regular expression.

Matches(String, Int32)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière, en commençant à la position de démarrage spécifiée dans la chaîne.Searches the specified input string for all occurrences of a regular expression, beginning at the specified starting position in the string.

Matches(String, String)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière spécifiée.Searches the specified input string for all occurrences of a specified regular expression.

Matches(String, String, RegexOptions)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière spécifique, en utilisant les options de correspondance spécifiées.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options.

Matches(String, String, RegexOptions, TimeSpan)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière spécifiée, en utilisant les options de correspondance et l'intervalle de délai d'attente spécifiés.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options and time-out interval.

MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
Replace(String, MatchEvaluator)

Dans une chaîne d’entrée spécifiée, remplace toutes les chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

Replace(String, MatchEvaluator, Int32)

Dans la chaîne d'entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d'expression régulière par une chaîne retournée par un délégué MatchEvaluator.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

Replace(String, MatchEvaluator, Int32, Int32)

Dans la sous-chaîne d'entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d'expression régulière par une chaîne retournée par un délégué MatchEvaluator.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

Replace(String, String)

Dans une chaîne d’entrée spécifiée, remplace toutes les chaînes qui correspondent à un modèle d’expression régulière par une chaîne de remplacement spécifiée.In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, Int32)

Dans une chaîne d’entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d’expression régulière par une chaîne de remplacement spécifiée.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, Int32, Int32)

Dans une sous-chaîne d’entrée spécifiée, remplace un nombre maximal spécifié de chaînes qui correspondent à un modèle d’expression régulière par une chaîne de remplacement spécifiée.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, MatchEvaluator)

Dans une chaîne d’entrée spécifiée, remplace toutes les chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

Replace(String, String, MatchEvaluator, RegexOptions)

Dans une chaîne d’entrée spécifiée, remplace toutes les chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Les options spécifiées modifient l'opération correspondante.Specified options modify the matching operation.

Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)

Dans la chaîne d’entrée spécifiée, remplace toutes les sous-chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Replace(String, String, String)

Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à l'expression régulière spécifiée par une chaîne de remplacement spécifiée.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

Replace(String, String, String, RegexOptions)

Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à l'expression régulière spécifiée par une chaîne de remplacement spécifiée.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Les options spécifiées modifient l'opération correspondante.Specified options modify the matching operation.

Replace(String, String, String, RegexOptions, TimeSpan)

Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à l'expression régulière spécifiée par une chaîne de remplacement spécifiée.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Split(String)

Fractionne une chaîne d'entrée en un tableau de sous-chaînes, aux positions définies par un modèle d'expression régulière spécifié dans le constructeur Regex.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

Split(String, Int32)

Fractionne une chaîne d'entrée spécifiée un nombre de fois maximal spécifié en un tableau de sous-chaînes, aux positions définies par une expression régulière spécifiée dans le constructeur Regex.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

Split(String, Int32, Int32)

Fractionne une chaîne d'entrée spécifiée un nombre de fois maximal spécifié en un tableau de sous-chaînes, aux positions définies par une expression régulière spécifiée dans le constructeur Regex.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. La recherche du modèle d’expression régulière débute à une position de caractère spécifiée dans la chaîne d’entrée.The search for the regular expression pattern starts at a specified character position in the input string.

Split(String, String)

Fractionne une chaîne d’entrée en tableau de sous-chaînes aux positions définies par un modèle d’expression régulière.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

Split(String, String, RegexOptions)

Fractionne une chaîne d’entrée en tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Les options spécifiées modifient l'opération correspondante.Specified options modify the matching operation.

Split(String, String, RegexOptions, TimeSpan)

Fractionne une chaîne d’entrée en tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

ToString()

Retourne le modèle d'expression régulière qui a été passé au constructeur Regex.Returns the regular expression pattern that was passed into the Regex constructor.

Unescape(String)

Convertit les caractères d'échappement dans la chaîne d'entrée.Converts any escaped characters in the input string.

UseOptionC()

RegexUtilisé par un objet généré par la méthode CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

UseOptionR()

RegexUtilisé par un objet généré par la méthode CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

ValidateMatchTimeout(TimeSpan)

Vérifie si un intervalle de délai d'attente est compris dans une plage acceptable.Checks whether a time-out interval is within an acceptable range.

Implémentations d’interfaces explicites

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Remplit un objet SerializationInfo avec les données nécessaires pour désérialiser l'objet Regex actuel.Populates a SerializationInfo object with the data necessary to deserialize the current Regex object.

S’applique à

Cohérence de thread

La classe Regex est immuable (lecture seule) et thread-safe.The Regex class is immutable (read-only) and thread safe. les objets Regex peuvent être créés sur n’importe quel thread et partagés entre les threads.Regex objects can be created on any thread and shared between threads. Pour plus d’informations, consultez sécurité des threads.For more information, see Thread Safety.

Voir aussi