C# - Expressions régulières

Une expression régulière est un modèle qui pourrait être mis en correspondance avec un texte d'entrée. Le framework .Net fournit un moteur d'expressions régulières qui permet une telle correspondance. Un modèle se compose d'un ou plusieurs caractères littéraux, opérateurs ou constructions.

Constructions pour définir des expressions régulières

Il existe différentes catégories de caractères, d'opérateurs et de constructions qui vous permettent de définir des expressions régulières. Cliquez sur les liens suivants pour trouver ces constructions.

• Les caractères s'échappent

• Classes de personnages

• Ancres

• Regroupement de constructions

• Quantificateurs

• Constructions de référence arrière

• Constructions d'alternance

• Remplacements

• Constructions diverses

La classe Regex

La classe Regex est utilisée pour représenter une expression régulière. Il a les méthodes couramment utilisées suivantes −

public bool IsMatch(chaîne d'entrée)

Indique si l'expression régulière spécifiée dans le constructeur Regex trouve une correspondance dans une chaîne d'entrée spécifiée.

public bool IsMatch(string input, int startat)

Indique si l'expression régulière spécifiée dans le constructeur Regex trouve une correspondance dans la chaîne d'entrée spécifiée, en commençant à la position de départ spécifiée dans la chaîne.

public static bool IsMatch(entrée de chaîne, modèle de chaîne)

Indique si l'expression régulière spécifiée trouve une correspondance dans la chaîne d'entrée spécifiée.

correspondances MatchCollection publiques (entrée de chaîne)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière.

remplacement de chaîne publique (entrée de chaîne, remplacement de chaîne)

Dans une chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à un modèle d'expression régulière par une chaîne de remplacement spécifiée.

chaîne publique[] Split (entrée de chaîne)

Fractionne une chaîne d'entrée en un tableau de sous-chaînes aux positions définies par un modèle d'expression régulière spécifié dans le constructeur Regex.

Sr.No.	Méthodes et description
1
2
3
4
5
6

Pour la liste complète des méthodes et des propriétés, veuillez lire la documentation Microsoft sur C#.

Exemple 1

L'exemple suivant correspond aux mots qui commencent par 'S' −

Démo en direct

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();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −

Matching words that start with 'S':
The Expression: \bS\S*
Splendid
Suns

Exemple 2

L'exemple suivant correspond à des mots qui commencent par 'm' et se terminent par 'e' −

Démo en direct

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();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −

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

Exemple 3

Cet exemple remplace l'espace blanc supplémentaire −

Démo en direct

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("Original String: {0}", input);
         Console.WriteLine("Replacement String: {0}", result);    
         Console.ReadKey();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −

Original String: Hello World   
Replacement String: Hello World