Expressions régulières C#

L'expression régulière est un modèle qui correspond au texte saisi. Le framework .Net fournit un moteur d'expression régulière qui permet ce type de correspondance. Un modèle se compose d'un ou plusieurs caractères, opérateurs et structures.

Définir des expressions régulières

Vous trouverez ci-dessous les différentes catégories de caractères, d'opérateurs et de structures utilisés pour définir des expressions régulières.

• Évasion de personnage

• Classe de personnage

• Ancre

• Construction de groupe

• Qualificateur

• Construction de référence arrière

• Constructions alternatives

• Remplacement

• Constructions diverses

Échappements de caractères

Régulier Le caractère barre oblique inverse ( ) dans une expression indique que le caractère qui la suit est un caractère spécial ou que le caractère doit être interprété littéralement.

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

Classe de caractères

La classe de caractères correspond à n'importe quel caractère d'un ensemble de caractères.

Le tableau suivant répertorie les classes de caractères :

Anchor

Une ancre ou une assertion atomique de largeur nulle entraîne la réussite ou l'échec de la correspondance, en fonction de la position actuelle dans la chaîne, mais elle ne fait pas avancer le moteur dans la chaîne ni utiliser de caractères .

Les points d'ancrage sont listés dans le tableau ci-dessous :

Construction de groupe

La construction de groupe décrit une sous-expression d'une expression régulière et est généralement utilisée pour capturer les sous-chaînes d'une chaîne d'entrée.

Le tableau suivant répertorie les constructions de regroupement :

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}\b";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}

Qualificateur

Qualificateur spécifie combien d'instances de l'élément précédent (qui peut être un caractère, un groupe ou une classe de caractères) doivent être présentes dans la chaîne d'entrée pour un correspond à l'élément qui se produit. Les qualificatifs incluent les éléments linguistiques répertoriés dans le tableau suivant.

Le tableau suivant répertorie les qualificatifs :

Construction de référence arrière

La référence arrière permet l'identification ultérieure de sous-expressions précédemment correspondantes au sein de la même expression régulière.

Le tableau suivant répertorie les constructions de référence arrière :

Constructions alternatives

Les constructions alternatives sont utilisées pour modifier les expressions régulières afin d'activer la correspondance soit/ou.

Le tableau suivant répertorie les constructions alternatives :

Remplacement

Le remplacement est une expression régulière utilisée dans les modèles de remplacement.

Le tableau suivant répertorie les caractères utilisés pour la substitution :

Constructions diverses

Le tableau suivant répertorie les différentes constructions diverses :

Classe Regex

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

Le tableau suivant répertorie certaines méthodes couramment utilisées dans la classe Regex :

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "A Thousand Splendid Suns";

         Console.WriteLine("Matching words that start with 'S': ");
         showMatch(str, @"\bS\S*");
         Console.ReadKey();
      }
   }
}

Matching words that start with 'S':
The 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("The 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();
      }
   }
}

Matching words start with 'm' and ends with 'e':
The Expression: \bm\S*e\b
make
maze
manage
measure