Aplicações Práticas de Expressões Regulares para Validação em Csharp

Introdução às Expressões Regulares

Expressões regulares (regex) são uma poderosa ferramenta para trabalhar com padrões de texto. Elas permitem realizar buscas, substituições e validações de forma eficiente e flexível, sendo amplamente utilizadas em linguagens de programação como C#. Neste artigo, exploraremos algumas aplicações práticas de expressões regulares para validação de dados em C#.

As expressões regulares são utilizadas em diversas áreas da programação, desde a validação de entradas de usuários até a análise de grandes volumes de dados textuais. A capacidade de definir padrões complexos de forma concisa torna as expressões regulares uma ferramenta indispensável para desenvolvedores que desejam garantir a integridade dos dados em suas aplicações.

Compreender como funcionam as expressões regulares e como aplicá-las corretamente em C# pode economizar tempo e reduzir a quantidade de código necessário para realizar tarefas comuns de validação. Durante este artigo, veremos exemplos práticos que ilustram como validar diferentes tipos de dados, como endereços de e-mail, números de telefone, CPF, URLs, senhas, datas, códigos postais, e muito mais.

Validação de Endereços de E-mail

A validação de endereços de e-mail é uma das aplicações mais comuns de expressões regulares. Um e-mail válido deve seguir um padrão específico que inclui caracteres alfanuméricos, pontos, e o símbolo '@'. Abaixo está um exemplo de como validar um endereço de e-mail usando C#.

using System;
using System.Text.RegularExpressions;

public class EmailValidator
{
    public static void Main()
    {
        string email = "exemplo@dominio.com";
        string pattern = @"^[^@\s]+@[^@\s]+\.[^@\s]+$";
        
        bool isValid = Regex.IsMatch(email, pattern);
        Console.WriteLine($"O e-mail '{email}' é válido? {isValid}");
    }
}

O padrão regex utilizado aqui, ^[^@\s]+@[^@\s]+\.[^@\s]+$, funciona da seguinte forma (MOZILLA, 2025):

• ^: Indica o início da string.
• [^@\s]+: Um ou mais caracteres que não são '@' ou espaços.
• @: O caractere '@' que separa o nome do domínio.
• [^@\s]+: Mais uma vez, um ou mais caracteres que não são '@' ou espaços, representando o domínio.
• \.: Um ponto, que separa o domínio da extensão.
• [^@\s]+: Um ou mais caracteres que não são espaços ou '@', representando a extensão do domínio.
• $: Indica o final da string.

Validação de Números de Telefone

Validar números de telefone pode ser desafiador devido às diferentes formatações. Uma expressão regular pode ser criada para aceitar diversos formatos. O exemplo abaixo valida números de telefone no formato (xx) xxxx-xxxx ou (xx) xxxxx-xxxx.

using System;
using System.Text.RegularExpressions;

public class PhoneValidator
{
    public static void Main()
    {
        string phone = "(12) 3456-7890";
        string pattern = @"^\(\d{2}\) \d{4,5}-\d{4}$";
        
        bool isValid = Regex.IsMatch(phone, pattern);
        Console.WriteLine($"O telefone '{phone}' é válido? {isValid}");
    }
}

A expressão regular ^\(\d{2}\) \d{4,5}-\d{4}$ funciona da seguinte maneira:

• ^: Início da string.
• \(\d{2}\): Dois dígitos entre parênteses para o código de área.
• : Um espaço.
• \d{4,5}: Quatro ou cinco dígitos, representando o número do telefone.
• -: Um traço que separa o número do telefone do restante.
• \d{4}: Quatro dígitos finais do número de telefone.
• $: Final da string.

Validação de CPF

No Brasil, o CPF (Cadastro de Pessoas Físicas) é um documento importante e sua validação é essencial. A seguir está um exemplo de como validar um CPF usando expressões regulares, considerando a formatação com pontos e traços (ALURA, 2025).

using System;
using System.Text.RegularExpressions;

public class CPFValidator
{
    public static void Main()
    {
        string cpf = "123.456.789-09";
        string pattern = @"^\d{3}\.\d{3}\.\d{3}-\d{2}$";
        
        bool isValid = Regex.IsMatch(cpf, pattern);
        Console.WriteLine($"O CPF '{cpf}' é válido? {isValid}");
    }
}

A expressão regular ^\d{3}\.\d{3}\.\d{3}-\d{2}$ é composta por:

• ^: Início da string.
• \d{3}: Três dígitos para o primeiro bloco do CPF.
• \.: Um ponto.
• \d{3}: Três dígitos para o segundo bloco do CPF.
• \.: Outro ponto.
• \d{3}: Três dígitos para o terceiro bloco do CPF.
• -: Um traço.
• \d{2}: Dois dígitos que formam a parte final do CPF.
• $: Final da string.

Validação de URLs

Validar URLs é outra tarefa comum. Uma expressão regular pode ser usada para verificar se uma string é uma URL válida. O exemplo abaixo valida URLs que começam com http:// ou https://.

using System;
using System.Text.RegularExpressions;

public class URLValidator
{
    public static void Main()
    {
        string url = "https://www.exemplo.com";
        string pattern = @"^(http|https)://[^\s/$.?#].[^\s]*$";
        
        bool isValid = Regex.IsMatch(url, pattern);
        Console.WriteLine($"A URL '{url}' é válida? {isValid}");
    }
}

A expressão regular ^(http|https)://[^\s/$.?#].[^\s]*$ é explicada da seguinte forma:

• ^: Início da string.
• (http|https): O protocolo da URL, que pode ser 'http' ou 'https'.
• ://: Literal que indica o início do endereço após o protocolo.
• [^\s/$.?#]: Qualquer caractere que não seja espaço em branco ou um dos caracteres especiais mencionados, que inicia o domínio.
• .: Um caractere qualquer após o domínio.
• [^\s]*: Qualquer sequência de caracteres que não contenha espaços, permitindo a captura de parâmetros e caminhos.
• $: Final da string.

Validação de Senhas

A validação de senhas é crucial para a segurança. Uma senha forte pode exigir uma combinação de letras maiúsculas, minúsculas, números e caracteres especiais. O exemplo a seguir valida uma senha com pelo menos 8 caracteres, incluindo pelo menos uma letra maiúscula, uma letra minúscula, um número e um caractere especial.

using System;
using System.Text.RegularExpressions;

public class PasswordValidator
{
    public static void Main()
    {
        string password = "Senha@123";
        string pattern = @"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$";
        
        bool isValid = Regex.IsMatch(password, pattern);
        Console.WriteLine($"A senha '{password}' é válida? {isValid}");
    }
}

A expressão regular ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$ é um pouco mais complexa e pode ser detalhada assim:

• ^: Início da string.
• (?=.*[a-z]): Asserts que a string contém pelo menos uma letra minúscula.
• (?=.*[A-Z]): Asserts que a string contém pelo menos uma letra maiúscula.
• (?=.*\d): Asserts que a string contém pelo menos um dígito.
• (?=.*[@$!%*?&]): Asserts que a string contém pelo menos um caractere especial.
• [A-Za-z\d@$!%*?&]{8,}: Permite qualquer combinação de letras, números e caracteres especiais, com um mínimo de 8 caracteres.
• $: Final da string.

Validação de Datas

Validação de datas pode ser complexa, principalmente ao lidar com diferentes formatos. A expressão regular abaixo valida datas no formato DD/MM/AAAA, garantindo que os dias e meses sejam válidos.

using System;
using System.Text.RegularExpressions;

public class DateValidator
{
    public static void Main()
    {
        string date = "31/12/2023";
        string pattern = @"^(0[1-9]|[12][0-9]|3[01])/(0[1-9]|1[0-2])/\d{4}$";
        
        bool isValid = Regex.IsMatch(date, pattern);
        Console.WriteLine($"A data '{date}' é válida? {isValid}");
    }
}

A expressão regular ^(0[1-9]|[12][0-9]|3[01])/(0[1-9]|1[0-2])/\d{4}$ é dividida em partes:

• ^: Início da string.
• (0[1-9]|[12][0-9]|3[01]): Pode ser um número de dois dígitos representando o dia, onde:
• 0[1-9]: Dias de 01 a 09.
• [12][0-9]: Dias de 10 a 29.
• 3[01]: Dias 30 e 31.
• /: Separador de dia e mês.
• (0[1-9]|1[0-2]): Representa o mês, onde:
• 0[1-9]: Meses de 01 a 09.
• 1[0-2]: Meses 10 a 12.
• /\d{4}: Quatro dígitos que representam o ano.
• $: Final da string.

Validação de Códigos Postais

Os códigos postais podem variar em formato dependendo do país. No Brasil, o formato é 00000-000. Abaixo, um exemplo de validação de código postal utilizando expressões regulares.

using System;
using System.Text.RegularExpressions;

public class PostalCodeValidator
{
    public static void Main()
    {
        string postalCode = "12345-678";
        string pattern = @"^\d{5}-\d{3}$";
        
        bool isValid = Regex.IsMatch(postalCode, pattern);
        Console.WriteLine($"O código postal '{postalCode}' é válido? {isValid}");
    }
}

A expressão regular ^\d{5}-\d{3}$ pode ser analisada da seguinte forma:

• ^: Início da string.
• \d{5}: Cinco dígitos que representam a primeira parte do código postal.
• -: Um traço que separa as duas partes do código postal.
• \d{3}: Três dígitos que representam a segunda parte do código postal.
• $: Final da string.

Validação de Números Inteiros e Decimais

Validação de números inteiros e decimais também pode ser realizada com expressões regulares. O exemplo abaixo valida números que podem ter um sinal de mais ou menos, e podem ser inteiros ou decimais.

using System;
using System.Text.RegularExpressions;

public class NumberValidator
{
    public static void Main()
    {
        string number = "-123.456";
        string pattern = @"^[+-]?\d+(\.\d+)?$";
        
        bool isValid = Regex.IsMatch(number, pattern);
        Console.WriteLine($"O número '{number}' é válido? {isValid}");
    }
}

A expressão regular ^[+-]?\d+(\.\d+)?$ é composta por:

• ^: Início da string.
• [+-]?: Um sinal de mais ou menos, que é opcional.
• \d+: Um ou mais dígitos que representam a parte inteira do número.
• (\.\d+)?: Um grupo opcional que representa a parte decimal, começando com um ponto.
• $: Final da string.

Conclusão

As expressões regulares são uma ferramenta poderosa para validação de dados em C#. Elas permitem criar soluções eficientes e flexíveis para uma variedade de formatos de entrada. Através dos exemplos apresentados, é possível perceber como as expressões regulares podem simplificar o processo de validação, tornando-o mais seguro e confiável.

É fundamental, no entanto, que os desenvolvedores compreendam as limitações e os desafios associados ao uso de expressões regulares, garantindo que sejam aplicadas corretamente em seus projetos. Embora as expressões regulares possam ser muito úteis, elas também podem se tornar complexas e difíceis de entender, especialmente quando se tenta validar dados que possuem muitas variações possíveis.

Além disso, é importante considerar que a validação através de expressões regulares não deve ser a única linha de defesa em um aplicativo. Devem ser implementadas outras formas de validação e sanitização de dados, especialmente quando se lida com entradas de usuários que podem ser manipuladas maliciosamente. O uso de expressões regulares deve ser parte de uma abordagem abrangente de segurança e integridade de dados.

Por fim, ao implementar validações em suas aplicações, é recomendável testar extensivamente as expressões regulares para garantir que todos os casos de uso desejados sejam tratados adequadamente, evitando falsos positivos e negativos. Isso não apenas melhora a confiabilidade do sistema, mas também proporciona uma melhor experiência ao usuário.