Le Tutoriel d'expressions régulières C#

View more Tutorials:

1- Expression régulière (Regular expression)

1.1- Vue d'ensemble

Une expression régulière (Regular expressions) définit un modèle (pattern) de recherche pour les chaînes. Les expressions régulières peuvent être utilisées pour rechercher, modifier et manipuler du texte. Le motif défini par l'expression régulière peut correspondre (match) une ou plusieurs fois ou pas du tout pour une chaîne donnée.

L'abréviation de l'expression régulière est regex.

1.2- Des langues supportées

Les expressions régulières (Regular expression) sont prises en charge par la plupart des langages de programmation, par exemple, C#, Java, Perl, Groovy, v..v... Malheureusement, chaque langue prend en charge des expressions régulières légèrement différentes.

2- Des règles d'écriture des expressions régulières

No Expression régulière Description
1 . Correspond (match) à un ou plusieurs caractères.
2 ^regex Trouve l'expression regex qui doit correspondre au début de la ligne.
3 regex$ Trouve une expression regex qui doit correspondre à la fin de la ligne.
4 [abc] Définit la définition, peut correspondre à la lettre a ou b ou c.
5 [abc][vz] Définit la définition, peut correspondre à a ou b ou c suivi de v ou z.
6 [^abc] Lorsqu'un caret apparaît comme le premier caractère entre crochets, il annule le motif. Cela peut correspondre à n'importe quel caractère sauf a ou b ou c.
7 [a-d1-7] Plages: correspond à une lettre entre a et d et les chiffres de 1 à 7.
8 X|Z Cherche X ou Z.
9 XZ Cherche X et directement suivi de Z.
10 $ Vérifie si une fin de ligne suit.

11 \d Un numéro aléatoire, abrégé pour [0-9]
12 \D Un caractère n'est pas numéric, abrégé pour [^0-9]
13 \s Caractère d'espace blanc, abrégé pour [ \t\n\x0b\r\f]
14 \S Le caractère n'est pas d'espace blanc, abrégé pour [^\s]
15 \w Caractère de mot, abrégé pour [a-zA-Z_0-9]
16 \W Un caractère de non-mot, abrégé pour [^\w]
17 \S+ Plusieurs caractères de non-espaces (Un ou plusieurs)
18 \b Correspond à une limite de mot où un caractère de mot est [a-zA-Z0-9_].

19 * Se produit 0 ou plusieurs fois, abrégé pour {0,}
20 + Se produit 1 ou plusieurs fois, abrégé pour {1,}
21 ? Se produit 0 ou une fois, ? abrégé pour {0,1}.
22 {X} Apparait x fois {}
23 {X,Y} Se produit entre X et Y fois.
24 *? * Se produit 0 ou plusieurs fois, ajoute ? en arrière signifie de chercher l'accord le plus petit

3- Des caractères spéciaux dans C# Regex (Special characters)

