Como verificar se as cadeias de caracteres estão no formato de e-mail válido
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.
