Qu'est ce qu'une expression régulière, comment l'écrire, comment l'utiliser en .NET ? Voilà les questions que nous aborderons dans cet article.

Expression régulière, expression rationnelle

Une expression régulière ou expression rationnelle (Anglais : regular expression) est une chaîne de caractères permettant de d'écrire un ensemble de chaînes de caractères selon une syntaxe dont nous verrons les spécificités dans le chapitre suivant. Vous trouverez les abréviations regex ou regexp tout au long de cet article ainsi que sur les différents sites de développements. Elles sont utilisées dans plusieurs cas :

• Les shells UNIX les utilisent pour faire des cherches de fichiers.
• Vérifier la forme d'une chaîne de caractères. C'est-à-dire vérifier si une chaîne caractères saisie par un utilisateur est correcte par rapport à ce que l'on attend. Par exemple un utilisateur saisie une adresse email et grâce à une expression régulière, on peut vérifier que cette adresse est syntaxiquement correcte.
• Il est également possible d'effectuer des traitements sur des chaînes de caractères, comme remplacer un morceau de cette dernière par un autre, découper cette chaîne...

La syntaxe

Les métacaractères

Grâce à ces métacaractères, il est possible de faire une infinité de combinaisons pour adapter à nos besoins.

Les caractères d'échappement

Le caractère d'échappement \ (backslash) indique que le caractère situé après le backslash n'est pas un opérateur mais un caractère Unicode.

Exemple 1 : Adresse email

Comme vous le savez sûrement, une adresse email est composée en 4 parties :

• La partie de gauche : Nom du propriétaire de l'adresse (Composé de caractères alphanumérique et d'éventuels '.', '-')
• Le caractère @
• Le sous-domaine (Eventuel) et le domaine (Composé de caractères alphanumérique et d'éventuels '.', '-')
• Un point '.' puis l'extention de domaine (entre 2 et 4 caractères).

Donc pour la première partie, nous devons avoir : "[a-zA-Z0-9_+-]+(\.[a-zA-Z0-9_+-]+)*" Pour la seconde : "@" Ensuite pour les éventuels sous-domaine et le nom de domaine : "[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*" Enfin pour l'extention de domaine : "\.[a-z]{2,4}" Il ne faut pas oublier qu'une expression régulière commence par un ^ et termine par un $. Nous avons donc pour vérifier une adresse email l'expression suivante : ^[a-zA-Z0-9_+-]+(\.[a-zA-Z0-9_+-]+)*@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*\.[a-z]{2,4}$ Bien sûr cette expression peut être améliorée en définissant en dur toutes les extensions de domaines...

Exemple 2 : Adresse IP

Une adresse IP est composée de 4 blocs de 1 à 3 chiffres séparés par des ".". Donc : xxx.xxx.xxx.xxx Les nombres allant de 1 Ã 254 (255 pour les masques de réseaux, sous-réseaux) L'expression régulière pour une adresse IP sera donc : ^(25[0-4]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-4]|2[0-4]\d|[0-1]?\d?\d)){3}$

Utilisation en .NET

Le namespace System.Text.RegularExpressions

La technologie .NET utilise des librairies accessibles grâce aux espaces de nom (Anglais : namespaces). Pour les expressions régulières, nous utilisons le namespace System.Text.RegularExpressions. Donc avant de commencer à coder, n'oubliez pas d'importer ce namespace : using System.Text.RegularExpressions;

Validation d'une chaîne

Validation d'une adresse eMail en C#

Afin de valider ou non une adresse email, nous allons créer une fonction IsEmail() qui nous retournera un booléen qui sera fonction de la validation de l'adresse.

   1: static Boolean IsEmail(String address)

   2: {

   3:      String pattern = @"^[a-zA-Z0-9_+-]+(\.[a-zA-Z0-9_+-]+)*"

   4:                         + @"@"

   5:                         + @"[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*"

   6:                         + @"\.[a-z]{2,4}$";

   7:      // Création de note Objet de type System.Text.RegularExpressions.Regex

   8:     // Le constructeur nous demande le pattern de l’expression régulière

   9:      Regex regex = new Regex(pattern);

  10:      // On retourne un résultat pour notre chaîne “address” grace à la fonction IsMatch()

  11:     return regex.IsMatch(address);

  12: } 

Validation d'une adresse IP en C#

Afin de valider ou non une adresse IP, nous allons créer une fonction IsIP() qui nous retournera un booléen qui sera fonction de la validation de l'adresse.

   1: static Boolean IsIP(String address)

   2: {

   3:      String pattern = @"^(25[0-4]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-4]|2[0-4]\d|[0-1]?\d?\d)){3}$";

   4:      // Création de note Objet de type System.Text.RegularExpressions.Regex

   5:     // Le constructeur nous demande le pattern de l’expression régulière

   6:     Regex regex = new Regex(pattern);

   7:     // On retourne un résultat pour notre chaîne “address” grâce à  la fonction IsMatch()

   8:     return regex.IsMatch(address);

   9: }

Nous utilisons la fonction IsMatch() de l'objet System.Text.RegularExpressions.Regex afin de savoir si la chaîne que nous lui passons en paramètre est syntaxiquement correcte par rapport à l'expression régulière que nous avons passé en paramètre du constructeur. Si nous passons la chaîne "192.168.1.18" à notre fonction, elle nous retournera : True. Avec la chaîne "255.255.255.255", la fonction nous retourne : False.