Des caractères spéciaux dans  C# Regex:
\.[{(*+?^$|
 
Les caractères listés ci-dessus sont des caractères spéciaux. En C# Regex, vous voulez comprendre des caractères de la manière normale, vous devez ajouter un \ devant.

L'exemple de caractère point. C# Regex est interprété comme un ou plusieurs caractères, si vous voulez l'interpréter comme un caractère point normalement requis mark \ ahead.
// Le motif Regex décrit un ou plusieurs caractères.
string regex = ".";

// Le motif Regex décrit un caractère point.
string regex = "\\.";
string regex = @"\.";

4- L'utilisation Regex.IsMatch(string)

  • Regex class
...
// Vérifiez que l'objet String entier correspond à l'expression régulière ou non.
public bool IsMatch(string regex)
..
L'utilisation la méthode  Regex.IsMatch(string regex) vous permet de vérifier que  l'objet String entier correspond à  regex ou non. C'est la manière populaire. Considérez ces exemples :

Regex .

Dans l'expression régulière de  C#, le caractère point (.) est un caractère spécial. Il réprésente une ou plusieurs caractères. Si vous voulez  C# comprendre qu'il est un point dans le sens normal, vous devez écrire "\\." ou @"\.";
DotExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class DotExample
    {
        public static void Main(string[] args)
        {
            // La chaîne avec 0 caractère (Chaîne vide)          
            string s1 = "";
            Console.WriteLine("s1=" + s1);

            // Vérifiez la chaîne s1
            // Correspond à 1 ou plusieurs caractères.
            // Des règles .
            // ==> False (fausse)
            bool match = Regex.IsMatch(s1, ".");
            Console.WriteLine("  -Match . " + match);

            // La chaîne a 1 caractère.  
            string s2 = "a";
            Console.WriteLine("s2=" + s2);

            // Vérifiez la chaîne s2
            // Correspond à 1 ou plusieurs caractères
            // Des règles .
            // ==> True (Vraie)
            match = Regex.IsMatch(s2, ".");
            Console.WriteLine("  -Match . " + match);

            // La chaîne a 3 caractères.
            string s3 = "abc";
            Console.WriteLine("s3=" + s3);

            // Vérifiez la chaîne s3
            // Correspond à un ou plusieurs caractères.
            // Des règles .
            // ==> true (vraie)
            match = Regex.IsMatch(s3, ".");
            Console.WriteLine("  -Match . " + match);

            // La chaîne a 3 caractères.
            string s4 = "abc";
            Console.WriteLine("s4=" + s4);

            // Vérifiez la chaîne s4
            // Correspond au caractère point.
            // ==> False (fausse)
            match = Regex.IsMatch(s4, @"\.");
            Console.WriteLine("  -Match \\. " + match);

            // La chaîne a 1 caractère (le point).
            string s5 = ".";
            Console.WriteLine("s5=" + s5);

            // Vérifiez la chaîne s5
            // Correspond à un caractère point
            // ==> True (vraie)
            match = Regex.IsMatch(s5, @"\.");
            Console.WriteLine("  -Match \\. " + match);

            Console.Read();
        }
    }

}
Exécutez l'exemple :
Un autre exemple  Regex.IsMath(string):
RegexIsMatchExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class RegexIsMatchExample
    {
        public static void Main(string[] args)
        {
            // La chaîne a 1 caractère
            string s2 = "m";
            Console.WriteLine("s2=" + s2);

            // Vérifiez la chaîne s2
            // Commence par le caractère 'm'
            // Règle ^
            // ==> true (Vraie)
            bool match = Regex.IsMatch(s2, "^m");
            Console.WriteLine("  -Match ^m " + match);

            // La chaîne a 7 caractères
            string s3 = "MMnnnnn";
            Console.WriteLine("s3=" + s3);

            // Vérifiez la chaîne s3
            // Commence par le caractère MM
            // Règle ^
            // ==> true
            match = Regex.IsMatch(s3, "^MM");
            Console.WriteLine("  -Match ^MM " + match);

            // Vérifiez la chaîne s3
            // Commence par MM
            // Ensuite, c'est le caractère 'n' qui apparait un ou plusieurs fois
            // Règles ^ et +
            match = Regex.IsMatch(s3, "^MMn+");
            Console.WriteLine("  -Match ^MMn+ " + match);

            // La chaîne a 1 caractère
            String s4 = "p";
            Console.WriteLine("s4=" + s4);

            // Vérifiez la chaîne s4 qui termine par 'p'
            // Règle $
            // ==> true
            match = Regex.IsMatch(s4, "p$");
            Console.WriteLine("  -Match p$ " + match);

            // La chaîne a 6 caractères
            string s5 = "122nnp";
            Console.WriteLine("s5=" + s5);


            // Vérifiez si la chaîne s5 termine par 'p'
            // ==> true
            match = Regex.IsMatch(s5, "p$");
            Console.WriteLine("  -Match p$ " + match);

            // Vérifiez la chaîne s5
            // Commence par un ou plusiers caractères (Règle .)
            // Puis, c'est le caractère 'n', qui apparait 1 ou 3 fois (Règle n{1,3} )
            // Termine par le caractère 'p' (Règle $)
            // Combine avec des règles ., {x,y}, $
            // ==> true
            match = Regex.IsMatch(s5, ".n{1,3}p$");
            Console.WriteLine("  -Match .n{1,3}p$ " + match);


            String s6 = "2ybcd";
            Console.WriteLine("s6=" + s6);

            // Vérifiez la chaîne s6
            // Commence par le caractère '2'
            // Puis, c'est 'x' ou 'y' ou 'z'  (Règle [xyz])
            // Suivi par tout, apparaissent 0 ou plusieurs fois.
            // Combinez les règles: [xyz], *
            // ==> true
            match = Regex.IsMatch(s6, "2[xyz].*");

            Console.WriteLine("  -Match 2[xyz].* " + match);

            string s7 = "2bkbv";
            Console.WriteLine("s7=" + s7);

            // Vérifier s7 Commencer une, une ou plusieurs fois
            // Suivi par 'a' ou 'b' ou 'c': [abc]
            // Suivant 'z' ou 'v': [zv]
            // Suivi par tout (0 ou plusieurs fois)
            // ==> true
            match = Regex.IsMatch(s7, ".[abc][zv].*");

            Console.WriteLine("  -Match .[abc][zv].* " + match);


            Console.Read();
        }
    }


}
Les résultats de l'exécution d'exemple :
Exemple suivant :
RegexIsMatchExample2.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class RegexIsMatchExample2
    {
        public static void Main(string[] args)
        {
            String s = "The film Tom and Jerry!";

            // Vérifiez la chaîne s
            // Commence par tous les caractères apparaissent 0 fois ou plus (Règle :. *)
            // Suivant "Tom" ou "Jerry"
            // Termine par les caractères apparaissent une fois ou plus (Règle :.)
            // Combinez les règles:., *, X | Z
            bool match = Regex.IsMatch(s, ".*(Tom|Jerry).");
            Console.WriteLine("s=" + s);
            Console.WriteLine("-Match .*(Tom|Jerry). " + match);

            s = "The cat";
            // ==> false
            match = Regex.IsMatch(s, ".*(Tom|Jerry).");
            Console.WriteLine("s=" + s);
            Console.WriteLine("-Match .*(Tom|Jerry). " + match);

            s = "The Tom cat";
            // ==> true
            match = Regex.IsMatch(s, ".*(Tom|Jerry).");
            Console.WriteLine("s=" + s);
            Console.WriteLine("-Match .*(Tom|Jerry). " + match);

            Console.Read();
        }
    }

}
Les résultats de l'exécution d'exemple :

