Regex Regex Regex Regex Class

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
RegexRegexRegexRegex
Dérivé
Attributs
Implémente

Exemples

L’exemple suivant utilise une expression régulière pour rechercher les 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 à une limite de mot.Start the match at a word boundary.
(?<word>\w+) Correspond à un ou plusieurs caractères alphabétiques jusqu'à une limite de mot.Match one or more word characters up to a word boundary. Nommer ce groupe capturé word.Name this captured group word.
\s+ Correspond à un ou plusieurs caractères d’espace blanc.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
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 construite dynamiquement à partir de la NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign, et NumberFormatInfo.PositiveSign propriétés 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 le système actuel du culture est en-US, l’expression régulière qui en résulte 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 le 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.
\.? Mettre en correspondance zéro ou un symbole de virgule décimale.Match zero or one decimal point symbol.
\d{2}? Correspond zéro ou une fois à deux chiffres décimaux.Match two decimal digits zero or one time.
(\d*\.?\d{2}?){1} Mettre en correspondance de chiffres intégraux et fractionnaires séparés par un symbole de virgule décimale au moins une fois.Match the pattern of integral and fractional digits separated by a decimal point symbol at least one time.
$ Correspond à 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 monétaire valide ne contient pas de symboles de séparateur de groupe, et qu’il dispose d’aucun chiffre fractionnaire ou le nombre de chiffres fractionnaires défini par la culture actuelle CurrencyDecimalDigits propriété.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 dans cet exemple est construite dynamiquement, nous ne savons pas au moment du design si le symbole monétaire de la culture actuelle, le signe décimal ou signes positifs et négatifs peuvent être mal interprétées par le moteur d’expression régulière comme régulière 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 empêcher toute mauvaise interprétation, l’exemple passe chaque chaîne générée dynamiquement à la Escape (méthode).To prevent any misinterpretation, the example passes each dynamically generated string to the Escape method.

Remarques

Le Regex classe représente le moteur des expressions régulières 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 d’ajouter les chaînes extraites à une collection pour 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 vous êtes principalement intéressé consiste à valider une chaîne en déterminant s’il est conforme à un modèle particulier, vous pouvez utiliser la System.Configuration.RegexStringValidator classe.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 Regex objet.Next, you can optionally instantiate a Regex object. Enfin, vous appelez une méthode qui effectue une opération, telles que le remplacement de texte qui correspond au modèle d’expression régulière, ou identifier 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 courants d’expressions régulières, consultez exemples d’expressions régulières.For some common regular expression patterns, see Regular Expression Examples. Il existe également un nombre de bibliothèques en ligne des modèles d’expressions régulières, tel que celui à 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 Regex de classe, 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

Vs d’expression régulière. Méthodes StringRegex vs. String Methods

Le System.String classe inclut plusieurs méthodes de comparaison et de recherche que vous pouvez utiliser pour effectuer des critères spéciaux avec le texte.The System.String class includes several search and comparison methods that you can use to perform pattern matching with text. Par exemple, le String.Contains, String.EndsWith, et String.StartsWith méthodes déterminent si une instance de chaîne contient une sous-chaîne spécifiée ; et le String.IndexOf, String.IndexOfAny, String.LastIndexOf, et String.LastIndexOfAny méthodes retournent le démarrage position 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 System.String classe 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 Regex classe 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 des exemples, consultez Expressions régulières .NET Framework.For more information and examples, see .NET Framework Regular Expressions.

Retour sur NotesBack to Remarks

Vs statiques. Méthodes d’instanceStatic vs. Instance Methods

