Como verificar se as cadeias de caracteres estão no formato de email válido

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

Esta expressão regular é relativamente simples em comparação com o que pode realmente ser usado como um endereço de e-mail. Usar uma expressão regular para validar um email é útil para garantir que a estrutura de um email esteja correta. No entanto, não é uma substituição para verificar se o email realmente existe.

✔️ USE uma pequena expressão regular 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 que a estrutura de um email está correta, a expressão se tornará tão complexa que é incrivelmente difícil depurar ou melhorar. Expressões regulares não podem validar se um email existe, mesmo se ele estiver estruturado corretamente. A melhor maneira de validar um email é enviar um email de teste para o endereço.

Example

O exemplo define um IsValidEmail método, que retorna true se a cadeia de caracteres contiver um endereço de email válido e false se não o fizer, mas não tomar 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 maneira:

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 sinalizador invalid como True se o método IdnMapping.GetAscii detectar 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.

O método IsValidEmail então chama o método Regex.IsMatch(String, String) para verificar se o endereço corresponde a um padrão de expressão regular.

O IsValidEmail método 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 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 conforme mostrado na tabela a seguir. A expressão regular é compilada usando o RegexOptions.IgnoreCase sinalizador.

Consulte também

• Expressões regulares do .NET
• Até onde se deve levar a validação de endereço de email?