Expressions régulières C#

Expression régulière C'est un modèle de correspondance pour le texte d'entrée.

Le cadre .Net fournit un moteur d'expression régulière permettant ce type de correspondance.

Le motif est composé d'un ou plusieurs caractères, opérateurs et structures.

Définir l'expression régulière

Le tableau suivant liste les caractères, opérateurs et structures utilisés pour définir les expressions régulières.

• Échappement de caractères

• Classe de caractères

• Points de repère

• 分组构造

• Quantifier

• Backreference construction

• Alternative construction

• Remplacement

• Constructions d'articles

Échappement de caractères

Le caractère de barre oblique inverse () dans l'expression régulière indique que le caractère suivant est un caractère spécial, ou que ce caractère doit être interprété littéralement.

Le tableau suivant liste les caractères d'échappement :

Classe de caractères

Une classe de caractères correspond à tout caractère d'un ensemble de caractères.

Le tableau suivant liste les classes de caractères :

Points de repère

Les points de repère ou les prédicats atomiques de zéro largeur peuvent réussir ou échouer en fonction de la position actuelle dans la chaîne, mais ils ne font pas avancer l'engine dans la chaîne ou utiliser des caractères.

Le tableau suivant liste les points de repère :

分组构造

分组构造描述了正则表达式的子表达式，通常用于捕获输入字符串的子字符串。

下表列出了分组构造：

using System;
using System.Text.RegularExpressions;
public　class　Example
{
　　　public　static　void　Main()
　　　{
　　　　　　string　input　=　"1851　1999　1950　1905　2003";
　　　　　　string　pattern　=　@"(?<=19)\d{2};
　　　　　　foreach　(Match　match　in　Regex.Matches(input,　pattern))
　　　　　　　　　Console.WriteLine(match.Value);
　　　}
}

Run example »

Quantifier

Quantifiers specify how many occurrences of the previous element (which can be a character, group, or character class) must exist in the input string to match the item. Quantifiers include the language elements listed in the table.

The following table lists the quantifiers:

Backreference construction

Backreference allows to identify previously matched subexpressions later in the same regular expression.

The following table lists the backreference constructions:

Alternative construction

Alternative construction is used to modify the regular expression to enable either/Match or.

The following table lists the alternative constructions:

Remplacement

Le remplacement est l'expression régulière utilisée dans le modèle de remplacement.

Le tableau suivant liste les caractères utilisés pour le remplacement :

Constructions d'articles

Le tableau suivant liste diverses constructions d'articles :

Classe Regex

La classe Regex est utilisée pour représenter une expression régulière.

Le tableau suivant liste certains des méthodes couramment utilisées de la classe Regex :

Pour obtenir la liste complète des propriétés de la classe Regex, veuillez consulter la documentation C# de Microsoft.

Exemple 1

Le exemple suivant matche les mots commençant par 'S' :

Correspondance des mots commençant par 'S':
L'Expression: \bS\S*
Splendid
Suns

using System;
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("Correspondance des mots commençant par 'm' et se terminant par 'e':");
　　　　　　　　　showMatch(str, @"\bm\S*e\b");
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Correspondance des mots commençant par 'm' et se terminant par 'e':
L'Expression: \bm\S*e\b
make
maze
manage
measure

using System;
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 originale : {0}", input)
　　　　　　　　　Console.WriteLine("Chaîne de remplacement : {0}", result);　　　　
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Chaîne originale : Hello     World　　　
Chaîne de remplacement : Hello World