Expressão Regular do C#

Expressão regular É um padrão de correspondência para o texto de entrada.

A framework .Net oferece um motor de expressão regular que permite essa correspondência.

O padrão é composto por um ou mais caracteres, operadores e estruturas.

Definição de expressão regular

A seguir está listado os caracteres, operadores e estruturas usados para definir os tipos de expressões regulares.

• Escapamento de caractere

• Classe de caractere

• Ponto de referência

• Construção de grupo

• Limitador

• Construção de referência inversa

• Construção alternativa

• Replacement

• Miscellaneous constructions

Escapamento de caractere

O caractere de barra invertida (\) no expressão regular indica que o caractere subsequente é um caractere especial ou deve ser interpretado literalmente.

A tabela a seguir lista os caracteres de escape:

Classe de caractere

A classe de caractere coincide com qualquer caractere de um grupo de caracteres.

A tabela a seguir lista as classes de caractere:

Ponto de referência

Os pontos de referência ou as afirmações de zero largura podem fazer com que a correspondência seja bem-sucedida ou falhada, dependendo da posição atual na string, mas eles não farão com que o motor avançe na string ou use caracteres.

A tabela a seguir lista os pontos de referência:

Construção de grupo

Construções de grupo descrevem subexpressões de expressões regulares, geralmente usadas para capturar substrings de strings de entrada.

A tabela a seguir lista as construções de grupo:

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};
　　　　　　foreach　(Match　match　in　Regex.Matches(input,　pattern))
　　　　　　　　　Console.WriteLine(match.Value);
　　　}
}

Executar exemplo »

Limitador

Os limitadores especificam quantas instâncias do elemento anterior (pode ser caractere, grupo ou classe de caracteres) devem existir na string de entrada para que o item coincida. Os limitadores incluem os elementos linguísticos listados na tabela a seguir.

A tabela a seguir lista os limitadores:

Construção de referência inversa

As referências inversas permitem identificar subexpressões que coincidiram anteriormente dentro da mesma expressão regular.

A tabela a seguir lista as construções de referência inversa:

Construção alternativa

Construções alternativas são usadas para modificar a expressão regular para habilitar either/ou coincidir.

A tabela a seguir lista as construções alternativas:

Replacement

Replacement is the regular expression used in the replacement pattern.

The following table lists characters used for replacement:

Miscellaneous constructions

The following table lists various miscellaneous constructions:

\b#Coincide com palavras que começam com A

Classe Regex

A classe Regex é usada para representar uma expressão regular.

Para obter uma lista completa de propriedades da classe Regex, consulte a documentação do C# da Microsoft.

Exemplo 1

O exemplo a seguir coincide com palavras que começam com 'S':

Palavras que começam com 'S':
A Expressão: \bS\S*
Splendid
Suns

using System;
using System.Text.RegularExpressions;
namespace RegExApplication
{
　　　class Program
　　　{
　　　　　　private static void showMatch(string text, string expr)
　　　　　　{
　　　　　　　　　Console.WriteLine("A Expressão: "　+　expr);
　　　　　　　　　MatchCollection mc = Regex.Matches(text, expr);
　　　　　　　　　foreach (Match m in mc)
　　　　　　　　　{
　　　　　　　　　　　　Console.WriteLine(m);
　　　　　　　　　}
　　　　　　}
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　string str = "fazer labirinto e gerenciar para medir ele";
　　　　　　　　　Console.WriteLine("Palavras que começam com 'm' e terminam com 'e':");
　　　　　　　　　showMatch(str, @"\bm\S*e\b");
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Palavras que começam com 'm' e terminam com 'e':
A Expressão: \bm\S*e\b
fazer
labirinto
gerenciar
medir

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("Cadeia Original: {0}", input)
　　　　　　　　　Console.WriteLine("Cadeia de Substituição: {0}", result);　　　　
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Cadeia Original: Hello      World　　　
Cadeia de Substituição: Hello World