5- Using Regex.Split & Regex.Replace

Une des autres méthodes utiliataires est  Regex.Split(string,string), cette méthode sépare une chaîne en sous- chaînes. Par exemple, vous avez la chaîne   "One,Two,Three" et vous voulez la diviser en 3 sous- chaînes, séparée par la virgule.
SplitWithRegexExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class SplitWithRegexExample
    {
        public static void Main(string[] args)
        {
            // \t: Caractère TAB
            // \n: Caractère de créer une nouvelle ligne (NewLine character).
            string TEXT = "This \t\t is \n my \t text";

            Console.WriteLine("TEXT=" + TEXT);

            // Définissez un Regex :
            // Les espaces blancs apparaissent une ou plusieurs fois.
            // Caractères d'espaces blancs: \t\n\x0b\r\f
            // Combinez des règles : \s et +
            String regex = @"\s+";

            Console.WriteLine(" -------------- ");

            String[] splitString = Regex.Split(TEXT, regex);

             
            Console.WriteLine(splitString.Length); // ==> 4

            foreach (string str in splitString)
            {
                Console.WriteLine(str);
            }

            Console.WriteLine(" -------------- ");

            // Remplacer les espaces blancs par la lettre tab.
            String newText = Regex.Replace(TEXT, "\\s+", "\t");
            Console.WriteLine("New text=" + newText);

            Console.Read();
        }
    }

}
Exécutez l'exemple :

6- Utilisation MatchCollection & Match

Utilisez la méthode  Regex.Matches(...) pour chercher tous les sous- chaine d'une chaine, correspondant à expression régulère. Cette méthode renvoie un objet  MatchCollection.
** Regex.Matches() **
public MatchCollection Matches(
    string input
)

public MatchCollection Matches(
    string input,
    int startat
)

public static MatchCollection Matches(
    string input,
    string pattern
)

public static MatchCollection Matches(
    string input,
    string pattern,
    RegexOptions options,
    TimeSpan matchTimeout
)

public static MatchCollection Matches(
    string input,
    string pattern,
    RegexOptions options
)
L'exemple ci-dessous, divise une chaine en sous- chaines, séparées par des espaces blancs (whitespace).
MatchCollectionExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class MatchCollectionExample
    {
        public static void Main(string[] args)
        {

            string TEXT = "This \t is a \t\t\t String";

            // \w : Un caractère d'un mot, abréviation de [a-zA-Z_0-9]
            // \w+ : Caractère d'un mot, apparait un ou plusieurs fois.
            string regex = @"\w+";


            MatchCollection matchColl = Regex.Matches(TEXT, regex);

            foreach (Match match in matchColl)
            {
                Console.WriteLine(" ---------------- ");
                Console.WriteLine("Value: " + match.Value);
                Console.WriteLine("Index: " + match.Index);
                Console.WriteLine("Length: " + match.Length);
            }


            Console.Read();
        }
    }

}
Le résultat de l'exécution d'exemple :