Après avoir défini un modèle d’expression régulière, vous pouvez la fournir au moteur d’expression régulière de deux manières :After you define a regular expression pattern, you can provide it to the regular expression engine in either of two ways:

  • En instanciant un Regex objet qui représente l’expression régulière.By instantiating a Regex object that represents the regular expression. Pour ce faire, vous transmettez le modèle d’expression régulière à un Regex constructeur.To do this, you pass the regular expression pattern to a Regex constructor. Un Regex objet est immuable ; lorsque vous instanciez un Regex de l’objet avec une expression régulière, que l’expression régulière de l’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 l’expression régulière et le texte à rechercher dans un static (Shared en 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 Regex objet.This enables you to use a regular expression without explicitly creating a Regex object.

Tous les Regex méthodes du modèle d’identification incluent à la fois statique et instance surcharges.All Regex pattern identification methods include both static and instance overloads.

Le moteur d’expression régulière doit compiler un modèle particulier avant de pouvoir utiliser le modèle.The regular expression engine must compile a particular pattern before the pattern can be used. Étant donné que Regex objets sont immuables, il s’agit d’une procédure unique qui se produit lorsqu’un Regex constructeur de classe ou une méthode statique est appelée.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 éliminer la nécessité de compiler à plusieurs reprises une expression régulière unique, 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 correspondance d’expression régulière offrent des performances comparables pour statique et les méthodes d’instance.As a result, regular expression pattern-matching methods offer comparable performance for static and instance methods.

Important

Dans les .NET Framework versions 1.0 et 1.1, tout compilé les expressions régulières, s’ils ont été utilisés dans l’instance ou une méthode statique appelle, ont été mis 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. À compter de .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 des fichiers récents expressions régulières statiques 15.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 empêcher cette recompilation, vous pouvez augmenter la Regex.CacheSize propriété.To prevent this recompilation, you can increase the Regex.CacheSize property.

  • Lorsque vous instanciez un nouveau Regex objets avec des expressions régulières 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 des 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 nouveau Regex objet à 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 seul Regex objet qui est accessible à tout le code qui le requiert, comme indiqué 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 sur NotesBack to Remarks

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

Si vous décidez d’instancier un Regex de l’objet et appeler ses méthodes ou appeler des méthodes statiques, le Regex classe offre les fonctionnalités de mise en correspondance de modèle 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 le IsMatch méthode 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 le Match méthode pour récupérer un Match objet qui représente la première correspondance dans une chaîne ou en 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 le Match.NextMatch (méthode).Subsequent matches can be retrieved by calling the Match.NextMatch method.

  • Récupération de toutes les correspondances.Retrieval of all matches. Vous appelez le 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 en 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 de texte correspondant.Replacement of matched text. Vous appelez le Replace méthode 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. En outre, certaines de la Replace méthodes incluent un MatchEvaluator paramètre 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 qui est formée à 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 le Split méthode 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 critères spéciaux, les Regex classe inclut plusieurs méthodes spéciales :In addition to its pattern-matching methods, the Regex class includes several special-purpose methods:

  • Le Escape méthode échappe tous les caractères qui peuvent être interprétés comme 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.

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

  • Le CompileToAssembly méthode 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 le System.Web.RegularExpressions espace de noms.The .NET Framework contains examples of these special-purpose assemblies in the System.Web.RegularExpressions namespace.

Retour sur 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 complet d’expression régulière qui fournit la puissance substantielle et la flexibilité 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 faibles performances.However, the power and flexibility come at a cost: the risk of poor performance. Les expressions régulières médiocres sont étonnamment faciles à créer.Regular expressions that perform poorly are surprisingly easy to create. Dans certains cas, les opérations d’expression régulière qui reposent sur une rétroaction excessive peuvent apparaître à cesser de répondre quand ils traitent le texte correspondant 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 de .NET Framework, consultez détails 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.

En commençant par le .NET Framework 4.5.NET Framework 4.5, vous pouvez définir un intervalle de délai d’attente pour les correspondances d’expression régulière.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 au sein de cet intervalle de temps, l’opération de correspondance lève un RegexMatchTimeoutException exception.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 ne consomme une puissance de traitement en essayant de faire correspondre le texte correspondant 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. Elle également peut indiquer, toutefois, que l’intervalle de délai d’attente a été défini trop faible ou que la charge actuelle de la machine 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.

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 a une valeur trop faible ou en raison de la charge de la machine excessive, vous pouvez augmenter l’intervalle de délai d’attente et recommencez 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 utilise la rétroaction excessive, vous pouvez supposer qu’une correspondance n’existe pas, et, si vous le souhaitez, vous pouvez enregistrer des informations qui vous permettent de 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 Regex(String, RegexOptions, TimeSpan) constructeur lorsque 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 matchTimeout paramètre.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 de délai d’attente par défaut 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:

  • En utilisant le délai d’expiration de l’application la valeur, s’il existe.By using the application-wide time-out value, if one exists. Cela peut être toute valeur de délai d’attente qui s’applique au domaine d’application dans lequel le Regex objet 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 de délai d’attente de l’application en appelant le AppDomain.SetData méthode pour attribuer la représentation sous forme de chaîne d’un TimeSpan valeur à 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.

  • À l’aide de la valeur InfiniteMatchTimeout, si aucune valeur de délai d’attente de l’application 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 sur NotesBack to Remarks

Constructeurs

Regex() Regex() Regex() Regex()

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

Regex(SerializationInfo, StreamingContext) Regex(SerializationInfo, StreamingContext) Regex(SerializationInfo, StreamingContext) 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) Regex(String) Regex(String) 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) Regex(String, RegexOptions) Regex(String, RegexOptions) 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) Regex(String, RegexOptions, TimeSpan) Regex(String, RegexOptions, TimeSpan) 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 capnames capnames capnames

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

