C# Expression régulière
Expression régulièreIl s'agit d'une formule de recherche utilisée pour décrire et faire correspondre des modèles de texte. En termes simples, vous pouvez la comprendre comme un langage de caractères génériques spécial utilisé pour trouver, valider ou remplacer précisément du contenu dans des chaînes de caractères.
Par exemple, si vous voulez déterminer si l'entrée utilisateur est une adresse e-mail ou un numéro de téléphone valide, ou extraire toutes les dates d'un texte—ce sont des cas d'utilisation typiques des expressions régulières.
Le framework .NET dispose d'un moteur d'expressions régulières intégré et complet, viaSystem.Text.RegularExpressionsL'espace de noms fournit la prise en charge.
Un motif d'expression régulière se compose d'un ou plusieurs caractères, opérateurs et structures qui décrivent ensemble les règles textuelles à mettre en correspondance.
Si vous ne maîtrisez pas encore les expressions régulières, vous pouvez d'abord lire notreTutoriel sur les expressions régulières。
Définir une expression régulière
Les expressions régulières sont composées des types de briques de base suivants, chacun responsable de différentes fonctions de correspondance :
- Échappement de caractère: traiter les caractères spéciaux comme des caractères ordinaires (par ex.,
\.correspond à un point littéral) - classe de caractères: correspond à un « certain type » de caractère (par ex.
\dcorrespond à n'importe quel chiffre) - Point d'ancrage: spécifie la « position » où la correspondance se produit (par ex.
^représente le début d'une ligne) - Construction de regroupement: regrouper les sous-modèles pour faciliter la capture ou la référence
- Quantificateurs: contrôlent le nombre de fois qu'un élément apparaît (p. ex.
+indique une ou plusieurs fois) - Construction de rétroréférence: référencer un contenu précédemment capturé pour une nouvelle correspondance
- Construction d'alternance: implémente la logique "ou" (p. ex.
cat|dog) - replace: référence le contenu capturé dans les opérations de remplacement
- Construction diverse: fonctions auxiliaires telles que les options en ligne, les commentaires, etc.
Échappement de caractère
Dans les expressions régulières, le caractère barre oblique inverse (\) a deux fonctions : premièrement, il échappe ce qui suitLes caractères ordinaires prennent un sens spécial(comme\nreprésente un saut de ligne), et deuxièmement, il transformeLes caractères spéciaux sont échappés en caractères littéraux(comme\.correspond à un point réel au lieu de "n'importe quel caractère").
Idée fausse courante chez les débutants : dans les chaînes C#,\est lui-même un caractère d'échappement, donc pour écrire dans une regex\d, dans les chaînes C#, vous devez écrire"\\d", ou utiliser une chaîne verbatim@"\d"(Recommandé).
Le tableau suivant répertorie les caractères d'échappement courants :
| Caractères d'échappement | Description | Mode | correspondance |
|---|---|---|---|
| \a | Correspond au caractère d'alarme (sonnerie) \u0007. | \a | Le "\u0007" dans "Warning!" + '\u0007' |
| \b | Dans les classes de caractères, correspond à la touche retour arrière \u0008. (Remarque : en dehors des classes de caractères, \b représente une limite de mot, voir la section "Ancres") | [\b]{3,} | "\b\b\b\b" dans "\b\b\b\b" |
| \t | Correspond au caractère de tabulation \u0009. Couramment utilisé pour correspondre à du texte séparé par des tabulations. | (\w+)\t | Les "Name\t" et "Addr\t" dans "Name\tAddr\t" |
| \r | Correspond au retour chariot \u000D. (\r n'est pas équivalent au saut de ligne \n. Les sauts de ligne Windows sont généralement \r\n) | \r\n(\w+) | "\r\nHello" dans "\r\nHello\nWorld." |
| \v | Correspond à la tabulation verticale \u000B. | [\v]{2,} | "\v\v\v" dans "\v\v\v" |
| \f | Correspond au saut de page \u000C. | [\f]{2,} | "\f\f\f" dans "\f\f\f" |
| \n | Correspond au saut de ligne \u000A. Les fins de ligne Unix/Linux n'ont généralement que \n. | \r\n(\w+) | "\r\nHello" dans "\r\nHello\nWorld." |
| \e | Correspond au caractère d'échappement \u001B. | \e | "\x001B" dans "\x001B" |
| \ nnn | Spécifie un caractère à l'aide d'une représentation octale (nnn comporte deux ou trois chiffres). | \w\040\w | "a b" et "c d" dans "a bc d" |
| \x nn | Spécifie un caractère à l'aide d'une représentation hexadécimale (nn comporte exactement deux chiffres). | \w\x20\w | "a b" et "c d" dans "a bc d" |
| \c X \c x | Correspond au caractère de contrôle ASCII spécifié par X ou x, où X ou x est la lettre du caractère de contrôle. | \cC | Le "\x0003" à l'intérieur de "\x0003" (Ctrl-C) |
| \u nnnn | Correspond à un caractère Unicode à l'aide d'une représentation hexadécimale (quatre chiffres représentés par nnnn). | \w\u0020\w | "a b" et "c d" dans "a bc d" |
| \ | Lorsqu'il est suivi d'un caractère d'échappement non reconnu, il correspond à ce caractère. | \d+[\+-x\*]\d+\d+[\+-x\*\d+ | Le "2+2" et "3*9" dans "(2+2) * 3*9" |
classe de caractères
Les classes de caractères sont utilisées pour faire correspondre un caractère parmi "un certain type" de caractèresN'importe lequel. Par exemple[aeiou]correspond à n'importe quelle voyelle,\dCorrespond à un seul chiffre. Il s'agit de l'une des fonctions de base les plus couramment utilisées dans les expressions régulières.
Le tableau suivant répertorie les classes de caractères :
| classe de caractères | Description | Mode | correspondance |
|---|---|---|---|
| [character_group] | Correspond à tout caractère unique dans character_group. Par défaut, la correspondance respecte la casse. | [mn] | le 'm' dans 'mat', le 'm' et le 'n' dans 'moon' |
| [^character_group] | Négation : correspond à tout caractère unique qui ne se trouve pas dans character_group. Par défaut, les caractères dans character_group respectent la casse. | [^aei] | "v" et "l" dans "avail" |
| [ first - last ] | Plage de caractères : correspond à un seul caractère dans la plage allant du premier au dernier. | [b-d] | [b-d]irds peut correspondre à Birds, Cirds, Dirds |
| . | Joker : correspond à un seul caractère sauf \n. Pour correspondre à un caractère point littéral (. ou \u002E), vous devez le précéder d'un caractère d'échappement (\.). | a.e | "ave" dans "have", "ate" dans "mate" |
| \p{ name } | etnameCorrespond à n'importe quel caractère unique dans la catégorie générale Unicode spécifiée ou le bloc nommé. | \p{Lu} | "C" et "L" dans "City Lights" |
| \P{ name } | et non dansnameCorrespond à n'importe quel caractère unique dans la catégorie générale Unicode spécifiée ou le bloc nommé. | \P{Lu} | "i", "t" et "y" dans "City" |
| \w | Correspond à tout caractère de mot (lettres, chiffres, trait de soulignement). Équivalent à [a-zA-Z0-9_] (dans la plage ASCII). | \w | Les "R", "o", "m" et "1" dans "Room#1" |
| \W | Correspond à tout caractère non-mot. C'est la négation de \w. | \W | "#" dans "Room#1" |
| \s | Correspond à tout caractère d'espacement (espace, tabulation, saut de ligne, etc.). | \w\s | Le "D " dans "ID A1.3" |
| \S | Correspond à tout caractère non blanc. C'est la négation de \s. | \s\S | " _" dans "int __ctr" |
| \d | Correspond à tout chiffre décimal. Équivalent à [0-9]. | \d | "4" dans "4 = IV" |
| \D | Correspond à tout caractère qui n'est pas un chiffre décimal. C'est la négation de \d. | \D | Les " ", "=", " ", "I" et "V" dans "4 = IV" |
Point d'ancrage
Les ancres (aussi appelées « ancres ») ne correspondent à aucun caractère spécifique, mais correspondent à une certaine position dans la chaîne.Position. Elles sont de « largeur nulle », ne consomment aucun caractère, elles affirment simplement que la position actuelle satisfait une certaine condition.
Par exemple^\d{3}signifie « trois chiffres au début de la chaîne »,\bsignifie « frontière entre caractères de mot et caractères non-mot ».
Le tableau suivant répertorie les ancres :
| Assertion | Description | Mode | correspondance |
|---|---|---|---|
| ^ | La correspondance doit commencer au début de la chaîne ou de la ligne. | ^\d{3} | "567" dans "567-777-" |
| $ | La correspondance doit apparaître à la fin de la chaîne, ou avant le\navant. | -\d{4}$ | "-2012" dans "8-12-2012" |
| \A | La correspondance doit apparaître au début de la chaîne (non affecté par le mode multiligne ; toujours le tout début de la chaîne entière). | \A\w{4} | "Code" dans "Code-007-" |
| \Z | La correspondance doit apparaître à la fin de la chaîne, ou avant le\navant. | -\d{3}\Z | "-007" dans "Bond-901-007" |
| \z | La correspondance doit apparaître à la fin de la chaîne (fin stricte, aucun \n autorisé à la fin). | -\d{3}\z | "-333" dans "-901-333" |
| \G | La correspondance doit apparaître là où la correspondance précédente s'est terminée. Couramment utilisé dans les scénarios de correspondance consécutive. | \G\(\d\) | "(1)", "(3)" et "(5)" dans "(1)(3)(5)[7](9)" |
| \b | Correspond à une limite de mot, c'est-à-dire la position entre un mot et un espace. | er\b | Correspond à "er" dans "never", mais ne peut pas correspondre à "er" dans "verb". |
| \B | Correspond à une limite de non-mot. | er\B | Correspond à "er" dans "verb", mais ne peut pas correspondre à "er" dans "never". |
Construction de regroupement
Les constructions de regroupement utilisent des parenthèses( )Enfermer une partie de l'expression régulière pour former une sous-expression. Le regroupement a deux objectifs principaux :
- capture: « sauvegarder » la sous-chaîne correspondante pour une extraction ou une référence ultérieure dans le remplacement.
- Restriction de portée: permettre aux quantificateurs ou aux constructions d'alternance de ne s'appliquer qu'à la sous-expression du groupe.
Cette partie est relativement difficile à comprendre ; vous pouvez lireExpression régulière - Sélection 、Assertions de prévision et de rétrovision dans les expressions régulièresFacilite la compréhension.
Le tableau suivant répertorie les constructions de regroupement :
| Construction de regroupement | Description | Mode | correspondance |
|---|---|---|---|
| ( subexpression ) | Capture la sous-expression correspondante et lui attribue un numéro d'ordre basé sur zéro. | (\w)\1 | "ee" dans "deep" |
| (?< name >subexpression) | Capture la sous-expression correspondante dans un groupe nommé. Les groupes nommés sont plus lisibles que la numérotation numérique et sont recommandés pour une utilisation dans des expressions régulières complexes. | (?< double>\w)\k< double> | "ee" dans "deep" |
| (?< name1 -name2 >subexpression) | Définit une définition de groupe d'équilibrage. Utilisé pour faire correspondre des structures imbriquées (comme des parenthèses appariées), une fonctionnalité avancée. | (((?'Open'\()[^\(\)]*)+((?'Close-Open'\))[^\(\)]*)+)*(?(Open)(?!))$ | "((1-3)*(3-1))" dans "3+2^((1-3)*(3-1))" |
| (?: subexpression) | Définit un groupe de non-capture. Utilisé lorsque seul un regroupement (limitation de portée) est nécessaire sans enregistrer le contenu correspondant ; les performances sont légèrement meilleures que celles des groupes de capture. | Write(?:Line)? | Le "WriteLine" dans "Console.WriteLine()" |
| (?imnsx-imnsx:subexpression) | Appliquer ou désactiver les options spécifiées danssubexpression. | A\d{2}(?i:\w+)\b | "A12xl" et "A12XL" dans "A12xl A12XL a12xl" |
| (?= sous-expression) | Assertion de préanalyse positive de largeur nulle. Correspond à une position qui est suivie par une sous-expression, mais ne consomme pas de caractères. | \w+(?=\.) | "He is. The dog ran. The sun is out." dans "is", "ran" et "out" |
| (?! sous-expression) | Assertion de préanalyse négative de largeur nulle. Correspond à une position qui n'est pas suivie par une sous-expression. | \b(?!un)\w+\b | "sure" et "used" dans "unsure sure unity used" |
| (?<=sous-expression) | Assertion de post-analyse positive de largeur nulle. Correspond à une position qui est immédiatement précédée par une sous-expression. | (?<=19)\d{2}\b | "99", "50", et "05" dans "1851 1999 1950 1905 2003" |
| (?<! sous-expression) | Assertion de lookbehind négative de largeur nulle. Correspond à une position non précédée par la sous-expression. | (?<!wo)man\b | "man" dans "Hi woman Hi man" |
| (?> subexpression) | Sous-expression sans retour arrière (groupe atomique). Une fois qu'elle correspond, aucun retour arrière n'est autorisé, ce qui peut améliorer les performances dans certains scénarios. | [13579](?>A+B+) | "1ABB", "3ABB" et "5AB" dans "1ABB 3ABBC 5AB 5AC" |
Exemple
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "1851 1999 1950 1905 2003";
string pattern = @"(?<=19)\d{2}\b";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
Qualificateurs
Les quantificateurs spécifient que l'élément précédent (caractère, classe de caractères ou groupe) doit apparaîtrecombien de foisCe n'est qu'alors que la correspondance est considérée comme réussie.
Les quantificateurs sont par défautgourmands, c'est-à-dire qu'ils correspondent au plus grand nombre de caractères possible. Ajouter après un quantificateur?peut devenir un motifparesseux (non gourmand), c'est-à-dire correspondre au plus petit nombre de caractères possible. Les débutants peuvent d'abord maîtriser*、+、?、{n}Ces quatre quantificateurs de base.
Le tableau suivant liste les quantificateurs :
| Qualificateurs | Description | Mode | correspondance |
|---|---|---|---|
| * | Correspond à l'élément précédent zéro ou plusieurs fois. (Zéro occurrence compte également comme une correspondance) | \d*\.\d | ".0"、 "19.9"、 "219.9" |
| + | Correspond à l'élément précédent une ou plusieurs fois. (Au moins une fois) | "be+" | Le "bee" dans "been", et le "be" dans "bent" |
| ? | Correspond à l'élément précédent zéro ou une fois. (c'est-à-dire que l'élément est facultatif) | "rai?n" | "ran"、 "rain" |
| { n } | Correspond exactement n fois à l'élément précédent. | ",\d{3}" | "1,043.6" dans ",043", "9,876,543,210" dans ",876"、 ",543" et ",210" |
| { n ,} | Correspond à l'élément précédent au moins n fois. | "\d{2,}" | "166"、 "29"、 "1930" |
| { n , m } | Correspond à l'élément précédent au moins n fois, mais pas plus de m fois. | "\d{3,5}" | Le "19302" dans "166", "17668", "193024" |
| *? | Correspond à l'élément précédent zéro ou plusieurs fois, mais le moins de fois possible (mode paresseux). | \d*?\.\d | ".0"、 "19.9"、 "219.9" |
| +? | Correspond à l'élément précédent une ou plusieurs fois, mais le moins de fois possible (mode paresseux). | "be+?" | "be" dans "been", "be" dans "bent" |
| ?? | Correspond à l'élément précédent zéro ou une fois, mais le moins de fois possible (mode paresseux). | "rai??n" | "ran"、 "rain" |
| { n }? | Correspond exactement n fois à l'élément qui précède. | ",\d{3}?" | "1,043.6" dans ",043", "9,876,543,210" dans ",876"、 ",543" et ",210" |
| { n ,}? | Correspond à l'élément précédent au moins n fois, mais le moins de fois possible. | "\d{2,}?" | "166", "29" et "1930" |
| { n , m }? | Correspond à l'élément précédent entre n et m fois, mais le moins de fois possible. | "\d{3,5}?" | "166", "17668", et les "193" et "024" dans "193024" |
Constructions de rétroréférence
Les rétroréférences permettent, au sein de la même expression régulière, de référencerle contenu des groupes précédemment capturés, ce qui effectue à nouveau une correspondance. Par exemple, en utilisant(\w)\1permet de trouver des caractères répétés consécutifs comme "ee", "ll".
Le tableau suivant liste les constructions de rétroréférence :
| Constructions de rétroréférence | Description | Mode | correspondance |
|---|---|---|---|
| \ number | Rétroréférence. Correspond à la valeur d'une sous-expression numérotée. | (\w)\1 | "ee" dans "seek" |
| \k< name > | Rétroréférence nommée. Correspond à la valeur d'une expression nommée. Plus lisible que les références numériques, recommandé. | (?< char>\w)\k< char> | "ee" dans "seek" |
Construction d'alternance
Les constructions d'alternance utilisent la barre verticale|Implémente une logique "ou", permettant à l'expression régulière de correspondre à l'un quelconque de plusieurs motifs candidats. Similaire à la||Opérateurs.
Le tableau suivant répertorie les constructions d'alternance :
| Construction d'alternance | Description | Mode | correspondance |
|---|---|---|---|
| | | Correspond à l'un quelconque des éléments séparés par le caractère de barre verticale (|). | th(e|is|at) | Les "the" et "this" dans "this is the day. " |
| (?( expression )yes | no ) | Si le modèle d'expression régulière correspond à l'expression spécifiée, alors correspond à la partieyes; sinon, correspond à la partie facultativeno. L'expression est interprétée comme une assertion de largeur nulle. | (?(A)A\d{2}\b|\b\d{3}\b) | Les "A10" et "910" dans "A10 C103 910" |
| (?( name )yes | no ) | Si name ou un groupe de capture nommé ou numéroté a une correspondance, alors correspond auyes; sinon, correspond auno facultatif。 | (?< quoted>")?(?(quoted).+?"|\S+\s) | "Dogs.jpg "Yiska playing.jpg"" dans Dogs.jpg et "Yiska playing.jpg" |
remplacement
La syntaxe de remplacement est utilisée pourRegex.Replace()de la méthodeChaîne de modèle de remplacementDans, vous pouvez utiliser$Utilisez des nombres ou des noms pour référencer le contenu d'un groupe précédemment capturé, ce qui permet une réorganisation flexible du texte.
Le tableau suivant répertorie les caractères utilisés pour la substitution :
| Caractère | Description | Mode | Motif de remplacement | Chaîne d'entrée | Chaîne de résultat |
|---|---|---|---|---|---|
| $nombre | Remplacement par groupenuméroLa sous-chaîne correspondante. | \b(\w+)(\s)(\w+)\b | $3$2$1 | "one two" | "two one" |
| ${name} | Remplacer par le groupe nomménameLa sous-chaîne correspondante. | \b(?< word1>\w+)(\s)(?< word2>\w+)\b | ${word2} ${word1} | "one two" | "two one" |
| $$ | Le caractère de remplacement "$". | \b(\d+)\s?USD | $$$1 | "103 USD" | "$103" |
| $& | Remplace par une copie de la correspondance entière. | (\$*(\d*(\.+\d+)?){1}) | **$& | "$1.30" | "**$1.30" |
| $` | Remplace tout le texte de la chaîne d'entrée avant la correspondance. | B+ | $` | "AABBCC" | "AAAACC" |
| $' | Remplace tout le texte de la chaîne d'entrée après la correspondance. | B+ | $' | "AABBCC" | "AACCCC" |
| $+ | Remplace le dernier groupe capturé. | B+(C+) | $+ | "AABBCCDD" | AACCDD |
| $_ | Remplace toute la chaîne d'entrée. | B+ | $_ | "AABBCC" | "AAAABBCCCC" |
Construction diverse
Le tableau suivant répertorie les constructions diverses :
| Constructeur | Description | Exemple |
|---|---|---|
| (?imnsx-imnsx) | Définit ou désactive des options telles que l'insensibilité à la casse au milieu d'un modèle. | \bA(?i)b\w+\b correspond à "ABA" et "Able" dans "ABA Able Act" |
| (?#comment) | Commentaire en ligne. Ce commentaire se termine à la première parenthèse fermante. | \bA(?#correspond à un mot commençant par A)\w+\b |
| # [Fin de ligne] | Ce commentaire commence par un # non échappé et se poursuit jusqu'à la fin de la ligne. | (?x)\bA\w+\b#Correspond aux mots commençant par A |
Classe Regex
La classe Regex est la classe centrale pour l'utilisation des expressions régulières dans .NET, située dansSystem.Text.RegularExpressionssous l'espace de noms. Avant de l'utiliser, vous devez ajouter en haut du fichier :
using System.Text.RegularExpressions;
Le tableau suivant répertorie quelques méthodes couramment utilisées de la classe Regex :
| Numéro de série | Metode & Deskripsi |
|---|---|
| 1 | public bool IsMatch(
string input
)
Détermine si la chaîne d'entrée contient un contenu qui correspond au modèle d'expression régulière. Couramment utilisé dans la validation de formulaires, comme la validation des formats de numéro de téléphone ou d'e-mail. |
| 2 | public bool IsMatch(
string input,
int startat
)
Effectue la détermination de correspondance à partir de la position spécifiée dans la chaîne. |
| 3 | public static bool IsMatch(
string input,
string pattern
)
Méthode statique ; pas besoin de créer d'abord un objet Regex. Passez directement la chaîne de modèle pour la détermination de correspondance. Convient aux cas d'utilisation ponctuels. |
| 4 | public MatchCollection Matches(
string input
)
Recherche toutes les correspondances dans la chaîne d'entrée, renvoie un MatchCollection, que l'on peut parcourir avec foreach sur chaque résultat de correspondance. |
| 5 | public string Replace(
string input,
string replacement
)
Remplace tout contenu dans la chaîne d'entrée qui correspond au modèle d'expression régulière par la chaîne spécifiée. |
| 6 | public string[] Split(
string input
)
Divise la chaîne d'entrée en un tableau de sous-chaînes selon les délimiteurs définis par le modèle d'expression régulière. Plus flexible que string.Split(), prenant en charge des règles de délimiteur complexes. |
Pour la liste complète des propriétés de la classe Regex, veuillez consulter la documentation Microsoft C#.
Exemple 1
L'exemple suivant met en correspondance les mots commençant par 'S' :
Analyse :\best une limite de mot,Scorrespond à la lettre majuscule S,\S*correspond à zéro ou plusieurs caractères non blancs ; combiné, cela signifie « des mots complets commençant par S ».
Exemple
using System.Text.RegularExpressions;
namespace RegExApplication
{
class Program
{
private static void showMatch(string text, string expr)
{
Console.WriteLine("L'expression : " + expr);
MatchCollection mc = Regex.Matches(text, expr);
foreach (Match m in mc)
{
Console.WriteLine(m);
}
}
static void Main(string[] args)
{
string str = "Mille soleils splendides";
Console.WriteLine("Mots correspondants commençant par 'S' : ");
showMatch(str, @"\bS\S*");
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :
Matching words that start with 'S': The Expression: \bS\S* Splendid Suns
Exemple 2
L'exemple suivant correspond aux mots commençant par 'm' et se terminant par 'e' :
Analyse :\bmcorrespond aux mots commençant par m,\S*correspond à tout caractère non blanc au milieu,e\bExige de se terminer par e suivi d'une limite de mot ; ensemble, il trouve tous les mots commençant par m et se terminant par e.
Exemple
using System.Text.RegularExpressions;
namespace RegExApplication
{
class Program
{
private static void showMatch(string text, string expr)
{
Console.WriteLine("L'expression : " + expr);
MatchCollection mc = Regex.Matches(text, expr);
foreach (Match m in mc)
{
Console.WriteLine(m);
}
}
static void Main(string[] args)
{
string str = "make maze and manage to measure it";
Console.WriteLine("Matching words start with 'm' and ends with 'e':");
showMatch(str, @"\bm\S*e\b");
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :
Matching words start with 'm' and ends with 'e': The Expression: \bm\S*e\b make maze manage measure
Exemple 3
L'exemple suivant remplace les espaces supplémentaires :
Analyse :\\s+Correspond à un ou plusieurs caractères d'espacement consécutifs (espaces, tabulations, etc.) et les remplace tous par un seul espace, fusionnant ainsi les espaces supplémentaires.
Exemple
using System.Text.RegularExpressions;
namespace RegExApplication
{
class Program
{
static void Main(string[] args)
{
string input = "Hello World ";
string pattern = "\\s+";
string replacement = " ";
Regex rgx = new Regex(pattern);
string result = rgx.Replace(input, replacement);
Console.WriteLine("Chaîne d'origine : {0}", input);
Console.WriteLine("Chaîne de remplacement : {0}", result);
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :
Original String: Hello World Replacement String: Hello World
GeneratedRegex : optimisation du générateur de source (.NET 7+)
À partir de .NET 7, C# a introduit[GeneratedRegex]attribut (générateur de source), qui est une amélioration majeure par rapport à la méthode traditionnelleRegexune amélioration importante apportée à la classe, en particulier pourles scénarios sensibles aux performancesouà utilisation répétéede regex.
Problèmes des approches traditionnelles
Utilisez la méthode traditionnellenew Regex(pattern)Lorsque ..., l'analyse et la compilation de l'expression régulière se produisent à l'exécution, chaque création a un surcoût. Bien que vous puissiez utiliserRegexOptions.CompiledAméliore la vitesse d'exécution, mais la compilation se produit toujours à l'exécution et augmente le temps de démarrage et l'utilisation de la mémoire.
Méthode traditionnelle
// Méthode 1 : réanalyser à chaque fois (le plus lent)
bool isMatch = Regex.IsMatch(input, @"\d{4}-\d{2}-\d{2}");
// Méthode 2 : champ statique + Compiled (pratique d'optimisation courante)
private static readonly Regex DateRegex = new Regex(@"\d{4}-\d{2}-\d{2}", RegexOptions.Compiled);
Utilisation de GeneratedRegex
Utilisation[GeneratedRegex]Avec l'attribut, le compilateur va, lors de laphase de compilation, générer l'expression régulière directement sous forme de code C# efficace, sans analyse ni compilation à l'exécution.
Conditions d'utilisation : .NET 7 ou version ultérieure est requis, et la méthode doit êtrepartialméthode, la classe conteneur doit également êtrepartialclass.
Utilisation de base de GeneratedRegex
using System.Text.RegularExpressions;
namespace RegExApplication
{
// La classe doit être déclarée comme partial
partial class Program
{
// Utilisez l'attribut [GeneratedRegex], le compilateur génère automatiquement l'implémentation
[GeneratedRegex(@"\d{4}-\d{2}-\d{2}")]
private static partial Regex DateRegex();
// Vous pouvez également ajouter des options, telles que l'ignorance de la casse
[GeneratedRegex(@"\bS\S*", RegexOptions.IgnoreCase)]
private static partial Regex StartsWithSRegex();
static void Main(string[] args)
{
string input = "Aujourd'hui, nous sommes le 2024-06-18, prochain événement : 2025-01-01";
// Utilisez-le comme si vous appeliez une méthode normale, cela renvoie une instance de Regex
foreach (Match m in DateRegex().Matches(input))
{
Console.WriteLine("Date trouvée :" + m.Value);
}
// Vérifier si cela correspond
Console.WriteLine(StartsWithSRegex().IsMatch("Splendide")); // Vrai
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :
找到日期:2024-06-18 找到日期:2025-01-01 True
GeneratedRegex vs Regex traditionnel
Le tableau suivant compare les deux approches selon plusieurs dimensions pour vous aider à choisir l'utilisation appropriée :
| Dimension de comparaison | Regex traditionnel | GeneratedRegex (générateur de source) | Recommandé |
|---|---|---|---|
| Version minimale requise | .NET Framework / .NET Core Toutes les versions prises en charge | .NET 7 et versions ultérieures | — |
| Moment de compilation | Analyse et compilation à l'exécution | Au moment de la compilation (lors de la génération), le générateur de source Roslyn génère du code | GeneratedRegex |
| Performances d'exécution | Normal : plus lent ; avec l'option Compiled : plus rapide, mais surcharge de démarrage élevée | Le plus rapide, proche des performances du code écrit à la main, et sans surcharge de démarrage | GeneratedRegex |
| Utilisation de la mémoire | Le mode compilé génère du code IL et a une utilisation de la mémoire plus élevée | Il génère du code C# ordinaire, qui est plus économe en mémoire | GeneratedRegex |
| Compatibilité AOT | RegexOptions.Compiled est incompatible avec AOT (compilation ahead-of-time) | Entièrement compatible avec Native AOT, adapté à la publication d'applications autonomes | GeneratedRegex |
| Lisibilité du code | La chaîne de motif est écrite directement dans le code, ce qui est plus intuitif | Nécessite de définir une méthode partielle, et la structure du code est légèrement plus complexe | Regex traditionnel (scénarios simples) |
| Mode dynamique | Pris en charge, le motif peut être une variable d'exécution | Non pris en charge, le motif doit être une constante de compilation | Regex traditionnel (scénarios dynamiques) |
| Prise en charge du débogage | Ordinaire | Le code généré peut être consulté et débogué directement, ce qui le rend plus transparent | GeneratedRegex |
| Scénarios applicables | Utilisation ponctuelle, modèles dynamiques, projets .NET hérités | Appels à haute fréquence, sensible aux performances, publication AOT, nouveaux projets .NET | Cela dépend du contexte |
Suggestions d'utilisation
- Si vous utilisez.NET 7+et que le modèle regex est fixe,Préférez utiliser
[GeneratedRegex]。 - Si le modèle regex doit être construit dynamiquement au moment de l'exécution (par ex. généré à partir de la saisie utilisateur), seule la méthode traditionnelle
new Regex(pattern)。 - Si le projet doit prendre en chargeNative AOTlors de la publication (par ex. le mode AOT de .NET 8), veillez à utiliser
[GeneratedRegex]plutôt queRegexOptions.Compiled。 - Pour les débutants, vous pouvez d'abord utiliser la méthode traditionnelle pour apprendre et vous exercer. Après avoir compris les principes des expressions régulières, migrez progressivement vers
[GeneratedRegex]。
Exemple : Utilisation de GeneratedRegex pour valider le format d'e-mail
using System.Text.RegularExpressions;
partial class EmailValidator
{
// Définir l'expression régulière de validation d'e-mail, en ignorant la casse
[GeneratedRegex(^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}, Regex.IgnoreCase)]
public static partial EmailRegex();
public static bool IsValidEmail(string email)
{
return EmailRegex().IsMatch(email);
}
static void Main(string[] args)
{
string[] emails = { "user@example.com", "bad-email", "hello@world.org", "missing@dot" };
foreach (var email in emails)
{
Console.WriteLine($"{email}: {(IsValidEmail(email) ? "valide" : "Invalide")}");
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :
user@example.com: 有效 bad-email: 无效 hello@world.org: 有效 missing@dot: 无效autres extensions