C # - Expresiones regulares

UN regular expressiones un patrón que se puede comparar con un texto de entrada. El marco .Net proporciona un motor de expresiones regulares que permite dicha coincidencia. Un patrón consta de uno o más caracteres, operadores o construcciones.

Construcciones para definir expresiones regulares

Hay varias categorías de caracteres, operadores y construcciones que le permiten definir expresiones regulares. Haga clic en los siguientes enlaces para encontrar estas construcciones.

La clase Regex

La clase Regex se utiliza para representar una expresión regular. Tiene los siguientes métodos de uso común:

No Señor. Métodos y descripción
1

public bool IsMatch(string input)

Indica si la expresión regular especificada en el constructor Regex encuentra una coincidencia en una cadena de entrada especificada.
2

public bool IsMatch(string input, int startat)

Indica si la expresión regular especificada en el constructor Regex encuentra una coincidencia en la cadena de entrada especificada, comenzando en la posición inicial especificada en la cadena.
3

public static bool IsMatch(string input, string pattern)

Indica si la expresión regular especificada encuentra una coincidencia en la cadena de entrada especificada.
4

public MatchCollection Matches(string input)

Busca en la cadena de entrada especificada todas las apariciones de una expresión regular.
5

public string Replace(string input, string replacement)

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con un patrón de expresión regular con una cadena de reemplazo especificada.
6

public string[] Split(string input)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado en el constructor Regex.

Para obtener la lista completa de métodos y propiedades, lea la documentación de Microsoft en C #.

Ejemplo 1

El siguiente ejemplo coincide con palabras que comienzan 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();
      }
   }
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

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

Ejemplo 2

El siguiente ejemplo coincide con palabras que comienzan con 'm' y terminan 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();
      }
   }
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

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

Ejemplo 3

Este ejemplo reemplaza el espacio en blanco adicional:

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

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Original String: Hello World   
Replacement String: Hello World