caps caps caps caps

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

capsize capsize capsize capsize

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

capslist capslist capslist capslist

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

factory factory factory factory

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

InfiniteMatchTimeout InfiniteMatchTimeout InfiniteMatchTimeout 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 internalMatchTimeout internalMatchTimeout 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 pattern pattern pattern

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

roptions roptions roptions 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 CacheSize CacheSize 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 CapNames CapNames 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 Caps Caps 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 MatchTimeout MatchTimeout MatchTimeout

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

Options Options Options Options

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

RightToLeft RightToLeft RightToLeft 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) CompileToAssembly(RegexCompilationInfo[], AssemblyName) CompileToAssembly(RegexCompilationInfo[], AssemblyName) 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[]) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) 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) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) 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) Equals(Object) Equals(Object) Equals(Object)

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

(Inherited from Object)
Escape(String) Escape(String) Escape(String) 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() Finalize() Finalize() 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() GetGroupNames() GetGroupNames() 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() GetGroupNumbers() GetGroupNumbers() 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() GetHashCode() GetHashCode() GetHashCode()

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

(Inherited from Object)
GetType() GetType() GetType() GetType()

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

(Inherited from Object)
GroupNameFromNumber(Int32) GroupNameFromNumber(Int32) GroupNameFromNumber(Int32) 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) GroupNumberFromName(String) GroupNumberFromName(String) 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() InitializeReferences() InitializeReferences() 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) IsMatch(String) IsMatch(String) 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) IsMatch(String, Int32) IsMatch(String, Int32) 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) IsMatch(String, String) IsMatch(String, 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) IsMatch(String, String, RegexOptions) IsMatch(String, String, RegexOptions) 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) IsMatch(String, String, RegexOptions, TimeSpan) IsMatch(String, String, RegexOptions, TimeSpan) 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) Match(String) Match(String) 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) Match(String, Int32) Match(String, Int32) 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) Match(String, Int32, Int32) Match(String, Int32, Int32) 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) Match(String, String) Match(String, String) 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) Match(String, String, RegexOptions) Match(String, String, RegexOptions) 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) Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan) 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) Matches(String) Matches(String) 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) Matches(String, Int32) Matches(String, Int32) 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) Matches(String, String) Matches(String, 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) Matches(String, String, RegexOptions) Matches(String, String, RegexOptions) 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) Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan) 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() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
Replace(String, MatchEvaluator) Replace(String, MatchEvaluator) Replace(String, MatchEvaluator) 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) Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32) 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) Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32) 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) Replace(String, String) Replace(String, String) 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) Replace(String, String, Int32) Replace(String, String, Int32) 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) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) 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) Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator) 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) Replace(String, String, MatchEvaluator, RegexOptions) Replace(String, String, MatchEvaluator, RegexOptions) 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) Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan) Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan) 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) Replace(String, String, String) Replace(String, String, String) 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) Replace(String, String, String, RegexOptions) Replace(String, String, String, RegexOptions) 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) Replace(String, String, String, RegexOptions, TimeSpan) Replace(String, String, String, RegexOptions, TimeSpan) 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) Split(String) Split(String) 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) Split(String, Int32) Split(String, Int32) 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) Split(String, Int32, Int32) Split(String, Int32, Int32) 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) Split(String, String) Split(String, 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) Split(String, String, RegexOptions) Split(String, String, RegexOptions) 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) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) 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() ToString() ToString() 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) Unescape(String) Unescape(String) Unescape(String)

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

UseOptionC() UseOptionC() UseOptionC() UseOptionC()

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

UseOptionR() UseOptionR() UseOptionR() 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) ValidateMatchTimeout(TimeSpan) ValidateMatchTimeout(TimeSpan) 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) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) 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

Le Regex classe est immuable (en lecture seule) et thread-safe.The Regex class is immutable (read-only) and thread safe. Regex objets peuvent être créées sur n’importe quel thread et partagés par plusieurs 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