Classe System.Text.RegularExpressions.Regex

Cet article vous offre des remarques complémentaires à la documentation de référence pour cette API.

La Regex classe représente . Moteur d’expression régulière de NET. Vous pouvez utiliser cette classe pour :

• Analysez rapidement de grandes quantités de texte pour rechercher des modèles de caractères spécifiques.
• Extraire, modifier, remplacer ou supprimer des sous-chaînes de texte.
• Ajoutez les chaînes extraites à une collection pour générer un rapport.

Remarque

Si vous souhaitez valider une chaîne en déterminant si elle est conforme à un modèle d’expression régulière spécifique, vous pouvez utiliser la System.Configuration.RegexStringValidator classe.

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 le langage d’expression régulière - référence rapide. Ensuite, vous pouvez instancier un Regex objet. Enfin, vous appelez une méthode qui effectue une opération, telle que le remplacement du texte qui correspond au modèle d’expression régulière ou l’identification d’une correspondance de modèle.

Pour plus d’informations sur le langage d’expression régulière, consultez la langue de l’expression régulière : référence rapide ou téléchargement et impression de l’une des brochures suivantes :

Informations de référence rapide au formatWord (.docx) au format PDF (.pdf)

Regex et méthodes String

La System.String classe comprend plusieurs méthodes de recherche et de comparaison que vous pouvez utiliser pour effectuer des correspondances de modèles avec du texte. Par exemple, les méthodes et les String.Containsméthodes String.EndsWithdéterminent si une instance de chaîne contient une sous-chaîne spécifiée ; et les String.IndexOfméthodes String.IndexOfAny, String.LastIndexOfet String.LastIndexOfAny retournent la position de départ d’une sous-chaîne spécifiée String.StartsWith dans une chaîne. Utilisez les méthodes de la System.String classe lorsque vous recherchez une chaîne spécifique. Utilisez la Regex classe lorsque vous recherchez un modèle spécifique dans une chaîne. Pour plus d’informations et d’exemples, consultez expressions régulières .NET.

Méthodes statiques et d’instance

Après avoir défini un modèle d’expression régulière, vous pouvez le fournir au moteur d’expression régulière de deux façons :

• En instanciant un Regex objet qui représente l’expression régulière. Pour ce faire, vous passez le modèle d’expression régulière à un Regex constructeur. Un Regex objet est immuable ; lorsque vous instanciez un Regex objet avec une expression régulière, l’expression régulière de cet objet ne peut pas être modifiée.

• En fournissant à la fois l’expression régulière et le texte à rechercher dans une static méthode (Shareden Visual Basic). Regex Cela vous permet d’utiliser une expression régulière sans créer explicitement d’objet Regex .

Toutes les Regex méthodes d’identification de modèle incluent des surcharges statiques et d’instance.

Le moteur d’expression régulière doit compiler un modèle particulier avant que le modèle puisse être utilisé. Étant donné que Regex les objets sont immuables, il s’agit d’une procédure ponctuelle qui se produit lorsqu’un Regex constructeur de classe ou une méthode statique est appelé. Pour éliminer la nécessité de 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. Par conséquent, les méthodes de correspondance de modèle d’expression régulière offrent des performances comparables pour les méthodes statiques et d’instance. Toutefois, la mise en cache peut affecter les performances dans les deux cas suivants :

• Lorsque vous utilisez des appels de méthode statique avec un grand nombre d’expressions régulières. Par défaut, le moteur d’expression régulière met en cache les 15 expressions régulières statiques les plus récemment utilisées. Si votre application utilise plus de 15 expressions régulières statiques, certaines expressions régulières doivent être recompilées. Pour éviter cette recompilation, vous pouvez augmenter la Regex.CacheSize propriété.

• Lorsque vous instanciez de nouveaux Regex objets avec des expressions régulières qui ont déjà été compilés. Par exemple, le code suivant définit une expression régulière pour localiser les mots dupliqués dans un flux de texte. Bien que l’exemple utilise une expression régulière unique, il instancie un nouvel Regex objet pour traiter chaque ligne de texte. Cela entraîne la recompilation de l’expression régulière avec chaque itération de la boucle.

  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 unique Regex accessible à tout le code qui l’exige, comme illustré dans l’exemple réécrit suivant.

  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()
  

Effectuer des opérations d’expression régulière

