Como verificar se as cadeias de caracteres estão no formato de e-mail válido

  • Artigo

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

Esta expressão regular é comparativamente simples ao que realmente pode ser usado como um e-mail. Usar uma expressão regular para validar um e-mail é útil para garantir que a estrutura de um e-mail esteja correta. No entanto, não é um substituto para verificar se o e-mail realmente existe.

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

✔️ ENVIE um e-mail 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 e-mail.

Se você tentar criar a expressão regular perfeita para validar que a estrutura de um e-mail está correta, a expressão se torna tão complexa que é incrivelmente difícil depurar ou melhorar. Expressões regulares não podem validar a existência de um e-mail, mesmo que ele esteja estruturado corretamente. A melhor maneira de validar um e-mail é enviar um e-mail 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 RegularExpressionso , causando um ataque de Negação de Serviço. ASP.NET APIs da estrutura principal que usam RegularExpressions passar um tempo limite.

Exemplo

O exemplo define um IsValidEmail método, que retorna true se a cadeia de caracteres contiver um endereço de e-mail válido e false se não contiver, mas não executar nenhuma outra ação.

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

Padrão Description
(@) Corresponda ao caractere @. Esta parte é o primeiro grupo de captura.
(.+) Corresponder a uma ou mais ocorrências de qualquer personagem. Esta parte é o segundo grupo de captura.
$ Termine a partida no final da string.

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

Gorjeta

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

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

O IsValidEmail método apenas determina se o formato de e-mail é válido para um endereço de e-mail, não valida que o e-mail existe. Além disso, o IsValidEmail método não verifica se o nome de domínio de nível superior é um nome de domínio válido listado no banco de dados de zona raiz 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 ^[^@\s]+@[^@\s]+\.[^@\s]+$ de expressão regular é interpretado como mostrado na tabela a seguir. A expressão regular é compilada usando o RegexOptions.IgnoreCase sinalizador.

Padrão Description
^ Comece a partida no início da string.
[^@\s]+ Corresponder a uma ou mais ocorrências de qualquer caractere diferente do caractere @ ou espaço em branco.
@ Corresponda ao caractere @.
[^@\s]+ Corresponder a uma ou mais ocorrências de qualquer caractere diferente do caractere @ ou espaço em branco.
\. Corresponder a um único caractere de período.
[^@\s]+ Corresponder a uma ou mais ocorrências de qualquer caractere diferente do caractere @ ou espaço em branco.
$ Termine a partida no final da string.

Importante

Esta expressão regular não se destina a cobrir todos os aspetos de um endereço de e-mail válido. Ele é fornecido como um exemplo para você estender conforme necessário.

Consulte também