C # Regex em exemplos

A tradução do artigo foi preparada especificamente para os alunos do curso "Desenvolvedor C #" .

---

A classe Regex implementa expressões regulares em C #. Neste artigo, você aprenderá como usar o C # Regex para validar várias entradas do usuário.

Regex em C # implementa expressões regulares. A classe C # Regex oferece métodos e propriedades para analisar texto grande, a fim de procurar padrões de caracteres. Neste artigo, você aprenderá como usar a classe .NET Regex em C #.

Expressões regulares

Uma expressão regular é usada para verificar se uma sequência corresponde a um padrão. Uma expressão regular (expressão regular ou regex ou regexp) é uma sequência de caracteres que define um padrão. Um padrão pode consistir em literais, números, caracteres, operadores ou construções. O padrão é usado para encontrar correspondências em uma sequência ou arquivo.
Expressões regulares são frequentemente usadas ao verificar entradas, analisar e localizar cadeias. Por exemplo, verificando uma data de nascimento válida, número de segurança social, nome completo, no qual o nome e o sobrenome são separados por vírgula, pesquisando o número de ocorrências de uma substring, substituindo substrings, formatos de data, formatos de email válidos, formato de moeda e assim por diante.

Regex de classe

No .NET, a classe Regex representa um mecanismo de regex. Ele pode ser usado para analisar rapidamente grandes quantidades de texto para encontrar padrões de caracteres específicos, extrair, editar, substituir ou excluir substrings de texto e adicionar as strings extraídas à coleção para gerar um relatório.

A classe Regex é definida no espaço para nome System.Text.RegularExpressions. O construtor da classe Regex usa como parâmetro uma sequência de modelo junto com outros parâmetros opcionais.

O seguinte trecho de código cria uma expressão regular a partir de um padrão. Aqui, o padrão corresponde a uma palavra que começa com a letra "M".

//    ,     "M" string pattern = @"\b[M]\w+"; //   Regex Regex rg = new Regex(pattern); 

O seguinte fragmento de código contém um texto longo com os nomes dos autores que precisam ser analisados.

 //   string authors = "Mahesh Chand, Raj Kumar, Mike Gold, Allen O'Neill, Marshal Troll"; 

O método Matches é usado para encontrar todas as correspondências em uma expressão regular e retorna um MatchCollection.

 //    MatchCollection matchedAuthors = rg.Matches(authors); 

O próximo trecho de código passa por uma coleção de correspondências.

 //     for (int count = 0; count < matchedAuthors.Count; count++) Console.WriteLine(matchedAuthors[count].Value); 

Aqui está o código completo:

 //    ,     "M" string pattern = @"\b[M]\w+"; //   Regex Regex rg = new Regex(pattern); //   string authors = "Mahesh Chand, Raj Kumar, Mike Gold, Allen O'Neill, Marshal Troll"; //    MatchCollection matchedAuthors = rg.Matches(authors); ///     for (int count = 0; count < matchedAuthors.Count; count++) Console.WriteLine(matchedAuthors[count].Value); 

No exemplo acima, o código procura o caractere "M". Mas e se a palavra começar com "m". O seguinte trecho de código usa o parâmetro RegexOptions.IgnoreCase para que o Regex não faça RegexOptions.IgnoreCase entre maiúsculas e minúsculas.

 //    ,     "M" string pattern = @"\b[m]\w+"; //   Regex Regex rg = new Regex(pattern, RegexOptions.IgnoreCase); 

Substituindo Vários Espaços pelo Regex

O método Regex.Replace() é usado para substituir a sequência correspondente por uma nova. O exemplo a seguir procura vários espaços em uma sequência com uma única.

 //      string badString = "Here is a strig with ton of white space." ; string CleanedString = Regex.Replace(badString, "\\s+", " "); Console.WriteLine($"Cleaned String: {CleanedString}"); 

O seguinte trecho de código substitui os espaços por '-'.

 string CleanedString = Regex.Replace(badString, "\\s+", "-"); 

Dividindo uma sequência em caracteres usando o Regex

No exemplo a seguir, o padrão de expressão regular [az] + e o método Regex.Split() são usados ​​para dividir uma sequência em caracteres, sem distinção entre Regex.Split() .

 //     string azpattern = "[az]+"; string str = "Asd2323b0900c1234Def5678Ghi9012Jklm"; string[] result = Regex.Split(str, azpattern, RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(500)); for (int i = 0; i < result.Length; i++) { Console.Write("'{0}'", result[i]); if (i < result.Length - 1) Console.Write(", "); } 

Expressões regulares em c #

Expressões regulares são o padrão de correspondência de padrões para analisar e alterar cadeias de caracteres e permitem ao usuário expressar como um programa de computador deve procurar o padrão especificado no texto e, em seguida, o que deve fazer quando cada correspondência for encontrada com o padrão fornecido. Às vezes, eles são abreviados como "regex". Eles são uma maneira poderosa de encontrar e modificar seqüências de caracteres que assumem um formato específico.

