Utilisation des expressions régulières en .Net

Les Regex sont un outil (ou plutôt un système) très puissant permettant de vérifier la syntaxe d'une chaine de caractères. Plus précisément, c'est vérifier que la chaine de caractères à examiner respecte un motif ou une série de motifs (notre Regex) désignant la syntaxe attendue de la phrase.

Les Regex sont utilisées pour trois grands types d'action :
- vérifier la syntaxe(forme) d'une chaine de caractères (ex. : adresse ip de forme chiffre.chiffre.chiffre.chiffre) ;
- remplacer une partie de la chaine (token) par un élément spécifique ;
- découper une chaine de caractères.

Leur utilisation la plus courante est de vérifier la syntaxe d'une chaine, c'est-à-dire contrôler qu'elle respecte un format prédéfini et normé, décrit par les combinaisons d'opérateurs et de valeurs de la chaine Regex.

Les Regex sont donc une suite de motifs qui se composent de métacaractères, de classes sous .NET et d'alias.
Voici tout d'abord, une série de métacaractères pouvant être utilisés et ayant chacun une correspondance bien précise.

Ces métacaractères nous permettent donc de faire des combinaisons infinies pouvant correspondre à tous les besoins. Néanmoins, pour vérifier des chaines de caractères de taille importante, l'écriture de ces métacaractères peut être fastidieuse, en plus du fait que la chaine Regex n'est pas très lisible pour le développeur. Heureusement, il existe une série d'alias permettant de faciliter cette tâche :

Comme rien n'est plus parlant qu'un exemple concret, en voici quelques-uns qui démontrent à quel point les chaines Regex peuvent être simples…
ou complexes :)
Chaine qui contient des lettres de a à d : [a-d] ou [abcd]
Chaine qui contient des lettres de a à d ou n'importe quelles lettres majuscules : [a-dA-Z]
Chaine commençant (et finissant) par y ou z : ^(y | z)$
Chaine ne contenant pas de chiffre : [^0-9]
Chaine contenant les chiffres 1 ou 2 ou le symbole ^ : [12\^]

On peut utiliser plusieurs métacaractères :
^[pP]hara(onix)?$ : phara, Phara, pharaonix ou Pharaonix

Ou tout simplement vérifier la validité d'une adresse ip :
^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$

Note : Cette ligne de validation semble complexe, mais dans une application, elle est la seule alternative à une suite énorme de substring() et comparaisons via les méthodes traditionnelles.

Les Regex nécessitent l'utilisation de l'espace de noms System.Text.RegularExpressions

using System.Text.RegularExpressions;

De plus, pour faciliter la vérification de vos Regex, je mets à disposition un petit programme qui permettra également de vérifier la validité des exemples que nous verrons par la suite. RegexMaker (32ko) Miroir.

La validation d'une chaine de caractères se fait grâce à la méthode IsMatch() qui retourne une valeur booléenne égale à true si la chaine correspond à la Regex et false dans le cas contraire.
Voici comme exemple, la méthode ValidMail() vérifie la validité d'une adresse mail passée en paramètre.

private bool ValidMail(string adresse)
{ 
    System.Text.RegularExpressions.Regex myRegex = new Regex(@"^([\w]+)@([\w]+)\.([\w]+)$");
    //([\w]+) ==> caractère alphanumérique apparaissant une fois ou plus 
    return myRegex.IsMatch(adresse); // retourne true ou false selon la vérification
}

Le fonctionnement de cette méthode consiste donc à créer un objet Regex que l'on initialise avec notre expression, puis on passe à cet objet la chaine à valider (ici la chaine adresse).

Une deuxième utilité des Regex est de pouvoir rechercher des occurrences de chaines spécifiques et de les remplacer par une autre chaine. Dans ce cas précis, nous utiliserons la méthode Replace(). Celle-ci est plus ou moins identique à la méthode Replace() de l'objet string, mais cette dernière ne permet de remplacer qu'une seule chaine de caractères par une autre. Prenons comme exemple, la méthode, SMS qui s'assure de remplacer certains termes par d'autres:

private string SMS(string chaine)
{
    System.Text.RegularExpressions.Regex myRegex = new Regex("(lut|salut|yop)");
    return myRegex.Replace(chaine,"bonjour"); //renvoi la chaine modifiée
}

Cette fois-ci, notre méthode remplacera toutes les occurrences des mots "lut", "salut" et "yop" par le mot "bonjour".

Il existe une subtilité des Regex qui consiste à pouvoir réutiliser la chaine récupérée via la Regex. La chaine Regex peut être modifiée de façon à ce que chaque motif correspondant à un groupe de métacaractères entre parenthèses soit récupérable et réutilisable par la suite. Ces regroupements sont donc réalisés à l'aide de "parenthèses de capture" (capturing parentheses) et permettent d'extraire des chaines de caractères qui seront utilisées pour la modification de la chaine de caractères finale. Voici un exemple concret: la méthode ToHtmlMail qui réutilise une partie de la chaine de départ, extraite grâce à la chaine Regex :

private string ToHtmlMail(string adresse)
{
   Regex  myRegex = new Regex(@"([\w\-.]+@[\w\-.]+)");
   return myRegex.Replace(adresse, "<a href=\"mailto:$1\" >$1a>");
}

Dans cette méthode, on ajoute les balises html mailto autour de l'adresse mail détectée. Ainsi, en passant à la méthode la chaine "contactez-moi via lg-morand@redaction-developpez.com", elle devient "contactez-moi via <a href="mailto:lg-morand@redaction-developpez.com">lg-morand@redaction-developpez.com</a>".
L'alias $1 représente la première chaine récupérée par la Regex :
([\w\-.]+@[\w\-.]+)
On aurait pu utiliser $2 si la chaine Regex de base était de la forme ([\w\-.]+)@([\w\-.]+). Voici le schéma représentant le cas de figure avec une chaine Regex à deux groupements (parenthèses) et les parties de la chaine analysée, qui sont récupérées :

II-D-1. Découpage par séparateur▲

private string[] Splitter(string chaine)
{
   Regex myRegex=new Regex(@"\d+");
   return myRegex.Split(chaine);
}

II-D-2. Découpage par regroupement▲

Regex myRegex=new Regex(@"^LDAP://CN=([\w]+), CN=([\w]+), DC=([\w]+), DC=([\w]+)$");
Match m= myRegex.Match("LDAP://CN=moderateurs, CN=pharaonix, DC=com, DC=developpez");
if(m.Success)
{  
   MessageBox.Show("Utilisateur: " + m.Groups[2].Value);
   MessageBox.Show("Groupe: " + m.Groups[1].Value);
   MessageBox.Show("Serveur: " + m.Groups[4].Value+"."+m.Groups[3].Value);
}