C # regex

Lesexpressions régulières sont un match pour entrer en mode texte..Net Framework fournit permettent à ce moteur d'expressions régulières de match. Motif se compose d'un ou plusieurs caractères, opérateurs et structures.

expression personnalisée régulière

Ci-dessous sont les personnages, les opérateurs, et la structure utilisée pour définir des expressions régulières différentes catégories.

• escape Caractère
• Classes de caractères
• ancre
• Structure du groupe
• qualificateur
• Structure backreferences
• configuration de rechange
• remplacer
• construction Divers

escape Caractère

Régulier caractère expression barre oblique inverse (\) indique que les caractères suivants avec le caractère spécial ou le caractère doivent être interprétés littéralement.

Le tableau suivant présente le caractère d'échappement:

Classes de caractères

Une classe de caractères correspond à tout caractère avec un jeu de caractères.

Le tableau suivant dresse la liste des classes de caractères:

ancre

Point d'ancrage ou un atome zéro largeur assertion correspondront le succès ou l'échec, en fonction de la position actuelle dans la chaîne, mais ils ne font pas usage du moteur vers l'avant ou caractères dans une chaîne.

Le tableau suivant dresse la liste des points d'ancrage:

Structure du groupe

Structure Packet décrit une sous-expression d'expression régulière, généralement utilisé comme entrée de capture d'une chaîne.

Le tableau suivant présente la structure de paquets:

Exemples

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

Exécution instance »

qualificateur

Qualifier spécifié dans la chaîne d'entrée doit exister sur chaque élément (peut être un caractère, un groupe ou une classe de personnage) combien d'instances de comparaître correspondance. Qualifiers y compris les éléments linguistiques énumérés dans le tableau suivant.

Le tableau suivant dresse la liste des qualificatifs:

Structure backreferences

Backreferences autorisés dans la même expression régulière suivie par l'identification du match subexpression précédent.

Le tableau suivant présente la configuration de back-référence:

configuration de rechange

Alternate configuré pour modifier une expression régulière pour permettre soit / ou correspondant.

Le tableau suivant indique la configuration alternative:

remplacer

Remplacer modèle de remplacement d'expression régulière utilisée.

Le tableau suivant présente les caractères utilisés pour le remplacement:

construction Divers

Le tableau suivant présente la construction divers:

classe Regex

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

Le tableau ci-dessous présente une partie de la méthode de la classe Regex commune:

Pour une liste complète des propriétés de classe Regex, voir les documents Microsoft C #.

exemple 1

Les exemples suivants sont jumelés avec 'S' au début du mot:

using System;
en utilisant System.Text.RegularExpressions;

namespace RegExApplication
{
   Programme de classe
   {
      showmatch private static void (texte string, string expr)
      {
         Console.WriteLine ( "L'expression:" + expr);
         MatchCollection mc = Regex.Matches (texte, expr);
         foreach (Match m de mc)
         {
            Console.WriteLine (m);
         }
      }
      static void Main (string [] args)
      {
         chaîne str = "A Thousand Splendid Suns";

         Console.WriteLine ( "mots qui commencent par 'S' Matching:");
         showmatch (str, @ "\ bS \ S *");
         Console.ReadKey ();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:

mots commençant par 'S' Matching:
L'expression: \ bS \ S *
magnifique
Soleils

exemple 2

Les exemples suivants sont jumelés avec 'm' en commençant par «e» à la fin du mot:

using System;
en utilisant System.Text.RegularExpressions;

namespace RegExApplication
{
   Programme de classe
   {
      showmatch private static void (texte string, string expr)
      {
         Console.WriteLine ( "L'expression:" + expr);
         MatchCollection mc = Regex.Matches (texte, expr);
         foreach (Match m de mc)
         {
            Console.WriteLine (m);
         }
      }
      static void Main (string [] args)
      {
         string str = "font labyrinthe et parviennent à le mesurer»;

         Console.WriteLine ( "mots correspondants commencent par« m »et se termine par 'e':");
         showmatch (str, @ "\ bm \ S * e \ b");
         Console.ReadKey ();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:

mots correspondants commencent par «m» et se termine par «e»:
L'expression: \ bm \ S * e \ b
faire
labyrinthe
gérer
mesurer

exemple 3

Les exemples suivants remplacent les espaces supplémentaires:

using System;
en utilisant System.Text.RegularExpressions;

namespace RegExApplication
{
   Programme de classe
   {
      static void Main (string [] args)
      {
         entrée de chaîne = "Bonjour tout le monde";
         cordage = "\\ s +";
         remplacement de chaîne = "";
         Regex rgx = new Regex (motif);
         résultat string = rgx.Replace (entrée, remplacement);

         Console.WriteLine ( "String Original: {0}", entrée);
         Console.WriteLine ( "Chaîne de remplacement: {0}", résultat);    
         Console.ReadKey ();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:

Chaîne d'origine: Bonjour tout le monde   
Chaîne de remplacement: Bonjour tout le monde