Aqui está um exemplo simples de código C # que mostra como as expressões regulares são usadas.

 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Text.RegularExpressions; namespace RegularExpression1 { class Program { static void Main(string[] args) { Regex r = new Regex(@"^\+?\d{0,2}\-?\d{4,5}\-?\d{5,6}"); //  Regex    . string[] str = { "+91-9678967101", "9678967101", "+91-9678-967101", "+91-96789-67101", "+919678967101" }; //         . foreach (string s in str) { Console.WriteLine("{0} {1} a valid mobile number.", s, r.IsMatch(s) ? "is" : "is not"); //  IsMatch    ,   ,     . } } } } 

Aqui está uma explicação detalhada de expressões regulares e seu uso em C # e .NET:
Expressões regulares em c #

Regex para verificação de e-mail

Para testar vários endereços de email, podemos usar as seguintes expressões regulares. Separamos os endereços usando o delimitador ';'

^((\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*)\s*[;]{0,1}\s*)+$

Se você deseja usar o delimitador ',' use o seguinte

^((\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*)\s*[,]{0,1}\s*)+$

e se você deseja usar os dois delimitadores ',' e ';' então use isso

^((\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*)\s*[;,.]{0,1}\s*)+$

Assim, usando a expressão regular acima, você pode verificar um ou vários endereços ao mesmo tempo.

Saiba mais aqui: Regex para verificar vários endereços de email .

Validando entrada do usuário com expressões regulares

Este artigo explica como usar expressões regulares (a classe Regex do espaço para nome System.Text.RegularExpressions) em C # e .NET.

Podemos usar o método Regex.Match, que recebe entrada e uma expressão regular e retorna sucesso se

 if (!Regex.Match(firstNameTextBox.Text, "^[AZ][a-zA-Z]*$").Success) {} if (!Regex.Match(addressTextBox.Text, @"^[0-9]+\s+([a-zA-Z]+|[a-zA-Z]+\s[a-zA-Z]+)$").Success) if (!Regex.Match(cityTextBox.Text, @"^([a-zA-Z]+|[a-zA-Z]+\s[a-zA-Z]+)$").Success) if (!Regex.Match(stateTextBox.Text, @"^([a-zA-Z]+|[a-zA-Z]+\s[a-zA-Z]+)$").Success) if (!Regex.Match(zipCodeTextBox.Text, @"^\d{5}$").Success) { if (!Regex.Match(phoneTextBox.Text, @"^[1-9]\d{2}-[1-9]\d{2}-\d{4}$").Success) 

Saiba mais aqui:
Validando entrada do usuário com expressões regulares

Dividir string usando Regex.split (regex) em C #

Nesta parte, aprenderemos como quebrar uma string usando RegEx em C #. Regex quebra uma cadeia de caracteres com base em um padrão. Ele processa o delimitador especificado como um modelo. É por isso que o Regex é melhor que o string.Split. Aqui estão alguns exemplos de como quebrar uma string usando o Regex em C #. Vamos escrever o código.

Para usar o Regex para dividir uma sequência, adicione os seguintes espaços para nome.

 using System; using System.Text.RegularExpressions; using System.Collections.Generic; 

Exemplo 1:

Separe os números das strings usando o Regex.

 string Text = "1 One, 2 Two, 3 Three is good."; string[] digits = Regex.Split(Text, @"\D+"); foreach (string value in digits) { int number; if (int.TryParse(value, out number)) { Console.WriteLine(value); } } 

O código acima quebra a cadeia usando \ D + e gera os números iterando sobre o resultado.

Saiba mais aqui:

Dividir string usando expressões regulares em C #

Substituir caracteres especiais da cadeia de caracteres por regex

Nesta parte, mostrarei como substituir caracteres especiais por expressões regulares em C #.

Se você possui uma sequência com caracteres especiais e deseja removê-los ou substituí-los, pode usar uma expressão regular para isso.

Use o seguinte código:

 Regex.Replace(your String, @"[^0-9a-zA-Z]+", "") 

Este código excluirá todos os caracteres especiais, mas se você não desejar excluir alguns caracteres especiais, por exemplo, a vírgula "," e os dois pontos ":" - faça as seguintes alterações:

 Regex.Replace(Your String, @"[^0-9a-zA-Z:,]+", "") 

Da mesma forma, você pode fazer alterações de acordo com seus requisitos.

Nota:

Deve-se notar que expressões regulares não são uma panacéia para toda pequena manipulação de string. Se você precisar de uma análise simples fornecida pela classe String ou por outras classes, tente usá-lo.

Para leitura adicional

Se você não conhece expressões regulares, recomendo a leitura deste artigo, Introdução às expressões regulares .

Aqui está outro artigo: " Usando expressões regulares em c # "