Regex Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Représente une expression régulière immuable.
public ref class Regexpublic ref class Regex : System::Runtime::Serialization::ISerializablepublic class Regexpublic class Regex : System.Runtime.Serialization.ISerializable[System.Serializable]
public class Regex : System.Runtime.Serialization.ISerializabletype Regex = classtype Regex = class
interface ISerializable[<System.Serializable>]
type Regex = class
interface ISerializablePublic Class RegexPublic Class Regex
Implements ISerializable- Héritage
-
Regex
- Dérivé
- Attributs
- Implémente
Exemples
L’exemple suivant utilise une expression régulière pour case activée pour 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 mots. |
(?<word>\w+) |
Faire correspondre 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.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 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 case activée 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 des NumberFormatInfo.CurrencyDecimalSeparatorpropriétés , CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSignet NumberFormatInfo.PositiveSign pour la 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 : faire correspondre deux chiffres décimaux zéro ou une fois. |
(\d*\.?(\d{2})?){1} |
Correspond au modèle de chiffres intégraux et fractionnaires séparés par un symbole décimal au moins 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 dans cet exemple est générée dynamiquement, vous ne savez pas au moment de la conception 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 erreur d’interprétation, l’exemple passe chaque chaîne générée dynamiquement à la Escape méthode.
Remarques
La Regex classe représente le moteur d’expression régulière du .NET Framework. Il peut être utilisé pour analyser rapidement de grandes quantités de texte afin de trouver 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 pour générer un rapport.
Notes
Si votre principal intérêt est de valider une chaîne en déterminant si elle est conforme à un modèle particulier, 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 Regular Expression Language - Quick Reference. Ensuite, vous pouvez éventuellement instancier un Regex objet. Enfin, vous appelez une méthode qui effectue une opération, telle que le remplacement du texte correspondant au modèle d’expression régulière ou l’identification d’une correspondance de modèle.
Notes
Pour obtenir certains modèles d’expression régulière courants, consultez Exemples d’expressions régulières. Il existe également un certain nombre de bibliothèques en ligne de modèles d’expression régulière, comme celle de Regular-Expressions.info.
Pour plus d’informations sur l’utilisation de la Regex classe, consultez les sections suivantes de cette rubrique :
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 :
Aide-mémoire au format Word (.docx)
Aide-mémoire au format PDF (.pdf)
Méthodes Regex et String
La System.String classe comprend plusieurs méthodes de recherche et de comparaison que vous pouvez utiliser pour effectuer une correspondance de modèle avec du texte. Par exemple, les String.Containsméthodes , String.EndsWithet String.StartsWith déterminent si une chaîne instance 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 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’expressions régulières de deux manières :
Instanciation d’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
staticmé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 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 à usage unique 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èles d’expression régulière offrent des performances comparables pour les méthodes statiques et instance.
Important
Dans les versions 1.0 et 1.1 du .NET Framework, toutes les expressions régulières compilées, qu’elles soient utilisées dans des appels de méthode instance ou statique, ont été mises en cache. À 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.
Toutefois, la mise en cache peut nuire aux 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’expressions régulières met en cache les 15 dernières expressions régulières statiques utilisées. Si votre application utilise plus de 15 expressions régulières statiques, certaines expressions régulières doivent être recompilées. Pour empêcher 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 été compilées précédemment. 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 seule expression régulière, 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 en a besoin, 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()
Exécution d’opérations d’expression régulière
Que vous décidiez 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 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 correspondant. Vous appelez la méthode pour remplacer le Replace texte correspondant. Le texte de remplacement peut également être défini par une expression régulière. En outre, certaines méthodes Replace 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 aux positions définies par l’expression régulière.
En plus de ses méthodes de correspondance de modèle, la Regex classe inclut 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. Le .NET Framework contient des exemples de ces assemblys à usage spécial dans l’espace de System.Web.RegularExpressions noms .
Définition d’une valeur Time-Out
.NET prend en charge un langage d’expression régulière complet qui offre une puissance et une flexibilité substantielles dans la correspondance des modèles. Toutefois, la puissance et la flexibilité ont un coût : le risque de performances médiocres. Les expressions régulières qui fonctionnent 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 des expressions régulières. Pour plus d’informations sur la rétroaction excessive, consultez Backtracking.
À compter de .NET Framework 4.5, vous pouvez définir un intervalle de délai d’attente pour les correspondances d’expressions régulières afin de limiter les retours excessifs. 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 une rétroaction 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 gaspiller la puissance de traitement en essayant de faire correspondre du texte qui correspond presque au modèle d’expression régulière. Cela peut également indiquer, toutefois, que l’intervalle de délai d’attente a été défini trop bas ou que la charge actuelle de l’ordinateur 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 défini trop bas 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 correspondante. 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.
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. 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 dans lequel l’appel de méthode statique est effectué. Vous pouvez définir la valeur de délai d’attente à l’échelle de l’application en appelant la méthode AppDomain.SetData pour attribuer la représentation sous forme de chaîne d’une valeur TimeSpan à la propriété « REGEX_DEFAULT_MATCH_TIMEOUT ».
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 Meilleures pratiques pour les expressions régulières.
Constructeurs
| Regex() |
Initialise une nouvelle instance de la classe Regex. |
| Regex(SerializationInfo, StreamingContext) |
Obsolète.
Initialise une nouvelle instance de la classe Regex à l'aide de données sérialisées. |
| Regex(String) |
Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée. |
| Regex(String, RegexOptions) |
Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée, avec des options qui modifient le modèle. |
| Regex(String, RegexOptions, TimeSpan) |
Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée, avec les options qui modifient le modèle et une valeur qui spécifie la durée pendant laquelle une méthode de modèle doit tenter une correspondance avant son expiration. |
Champs
| capnames |
Utilisé par un objet Regex généré par la méthode CompileToAssembly. |
| caps |
Utilisé par un objet Regex généré par la méthode CompileToAssembly. |
| capsize |
Utilisé par un objet Regex généré par la méthode CompileToAssembly. |
| capslist |
Utilisé par un objet Regex généré par la méthode CompileToAssembly. |
| factory |
Utilisé par un objet Regex généré par la méthode CompileToAssembly. |
| InfiniteMatchTimeout |
Spécifie qu’une opération de critères spéciaux ne doit pas expirer. |
| internalMatchTimeout |
Durée maximale pouvant s’écouler lors d’une opération de correspondance de modèle avant que l’opération expire. |
| pattern |
Utilisé par un objet Regex généré par la méthode CompileToAssembly. |
| roptions |
Utilisé par un objet Regex généré par la méthode CompileToAssembly. |
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. |
| CapNames |
Obtient ou définit un dictionnaire qui mappe des groupes de capture nommés à leurs valeurs d’index. |
| Caps |
Obtient ou définit un dictionnaire qui mappe des groupes de capture numérotés à leurs valeurs d’index. |
| MatchTimeout |
Obtient l'intervalle du délai d'attente de l'instance actuelle. |
| Options |
Obtient les options passées dans le constructeur Regex. |
| RightToLeft |
Obtient une valeur qui indique si l'expression régulière cherche de droite à gauche. |
Méthodes
| CompileToAssembly(RegexCompilationInfo[], AssemblyName) |
Obsolète.
Compile un ou plusieurs objets Regex spécifiés dans un assembly nommé. |
| CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) |
Obsolète.
Compile un ou plusieurs objets Regex spécifiés dans un assembly nommé avec les attributs spécifiés. |
| CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) |
Obsolète.
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. |
| Count(ReadOnlySpan<Char>) |
Recherche dans une étendue d’entrée toutes les occurrences d’une expression régulière et retourne le nombre de correspondances. |
| Count(ReadOnlySpan<Char>, Int32) |
Recherche dans une étendue d’entrée toutes les occurrences d’une expression régulière et retourne le nombre de correspondances. |
| Count(ReadOnlySpan<Char>, String) |
Recherche dans une étendue d’entrée toutes les occurrences d’une expression régulière et retourne le nombre de correspondances. |
| Count(ReadOnlySpan<Char>, String, RegexOptions) |
Recherche dans une étendue d’entrée toutes les occurrences d’une expression régulière et retourne le nombre de correspondances. |
| Count(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan) |
Recherche dans une étendue d’entrée toutes les occurrences d’une expression régulière et retourne le nombre de correspondances. |
| Count(String) |
Recherche toutes les occurrences d’une expression régulière dans une chaîne d’entrée et retourne le nombre de correspondances. |
| Count(String, String) |
Recherche toutes les occurrences d’une expression régulière dans une chaîne d’entrée et retourne le nombre de correspondances. |
| Count(String, String, RegexOptions) |
Recherche toutes les occurrences d’une expression régulière dans une chaîne d’entrée et retourne le nombre de correspondances. |
| Count(String, String, RegexOptions, TimeSpan) |
Recherche toutes les occurrences d’une expression régulière dans une chaîne d’entrée et retourne le nombre de correspondances. |
| EnumerateMatches(ReadOnlySpan<Char>) |
Recherche dans une étendue d’entrée toutes les occurrences d’une expression régulière et retourne un Regex.ValueMatchEnumerator pour itérer sur les correspondances. |
| EnumerateMatches(ReadOnlySpan<Char>, Int32) |
Recherche dans une étendue d’entrée toutes les occurrences d’une expression régulière et retourne un Regex.ValueMatchEnumerator pour itérer sur les correspondances. |
| EnumerateMatches(ReadOnlySpan<Char>, String) |
Recherche dans une étendue d’entrée toutes les occurrences d’une expression régulière et retourne un Regex.ValueMatchEnumerator pour itérer sur les correspondances. |
| EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions) |
Recherche dans une étendue d’entrée toutes les occurrences d’une expression régulière et retourne un Regex.ValueMatchEnumerator pour itérer sur les correspondances. |
| EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan) |
Recherche dans une étendue d’entrée toutes les occurrences d’une expression régulière et retourne un Regex.ValueMatchEnumerator pour itérer sur les correspondances. |
| Equals(Object) |
Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object) |
| Escape(String) |
Échappe un jeu minimal de caractères (\, *, +, ?, |, {, [, (,), ^, $, ., #et espace blanc) en les remplaçant par leurs codes d’échappement. 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. |
| Finalize() |
Ce membre substitue Finalize(). Une documentation plus complète est peut-être disponible dans cette rubrique. 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. |
| GetGroupNames() |
Retourne un tableau de noms de groupes de captures pour l'expression régulière. |
| GetGroupNumbers() |
Retourne un tableau des numéros de groupes de captures qui correspondent aux noms de groupes d'un tableau. |
| GetHashCode() |
Fait office de fonction de hachage par défaut. (Hérité de Object) |
| GetType() |
Obtient le Type de l'instance actuelle. (Hérité de Object) |
| GroupNameFromNumber(Int32) |
Obtient le nom de groupe qui correspond au numéro de groupe spécifié. |
| GroupNumberFromName(String) |
Retourne le numéro de groupe qui correspond au nom de groupe spécifié. |
| InitializeReferences() |
Obsolète.
Utilisé par un objet Regex généré par la méthode CompileToAssembly. |
| IsMatch(ReadOnlySpan<Char>) |
Indique si l’expression régulière spécifiée dans le constructeur Regex trouve une correspondance dans une étendue d’entrée spécifiée. |
| IsMatch(ReadOnlySpan<Char>, Int32) |
Indique si l’expression régulière spécifiée dans le constructeur Regex trouve une correspondance dans une étendue d’entrée spécifiée. |
| IsMatch(ReadOnlySpan<Char>, String) |
Indique si l’expression régulière spécifiée trouve une correspondance dans l’étendue d’entrée spécifiée. |
| IsMatch(ReadOnlySpan<Char>, String, RegexOptions) |
Indique si l’expression régulière spécifiée trouve une correspondance dans l’étendue d’entrée spécifiée, à l’aide des options de correspondance spécifiées. |
| IsMatch(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan) |
Indique si l’expression régulière spécifiée trouve une correspondance dans l’étendue d’entrée spécifiée, à l’aide des options de correspondance et de l’intervalle de délai d’attente spécifiés. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| Matches(String) |
Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière. |
| 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. |
| 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. |
| 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. |
| 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. |
| MemberwiseClone() |
Crée une copie superficielle du Object actuel. (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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. Les options spécifiées modifient l'opération correspondante. |
| 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. 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. |
| 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. |
| 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. Les options spécifiées modifient l'opération correspondante. |
| 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. 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. |
| 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. |
| 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. |
| 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. 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. |
| 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. |
| 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é. Les options spécifiées modifient l'opération correspondante. |
| 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é. 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. |
| ToString() |
Retourne le modèle d'expression régulière qui a été passé au constructeur |
| Unescape(String) |
Convertit les caractères d'échappement dans la chaîne d'entrée. |
| UseOptionC() |
Obsolète.
Utilisé par un objet Regex généré par la méthode CompileToAssembly. |
| UseOptionR() |
Obsolète.
Utilisé par un objet Regex généré par la méthode CompileToAssembly. |
| ValidateMatchTimeout(TimeSpan) |
Vérifie si un intervalle de délai d'attente est compris dans une plage acceptable. |
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. |
S’applique à
Cohérence de thread
La Regex classe est immuable (lecture seule) et thread-safe. Regex Les objets peuvent être créés sur n’importe quel thread et partagés entre les threads. Pour plus d’informations, consultez Sécurité des threads.