C #: espressioni regolari

UN regular expressionè un modello che potrebbe essere confrontato con un testo di input. Il framework .Net fornisce un motore di espressioni regolari che consente tale corrispondenza. Un modello è costituito da uno o più caratteri letterali, operatori o costrutti.

Costrutti per la definizione di espressioni regolari

Esistono varie categorie di caratteri, operatori e costrutti che consentono di definire espressioni regolari. Fare clic sui collegamenti seguenti per trovare questi costrutti.

La classe Regex

La classe Regex viene utilizzata per rappresentare un'espressione regolare. Ha i seguenti metodi comunemente usati:

Sr.No. Metodi e descrizione
1

public bool IsMatch(string input)

Indica se l'espressione regolare specificata nel costruttore Regex trova una corrispondenza in una stringa di input specificata.
2

public bool IsMatch(string input, int startat)

Indica se l'espressione regolare specificata nel costruttore Regex trova una corrispondenza nella stringa di input specificata, a partire dalla posizione iniziale specificata nella stringa.
3

public static bool IsMatch(string input, string pattern)

Indica se l'espressione regolare specificata trova una corrispondenza nella stringa di input specificata.
4

public MatchCollection Matches(string input)

Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare.
5

public string Replace(string input, string replacement)

In una stringa di input specificata, sostituisce tutte le stringhe che corrispondono a un modello di espressione regolare con una stringa di sostituzione specificata.
6

public string[] Split(string input)

Divide una stringa di input in una matrice di sottostringhe nelle posizioni definite da un modello di espressione regolare specificato nel costruttore Regex.

Per l'elenco completo di metodi e proprietà, leggi la documentazione Microsoft su C #.

Esempio 1

L'esempio seguente trova parole che iniziano con "S" -

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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

Esempio 2

L'esempio seguente trova le parole che iniziano con "m" e terminano con "e" -

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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

Esempio 3

Questo esempio sostituisce lo spazio bianco aggiuntivo -

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Original String: Hello World   
Replacement String: Hello World