Que vous décidez d’instancier un Regex objet et d’appeler ses méthodes ou d’appeler des méthodes statiques, la Regex classe offre les fonctionnalités de correspondance de modèle suivantes :

• Validation d’une correspondance. Vous appelez la IsMatch méthode pour déterminer si une correspondance est présente.

• Récupération d’une correspondance unique. Vous appelez la Match méthode pour récupérer un Match objet qui représente la première correspondance dans une chaîne ou dans une partie d’une chaîne. Les correspondances suivantes peuvent être récupérées en appelant la Match.NextMatch méthode.

• Récupération de toutes les correspondances. Vous appelez la Matches méthode pour récupérer un System.Text.RegularExpressions.MatchCollection objet qui représente toutes les correspondances trouvées dans une chaîne ou dans une partie d’une chaîne.

• Remplacement du texte mis en correspondance. Vous appelez la méthode pour remplacer le Replace texte mis en correspondance. Le texte de remplacement peut également être défini par une expression régulière. En outre, certaines des Replace méthodes incluent un MatchEvaluator paramètre qui vous permet de définir par programmation le texte de remplacement.

• Création d’un tableau de chaînes formé à partir de parties d’une chaîne d’entrée. Vous appelez la Split méthode pour fractionner une chaîne d’entrée à des positions définies par l’expression régulière.

En plus de ses méthodes de correspondance de modèle, la Regex classe comprend plusieurs méthodes à usage spécial :

• La Escape méthode échappe tous 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.
• La Unescape méthode supprime ces caractères d’échappement.
• La CompileToAssembly méthode crée un assembly qui contient des expressions régulières prédéfinies. .NET contient des exemples de ces assemblys à usage spécial dans l’espace System.Web.RegularExpressions de noms.

Définir une valeur de délai d’attente

.NET prend en charge un langage d’expression régulière complet qui offre une puissance et une flexibilité substantielles dans la mise en correspondance des modèles. Toutefois, la puissance et la flexibilité sont coûteuses : le risque de performances médiocres. Les expressions régulières qui s’exécutent mal sont étonnamment faciles à créer. Dans certains cas, les opérations d’expression régulière qui s’appuient sur un retour arrière excessif peuvent sembler cesser de répondre lorsqu’elles traitent du texte qui correspond presque au modèle d’expression régulière. Pour plus d’informations sur le moteur d’expression régulière .NET, consultez Détails du comportement d’expression régulière. Pour plus d’informations sur le retour arrière excessif, consultez Backtracking.

À compter de .NET Framework 4.5, vous pouvez définir un intervalle de délai d’attente pour les correspondances d’expression régulière afin de limiter le retour arrière excessif. Selon le modèle d’expression régulière et le texte d’entrée, le temps d’exécution peut dépasser l’intervalle de délai d’attente spécifié, mais il ne passe pas plus de temps à effectuer un retour arrière que l’intervalle de délai d’attente spécifié. Si le moteur d’expression régulière expire, il lève une RegexMatchTimeoutException exception. Dans la plupart des cas, cela empêche le moteur d’expression régulière de perdre la puissance de traitement en essayant de faire correspondre le texte qui correspond presque au modèle d’expression régulière. Il peut également indiquer que l’intervalle de délai d’attente a été défini trop bas ou que la charge de la machine actuelle a provoqué une dégradation globale des performances.

La façon dont vous gérez l’exception dépend de la cause de l’exception. Si l’exception se produit parce que l’intervalle de délai d’attente est trop faible ou en raison d’une charge excessive de la machine, vous pouvez augmenter l’intervalle de délai d’attente et réessayer l’opération correspondante. Si l’exception se produit parce que l’expression régulière s’appuie sur un retour arrière excessif, vous pouvez supposer qu’une correspondance n’existe pas et, si vous le souhaitez, vous pouvez consigner des informations qui vous aideront à modifier le modèle d’expression régulière.

Vous pouvez définir un intervalle de délai d’attente en appelant le Regex(String, RegexOptions, TimeSpan) constructeur lorsque vous instanciez un objet d’expression régulière. 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 matchTimeout paramètre. Si vous ne définissez pas explicitement une valeur de délai d’attente, la valeur de délai d’attente par défaut est déterminée comme suit :