7- Le groupe (Group)

Avec une expression régulière, vous pouvez la diviser en groupes (group):
// Une expression régulière
string regex = @"\s+=\d+";

// Écrivant sous forme de 3 groupe (group), par marquant ( )
string regex2 = @"(\s+)(=)(\d+)";

// 2 groupes (group)
string regex3 = @"(\s+)(=\d+)";
Les  group peut être imbriqué et nécessite donc une règle d'indexation du group.  La totalité du  pattern est définie comme le groupe 0. Le groupe restant a décrit une illustration similaire ci-dessous:

Remarque: Utilisez (?:pattern) pour informer à C# de ne pas voir ceci étant un group (None-capturing group)

Vous pouvez définir un groupe de capture nommé (?<groupName>pattern) ou  (?'groupName'pattern). Et vous pouvez accéder au contenu correspondant à match.Groups["groupName"]. Ceci fait Regex devenir plus long, mais le code est plus significatif, car il indique ce que vous essayez de faire correspondre ou d'extraire avec l'expression régulière.

Le groupe de capture nommé peut également être accédé via match.Groups [groupIndex] avec le même schéma de numérotation.
-
Observons un exemple en utilisant le groupe (group) baptisé :
NamedGroupExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class NamedGroupExample
    {
        public static void Main(string[] args)
        {
            string TEXT = " int a = 100;  float b= 130;  float c= 110 ; ";

            // Utilisez (?<groupName>pattern) pour définir un Group nommé : groupName
            // Défini le groupe nommé 'declare': en utilisant (?<declare> ...)
            // Et un groupe nommé 'value': utilisez : (?<value> ..)
            string regex = @"(?<declare>\s*(int|float)\s+[a-z]\s*)=(?<value>\s*\d+\s*);";

            MatchCollection matchCollection = Regex.Matches(TEXT, regex);


            foreach (Match match in matchCollection)
            {
                string group = match.Groups["declare"].Value;
                Console.WriteLine("Full Text: " + match.Value);
                Console.WriteLine("<declare>: " + match.Groups["declare"].Value);
                Console.WriteLine("<value>: " + match.Groups["value"].Value);
                Console.WriteLine("------------------------------");
            }

            Console.Read();
        }
    }

}
Les résultats de l'exécution d'exemple :
Pour simplifier, vous pouvez voir l'illustration ci-dessous :

8- Using MatchCollection, Group and *?

Dans certaines situations  *? il est primordial. Prennez l'exemple ci-dessous :
// Ceci est regex
// Tous les caractères, apparait 0 ou plusieurs fois,
// ensuite, c'est le caractère  '  et puis, c'est  >
string regex = ".*'>";

// La chaine TEXT1 ci-dessous ne correspond pas à ce ledit regex.
string TEXT1 = "FILE1'>";

// La chaine TEXT2 ci-dessous correspond au ledit regex.
string TEXT2 = "FILE1'> <a href='http://HOST/file/FILE2'>";
*? trouvera le plus petit accord (smallest match). Nous considérons l'exemple ci-dessous :
NamedGroupExample2.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class NamedGroupExample2
    {
        public static void Main(string[] args)
        {

            string TEXT = "<a href='http://HOST/file/FILE1'>File 1</a>"
                         + "<a href='http://HOST/file/FILE2'>File 2</a>";

            // Définissez un groupe nommé fileName.
            // * signifie de l'apparution 0 ou plusieurs fois.
            // *? signifie un petit accord (smallest match).
            string regex = "/file/(?<fileName>.*?)'>";

            MatchCollection matchCollection = Regex.Matches(TEXT, regex);


            foreach (Match match in matchCollection)
            {
                Console.WriteLine("File Name = " + match.Groups["fileName"].Value);
                Console.WriteLine("------------------------------");
            }

            Console.Read();
        }
    }

}
Les résultats de l'exécution d'exemple :

View more Tutorials: