Compartilhar via

Como verificar se cadeias de caracteres estão em um formato de email válido

  • Artigo

O exemplo neste artigo usa uma expressão regular para verificar se uma cadeia de caracteres está em um formato de email válido.

Essa expressão regular é relativamente simples em comparação com o que pode ser usado como um email. Usar uma expressão regular para validar um email é útil para garantir que a estrutura dele está correta. No entanto, essa substituição não verifica se o email realmente existe.

✔️ USE uma expressão regular pequena para verificar a estrutura válida de um email.

✔️ ENVIE um email de teste para o endereço fornecido por um usuário do seu aplicativo.

❌ NÃO use uma expressão regular como a única maneira de validar um email.

Se você tentar criar a expressão regular perfeita para validar se a estrutura de um email está correta, a expressão se tornará tão complexa que será incrivelmente difícil depurar ou melhorar. Expressões regulares não podem validar se existe um email, mesmo que ele esteja estruturado corretamente. A melhor maneira de validar um email é enviar um email de teste para o endereço.

Aviso

Ao usar System.Text.RegularExpressions para processar entradas não confiáveis, passe um tempo limite. Um usuário mal-intencionado pode fornecer entrada para RegularExpressions, causando um ataque de negação de serviço. APIs ASP.NET Core Framework que usam RegularExpressions passam um tempo limite.

Exemplo

O exemplo define um método IsValidEmail, que retornará true se a cadeia de caracteres contiver um endereço de email válido e false se não contiver, mas não realiza outra ação.

Para verificar se o endereço de email é válido, o método IsValidEmail chama o método Regex.Replace(String, String, MatchEvaluator) com o padrão da expressão regular (@)(.+)$ para separar o nome de domínio do endereço de email. O terceiro parâmetro é um representante MatchEvaluator, que representa o método que processa e substitui o texto correspondente. O padrão da expressão regular é interpretado da seguinte maneira:

Padrão Descrição
(@) Coincida o caractere @. Essa parte é o primeiro grupo de captura.
(.+) Coincida uma ou mais ocorrências de qualquer caractere. Essa parte é o segundo grupo de captura.
$ Encerrar a correspondência ao final da cadeia de caracteres.

O nome de domínio, juntamente com o caractere @, é passado para o método DomainMapper. O método usa a classe IdnMapping para traduzir caracteres Unicode que estão fora do intervalo de caracteres US-ASCII para Punycode. O método também define o sinalizador invalid como True, caso o método IdnMapping.GetAscii detecte algum caractere inválido no nome do domínio. O método retorna o nome de domínio Punycode precedido pelo símbolo @ para o método IsValidEmail.

Dica

É recomendável que você use o padrão de expressão regular simples (@)(.+)$ para normalizar o domínio e retornar um valor que indica que ele passou ou falhou. No entanto, o exemplo neste artigo descreve como usar ainda mais uma expressão regular para validar o email. Independentemente de como você valida um email, você sempre deve enviar um email de teste para o endereço a fim de verificar se ele existe.

Em seguida, o método IsValidEmail chama o método Regex.IsMatch(String, String) para verificar se o endereço está adequado para um padrão de expressão regular.

O método IsValidEmail apenas determina se o formato de email é válido para um endereço de email; ele não valida se o email existe. Além disso, o método IsValidEmail não verifica se o nome de domínio primário é um nome de domínio válido listado no IANA Root Zone Database (Banco de dados de zona raiz da IANA), o que exigiria uma operação de pesquisa.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

namespace RegexExamples
{
    class RegexUtilities
    {
        public static bool IsValidEmail(string email)
        {
            if (string.IsNullOrWhiteSpace(email))
                return false;

            try
            {
                // Normalize the domain
                email = Regex.Replace(email, @"(@)(.+)$", DomainMapper,
                                      RegexOptions.None, TimeSpan.FromMilliseconds(200));

                // Examines the domain part of the email and normalizes it.
                string DomainMapper(Match match)
                {
                    // Use IdnMapping class to convert Unicode domain names.
                    var idn = new IdnMapping();

                    // Pull out and process domain name (throws ArgumentException on invalid)
                    string domainName = idn.GetAscii(match.Groups[2].Value);

                    return match.Groups[1].Value + domainName;
                }
            }
            catch (RegexMatchTimeoutException e)
            {
                return false;
            }
            catch (ArgumentException e)
            {
                return false;
            }

            try
            {
                return Regex.IsMatch(email,
                    @"^[^@\s]+@[^@\s]+\.[^@\s]+$",
                    RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250));
            }
            catch (RegexMatchTimeoutException)
            {
                return false;
            }
        }
    }
}

Imports System.Globalization
Imports System.Text.RegularExpressions

Public Class RegexUtilities
    Public Shared Function IsValidEmail(email As String) As Boolean

        If String.IsNullOrWhiteSpace(email) Then Return False

        ' Use IdnMapping class to convert Unicode domain names.
        Try
            'Examines the domain part of the email and normalizes it.
            Dim DomainMapper =
                Function(match As Match) As String

                    'Use IdnMapping class to convert Unicode domain names.
                    Dim idn = New IdnMapping

                    'Pull out and process domain name (throws ArgumentException on invalid)
                    Dim domainName As String = idn.GetAscii(match.Groups(2).Value)

                    Return match.Groups(1).Value & domainName

                End Function

            'Normalize the domain
            email = Regex.Replace(email, "(@)(.+)$", DomainMapper,
                                  RegexOptions.None, TimeSpan.FromMilliseconds(200))

        Catch e As RegexMatchTimeoutException
            Return False

        Catch e As ArgumentException
            Return False

        End Try

        Try
            Return Regex.IsMatch(email,
                                 "^[^@\s]+@[^@\s]+\.[^@\s]+$",
                                 RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250))

        Catch e As RegexMatchTimeoutException
            Return False

        End Try

    End Function
End Class

Neste exemplo, o padrão de expressão regular ^[^@\s]+@[^@\s]+\.[^@\s]+$ é interpretado conforme mostrado na tabela a seguir. A expressão regular é compilada com o sinalizador RegexOptions.IgnoreCase.

Padrão Descrição
^ Comece a correspondência no início da cadeia de caracteres.
[^@\s]+ Corresponda uma ou mais ocorrências de qualquer caractere que não seja o caractere @ ou o espaço em branco.
@ Coincida o caractere @.
[^@\s]+ Corresponda uma ou mais ocorrências de qualquer caractere que não seja o caractere @ ou o espaço em branco.
\. Corresponda a um único caractere de ponto.
[^@\s]+ Corresponda uma ou mais ocorrências de qualquer caractere que não seja o caractere @ ou o espaço em branco.
$ Encerrar a correspondência ao final da cadeia de caracteres.

Importante

Essa expressão regular não se destina a abranger todos os aspectos de um endereço de email válido. Ela é fornecida como um exemplo para você estender conforme necessário.

Confira também