• En utilisant la valeur de délai d’attente à l’échelle de l’application, le cas échéant. Définissez la valeur de délai d’attente à l’échelle de l’application en appelant la AppDomain.SetData méthode pour affecter la représentation sous forme de chaîne d’une TimeSpan valeur à la REGEX_DEFAULT_MATCH_TIMEOUT propriété.
• En utilisant la valeur InfiniteMatchTimeout, si aucune valeur de délai d’attente à l’échelle de l’application n’a été définie.

Important

Nous vous recommandons de définir une valeur de délai d’attente dans toutes les opérations de correspondance de modèle d’expression régulière. Pour plus d’informations, consultez Les meilleures pratiques pour les expressions régulières.

Exemples

L’exemple suivant utilise une expression régulière pour vérifier les occurrences répétées de mots dans une chaîne. L'expression régulière \b(?<word>\w+)\s+(\k<word>)\b peut être interprétée comme indiqué dans le tableau suivant.

Modèle	Description
\b	Démarrez la correspondance à une limite de mot.
(?<word>\w+)	Mettre en correspondance un ou plusieurs caractères de mot jusqu’à une limite de mot. Nommez ce groupe wordcapturé .
\s+	Mettre en correspondance un ou plusieurs espaces blancs.
(\k<word>)	Correspond au groupe capturé nommé word.
\b	Mettre en correspondance la limite d'un mot.

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 49 and 53

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 49 and 53

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 approprié pour représenter une valeur monétaire. Dans ce cas, l’expression régulière est générée dynamiquement à partir de la NumberFormatInfo.CurrencyDecimalSeparatorNumberFormatInfo.NegativeSignCurrencyDecimalDigitsNumberFormatInfo.CurrencySymbolNumberFormatInfo.PositiveSign culture en-US. L’expression régulière résultante est ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Cette expression régulière peut être interprétée comme indiqué dans le tableau suivant.

Modèle	Description
^	Commencez au début de la chaîne.
\s*	Correspond à zéro, un ou plusieurs espaces blancs.
[\+-]?	Mettre en correspondance zéro ou une occurrence du signe positif ou du signe négatif.
\s?	Mettre en correspondance zéro ou un espace blanc.
\$?	Mettre en correspondance zéro ou une occurrence du signe dollar.
\s?	Mettre en correspondance zéro ou un espace blanc.
\d*	Met en correspondance zéro ou plusieurs chiffres décimaux.
\.?	Mettre en correspondance zéro ou un symbole décimal.
(\d{2})?	Capture du groupe 1 : mettre en correspondance deux chiffres décimaux zéro ou une fois.
(\d*\.?(\d{2})?){1}	Correspond au modèle des chiffres intégraux et fractionnaires séparés par un symbole de virgule décimale exactement une fois.
$	Correspond à la fin de la chaîne.

Dans ce cas, l’expression régulière suppose qu’une chaîne monétaire valide ne contient pas de symboles de séparateur de groupe et qu’elle n’a pas de chiffres fractionnaires ou le nombre de chiffres fractionnaires définis par la propriété de CurrencyDecimalDigits la culture spécifiée.

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

public class Example
{
    public static void Main()
    {
        // Get the en-US NumberFormatInfo object to build the regular 
        // expression pattern dynamically.
        NumberFormatInfo nfi = CultureInfo.GetCultureInfo("en-US").NumberFormat;

        // 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}$";

        Console.WriteLine($"Pattern is {pattern}\n");

        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($"{test} is a currency value.");
            else
                Console.WriteLine($"{test} is not a currency value.");
        }
    }
}
// The example displays the following output:
//       Pattern is ^\s*[\+-]?\s?\$?\s?(\d*\.?(\d{2})?){1}$
//
//       -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 = CultureInfo.GetCultureInfo("en-US").NumberFormat

      ' 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}$"
      
      Console.WriteLine("Pattern is {0}", pattern)
      Console.WriteLine()
      
      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:
'       Pattern is ^\s*[\+-]?\s?\$?\s?(\d*\.?(\d{2})?){1}$
'
'       -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 générée dynamiquement, vous ne savez pas au moment du design si le symbole monétaire, le signe décimal ou les signes positifs et négatifs de la culture spécifiée (en-US dans cet exemple) peuvent être mal interprétés par le moteur d’expression régulière en tant qu’opérateurs de langage d’expression régulière. Pour éviter toute mauvaise interprétation, l’exemple transmet chaque chaîne générée dynamiquement à la Escape méthode.