C# código para validar o endereço de E-mail
Qual é o código mais elegante para validar que um texto é um endereço de E-mail válido?
30 answers
bool IsValidEmail(string email)
{
try {
var addr = new System.Net.Mail.MailAddress(email);
return addr.Address == email;
}
catch {
return false;
}
}
Para clarificar, a questão é saber se uma determinada string é uma representação válida de um endereço de E-mail, não se um endereço de E-mail é um destino válido para enviar uma mensagem. Para isso, a única maneira real é enviar uma mensagem para confirmar.
Note que os endereços de E-mail são mais indulgentes do que você poderia imaginar. Todas estas formas são perfeitamente válidas:- cog@wheel
- " cogwheel the laranja " @example.com
- 123@$.xyz
Para a maioria dos casos de uso, um falso " inválido "é muito pior para os seus utilizadores e a prova futura do que um falso"válido". Aqui está um artigo que costumava ser a resposta aceita a esta pergunta (essa resposta já foi suprimida). Tem muito mais detalhes e algumas outras ideias de como resolver o problema.
Fornecer verificações de sanidade ainda é uma boa ideia para a experiência do utilizador. Assumindo que o endereço de E-mail é válido, Você pode procurar domínios de topo conhecidos, verificar o domínio para um registo MX, verificar se há erros ortográficos de nomes de domínio comuns (gmail.cmo), etc. Em seguida, apresentar um aviso dando ao usuário a chance de dizer "sim, meu servidor de E-mail realmente permite como um endereço de E-mail."Quanto a usar o tratamento de excepções para a lógica empresarial, concordo que isso é algo a evitar. Mas este é um daqueles casos em que a conveniência e a clareza podem superar o dogma. Além disso, se fizeres mais alguma coisa com o ... o endereço de E-mail deve envolver transformá-lo num endereço de E-mail. Mesmo que você não use esta função exata, você provavelmente vai querer usar o mesmo padrão. Você também pode verificar para tipos específicos de falha, capturando diferentes exceções: formato nulo, vazio ou inválido.
{[[2]} de acordo com o comentário de Stuart, isto compara o endereço final com o texto original em vez de sempre retornar verdadeiro. O endereço de correio tenta processar um texto com espaços em "nome de visualização" e Porções de "Address", então a versão original estava retornando falsos positivos.
--- outra leitura - - -
using System.ComponentModel.DataAnnotations;
class ValidateSomeEmails
{
static void Main(string[] args)
{
var foo = new EmailAddressAttribute();
bool bar;
bar = foo.IsValid("[email protected]"); //true
bar = foo.IsValid("[email protected]"); //true
bar = foo.IsValid("[email protected]"); //true
bar = foo.IsValid("[email protected]"); //true
bar = foo.IsValid("fdsa"); //false
bar = foo.IsValid("fdsa@"); //false
bar = foo.IsValid("fdsa@fdsa"); //false
bar = foo.IsValid("fdsa@fdsa."); //false
//one-liner
if (new EmailAddressAttribute().IsValid("[email protected]"))
bar = true;
}
}
. net 4.5 Adicionado Sistema.ComponentModel.Anotações de dados.Endereço electrónico
Pode navegar na fonte do EmailAddressAttribute, Este é o Regex que usa internamente:
const string pattern = @"^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$";
bool isValid = Validator.EmailIsValid(emailString);
Aqui está a classe:
using System.Text.RegularExpressions;
public static class Validator
{
static Regex ValidEmailRegex = CreateValidEmailRegex();
/// <summary>
/// Taken from http://haacked.com/archive/2007/08/21/i-knew-how-to-validate-an-email-address-until-i.aspx
/// </summary>
/// <returns></returns>
private static Regex CreateValidEmailRegex()
{
string validEmailPattern = @"^(?!\.)(""([^""\r\\]|\\[""\r\\])*""|"
+ @"([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)"
+ @"@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$";
return new Regex(validEmailPattern, RegexOptions.IgnoreCase);
}
internal static bool EmailIsValid(string emailAddress)
{
bool isValid = ValidEmailRegex.IsMatch(emailAddress);
return isValid;
}
}
Uso este método de revestimento único que faz o trabalho para mim -
using System.ComponentModel.DataAnnotations;
public bool IsValidEmail(string source)
{
return new EmailAddressAttribute().IsValid(source);
}
public static bool emailIsValid(string email)
{
string expresion;
expresion = "\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
if (Regex.IsMatch(email, expresion))
{
if (Regex.Replace(email, expresion, string.Empty).Length == 0)
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
Pode ter esta função estática numa classe geral.
A maneira mais elegante é usar os métodos do. Net.
Estes métodos:
São testados e testados. Estes métodos são utilizados nos meus próprios projectos profissionais.
Use expressões regulares internamente, que são confiáveis e rápidas.
Feito pela Microsoft para C#. Não há necessidade de reinventar a roda.
Devolver um resultado bool. True significa que o email é válido.
Para usuários do. Net 4.5 e maior
Adicione esta referência ao seu projecto:
Sistema.ComponentModel.DataAnnotations
Agora pode usar o seguinte código:
(new EmailAddressAttribute().IsValid("[email protected]"));
Exemplo de Utilização
Aqui estão alguns métodos para declarar:protected List<string> GetRecipients() // Gets recipients from TextBox named `TxtRecipients`
{
List<string> MethodResult = null;
try
{
List<string> Recipients = TxtRecipients.Text.Replace(",",";").Replace(" ", "").Split(';').ToList();
List<string> RecipientsCleaned = new List<string>();
foreach (string Recipient in RecipientsCleaned)
{
if (!String.IsNullOrWhiteSpace(Recipient))
{
RecipientsNoBlanks.Add(Recipient);
}
}
MethodResult = RecipientsNoBlanks;
}
catch//(Exception ex)
{
//ex.HandleException();
}
return MethodResult;
}
public static bool IsValidEmailAddresses(List<string> recipients)
{
List<string> InvalidAddresses = GetInvalidEmailAddresses(recipients);
return InvalidAddresses != null && InvalidAddresses.Count == 0;
}
public static List<string> GetInvalidEmailAddresses(List<string> recipients)
{
List<string> MethodResult = null;
try
{
List<string> InvalidEmailAddresses = new List<string>();
foreach (string Recipient in recipients)
{
if (!(new EmailAddressAttribute().IsValid(Recipient)) && !InvalidEmailAddresses.Contains(Recipient))
{
InvalidEmailAddresses.Add(Recipient);
}
}
MethodResult = InvalidEmailAddresses;
}
catch//(Exception ex)
{
//ex.HandleException();
}
return MethodResult;
}
...e código que os demonstra em ação:
List<string> Recipients = GetRecipients();
bool IsValidEmailAddresses = IsValidEmailAddresses(Recipients);
if (IsValidEmailAddresses)
{
//Emails are valid. Your code here
}
else
{
StringBuilder sb = new StringBuilder();
sb.Append("The following addresses are invalid:");
List<string> InvalidEmails = GetInvalidEmailAddresses(Recipients);
foreach (string InvalidEmail in InvalidEmails)
{
sb.Append("\n" + InvalidEmail);
}
MessageBox.Show(sb.ToString());
}
Além disso, este exemplo:
- estende-se para além da especificação, uma vez que uma única cadeia é usada para conter 0, um ou muitos endereços de E-mail gerados por um ponto-vírgula
;. - demonstra claramente como usar o método IsValid do objecto EmailAddressAttribute.
Alternativa, para os usuários de uma versão de. Net inferior a 4.5
Para situações em que a. Net 4. 5 não está disponível, utilizo a seguinte solução:
Especificamente, eu uso:
public static bool IsValidEmailAddress(string emailAddress)
{
bool MethodResult = false;
try
{
MailAddress m = new MailAddress(emailAddress);
MethodResult = m.Address == emailAddress;
}
catch //(Exception ex)
{
//ex.HandleException();
}
return MethodResult;
}
public static List<string> GetInvalidEmailAddresses(List<string> recipients)
{
List<string> MethodResult = null;
try
{
List<string> InvalidEmailAddresses = new List<string>();
foreach (string Recipient in recipients)
{
if (!IsValidEmail(Recipient) && !InvalidEmailAddresses.Contains(Recipient))
{
InvalidEmailAddresses.Add(Recipient);
}
}
MethodResult = InvalidEmailAddresses;
}
catch //(Exception ex)
{
//ex.HandleException();
}
return MethodResult;
}
Acho que este regex é uma boa troca entre verificar algo mais do que apenas a marca@, e aceitar casos estranhos:
^[^@\s]+@[^@\s]+(\.[^@\s]+)+$
Vai pelo menos fazer-te colocar algo à volta da marca@, e colocar pelo menos um domínio de aparência normal.
Código curto e preciso
public static bool IsValidEmail(this string email)
{
const string pattern = @"^(?!\.)(""([^""\r\\]|\\[""\r\\])*""|" + @"([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)" + @"@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$";
var regex = new Regex(pattern, RegexOptions.IgnoreCase);
return regex.IsMatch(email);
}
Confira meu postsobre isso para uma discussão sobre o assunto e uma implementação f# usando FParsec. [/shameless_ plug]
- Todo antes que o @ seja simplificado, para que pelo menos o javascript funcione. Não me importo de relaxar a validação aqui, desde que o servidor de intercâmbio não me dê um 5.1.3. - Tudo depois do @ é a solução do Phil modificada para domínios de letras únicas.
public const string EmailPattern =
@"^\s*[\w\-\+_']+(\.[\w\-\+_']+)*\@[A-Za-z0-9]([\w\.-]*[A-Za-z0-9])?\.[A-Za-z][A-Za-z\.]*[A-Za-z]$";
Para as pessoas que sugiram usar o system.net.mail MailMessage (), essa coisa é muito flexível. Claro, C# irá aceitar o e-mail, mas em seguida, o servidor de troca irá bombardear com erro 5.1.3 tempo de execução, assim que você tentar enviar o e-mail.
Se realmente e quero mesmo saber se um endereço de E-mail é válido...pede ao permutador de correio que o prove, não é preciso nenhum regex. Posso fornecer o código se for solicitado.
Os passos gerais são os seguintes:: 1. o endereço de E-mail tem uma parte do nome de domínio? (Índice de @ > 0) 2. usar uma pesquisa DNS perguntar se o domínio tem um permutador de correio 3. abrir a ligação tcp ao permutador de correio 4. usando o protocolo smtp, abra uma mensagem para o servidor usando o endereço de E-mail como o reciever 5. analisar o servidor resposta. 6. se chegou até aqui, está tudo bem.
Isto é como podem imaginar, muito caro em termos de tempo e depende do smtp, mas funciona.Em Geral, uma expressão regular para validar endereços de e-mail não é uma coisa fácil de chegar com, no momento da redação deste texto, a sintaxe de um endereço de e-mail deve seguir um número relativamente elevado de normas e a implementação de todos eles dentro de uma expressão regular é praticamente inviável!
Sugiro-lhe que experimente o nosso ... EmailVerify.NET , uma biblioteca. net madura que pode validar endereços de E-mail a seguir a Todos das normas actuais do IETF (RFC 1123, RFC 2821, RFC 2822, RFC 3696, RFC 4291, RFC 5321 e RFC 5322), testa os registros de DNS relacionados, verifica se as caixas de correio alvo podem aceitar mensagens e até mesmo dizer se um determinado endereço é descartável ou não.Disclaimer: eu sou o desenvolvedor principal para este componente.
For the simple email like [email protected], below code is sufficient.
public static bool ValidateEmail(string email)
{
System.Text.RegularExpressions.Regex emailRegex = new System.Text.RegularExpressions.Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
System.Text.RegularExpressions.Match emailMatch = emailRegex.Match(email);
return emailMatch.Success;
}
Verificar o texto de E-mail é o formato certo ou o formato errado por System.Text.RegularExpressions:
public static bool IsValidEmailId(string InputEmail)
{
Regex regex = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
Match match = regex.Match(InputEmail);
if (match.Success)
return true;
else
return false;
}
protected void Email_TextChanged(object sender, EventArgs e)
{
String UserEmail = Email.Text;
if (IsValidEmailId(UserEmail))
{
Label4.Text = "This email is correct formate";
}
else
{
Label4.Text = "This email isn't correct formate";
}
}
/ Usando o Regex interno usado na criação do componente" new EmailAddressAttribute (); " em .Net4.5 >>> Usando o sistema.ComponentModel.Anotações de dados; // Para validar um endereço de E-mail......Testado e a trabalhar.
public bool IsEmail(string email)
{
if (String.IsNullOrEmpty(email))
{ return false; }
try
{
Regex _regex = new Regex("^((([a-z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])" +
"+(\\.([a-z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])+)*)|((\\x22)" +
"((((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(([\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]|\\x21|[\\x23-\\x5b]|[\\x5d-\\x7e]|" +
"[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(\\\\([\\x01-\\x09\\x0b\\x0c\\x0d-\\x7f]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\u" +
"FDF0-\\uFFEF]))))*(((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(\\x22)))@((([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|" +
"(([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])*([a-z]|\\d|" +
"[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])))\\.)+(([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(([a-z]|[\\u00A0-\\uD7FF\\uF900" +
"-\\uFDCF\\uFDF0-\\uFFEF])([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])*([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFF" +
"EF])))\\.?$", RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture | RegexOptions.Compiled);
return _regex.IsMatch(email);
}
catch (RegexMatchTimeoutException)
{
return false;
}
}
Também pode usar isto:
Http://msdn.microsoft.com/en-us/library/01escwtf(v=vs 110).aspx
using System;
using System.Globalization;
using System.Text.RegularExpressions;
public class RegexUtilities
{
public bool IsValidEmail(string strIn)
{
if (String.IsNullOrEmpty(strIn))
{
return false;
}
// Use IdnMapping class to convert Unicode domain names.
try
{
strIn = Regex.Replace(strIn, @"(@)(.+)$", this.DomainMapper, RegexOptions.None, TimeSpan.FromMilliseconds(200));
}
catch (RegexMatchTimeoutException)
{
return false;
}
if (invalid)
{
return false;
}
// Return true if strIn is in valid e-mail format.
try
{
return Regex.IsMatch(strIn, @"^(?("")("".+?(?<!\\)""@)|(([0-9a-z]((\.(?!\.))| [-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-\w]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9]))$", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250));
}
catch (RegexMatchTimeoutException)
{
return false;
}
}
private string DomainMapper(Match match)
{
// IdnMapping class with default property values.
IdnMapping idn = new IdnMapping();
string domainName = match.Groups[2].Value;
try
{
domainName = idn.GetAscii(domainName);
}
catch (ArgumentException)
{
invalid = true;
}
return match.Groups[1].Value + domainName;
}
}
private static bool IsValidEmail(string emailAddress)
{
const string validEmailPattern = @"^(?!\.)(""([^""\r\\]|\\[""\r\\])*""|"
+ @"([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)"
+ @"@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$";
return new Regex(validEmailPattern, RegexOptions.IgnoreCase).IsMatch(emailAddress);
}
public static bool IsValidEmailAddress(string candidateEmailAddr)
{
string regexExpresion = "\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
return (Regex.IsMatch(candidateEmailAddr, regexExpresion)) &&
(Regex.Replace(candidateEmailAddr, regexExpresion, string.Empty).Length == 0);
}
Escrevi uma função para verificar se um e-mail é válido ou não. Parece que funciona bem para mim na maioria dos casos.
Resultados:
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
dad@sds => FALSE
[email protected] => FALSE
[email protected] => FALSE
asd@[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => TRUE
[email protected] => TRUE
[email protected] => TRUE
[email protected] => TRUE
Código:
private bool IsValidEmail(string email)
{
bool valid = false;
try
{
var addr = new System.Net.Mail.MailAddress(email);
valid = true;
}
catch
{
valid = false;
goto End_Func;
}
valid = false;
int pos_at = email.IndexOf('@');
char checker = Convert.ToChar(email.Substring(pos_at + 1, 1));
var chars = "qwertyuiopasdfghjklzxcvbnm0123456789";
foreach (char chr in chars)
{
if (checker == chr)
{
valid = true;
break;
}
}
if (valid == false)
{
goto End_Func;
}
int pos_dot = email.IndexOf('.', pos_at + 1);
if(pos_dot == -1)
{
valid = false;
goto End_Func;
}
valid = false;
try
{
checker = Convert.ToChar(email.Substring(pos_dot + 1, 1));
foreach (char chr in chars)
{
if (checker == chr)
{
valid = true;
break;
}
}
}
catch
{
valid = false;
goto End_Func;
}
Regex valid_checker = new Regex(@"^[[email protected]]*$");
valid = valid_checker.IsMatch(email);
if (valid == false)
{
goto End_Func;
}
List<int> pos_list = new List<int> { };
int pos = 0;
while (email.IndexOf('_', pos) != -1)
{
pos_list.Add(email.IndexOf('_', pos));
pos = email.IndexOf('_', pos) + 1;
}
pos = 0;
while (email.IndexOf('.', pos) != -1)
{
pos_list.Add(email.IndexOf('.', pos));
pos = email.IndexOf('.', pos) + 1;
}
pos = 0;
while (email.IndexOf('-', pos) != -1)
{
pos_list.Add(email.IndexOf('-', pos));
pos = email.IndexOf('-', pos) + 1;
}
int sp_cnt = pos_list.Count();
pos_list.Sort();
for (int i = 0; i < sp_cnt - 1; i++)
{
if (pos_list[i] + 1 == pos_list[i + 1])
{
valid = false;
break;
}
if (pos_list[i]+1 == pos_at || pos_list[i]+1 == pos_dot)
{
valid = false;
break;
}
}
if(valid == false)
{
goto End_Func;
}
if (pos_list[sp_cnt - 1] == email.Length - 1 || pos_list[0] == 0)
{
valid = false;
}
End_Func:;
return valid;
}
A forma simples de identificar o emailid é válida ou não.
public static bool EmailIsValid(string email)
{
return Regex.IsMatch(email, @"^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$");
}
Há um problema de Cultura no regex em C# e não em js. Então precisamos usar a regex no modo US para verificar o email. Se você não usar o modo ECMAScript, seus caracteres especiais da linguagem estão insinuando em A-Z com regex.
Regex.IsMatch(email, @"^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9_\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$", RegexOptions.ECMAScript)
Acabei por usar este regex, uma vez que valida com sucesso vírgulas, comentários, caracteres Unicode e endereços de domínio IP(v4).
Os endereços válidos serão:
"" @example.org
(comentário)[email protected]
Тест@example.org
ტესტი@example.org
Teste@[192. 168. 1. 1]
public const string REGEX_EMAIL = @"^(((\([\w!#$%&'*+\/=?^_`{|}~-]*\))?[^<>()[\]\\.,;:\s@\""]+(\.[^<>()[\]\\.,;:\s@\""]+)*)|(\"".+\""))(\([\w!#$%&'*+\/=?^_`{|}~-]*\))?@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$";
No caso de estar a utilizar FluentValidation pode escrever algo tão simples como isto:
public cass User
{
public string Email { get; set; }
}
public class UserValidator : AbstractValidator<User>
{
public UserValidator()
{
RuleFor(x => x.Email).EmailAddress().WithMessage("The text entered is not a valid email address.");
}
}
// Validates an user.
var validationResult = new UserValidator().Validate(new User { Email = "açflkdj" });
// This will return false, since the user email is not valid.
bool userIsValid = validationResult.IsValid;
Baseado na resposta de @Cogwheel eu quero compartilhar uma solução modificada que funciona para SSIS e o "componente de Script":
- Coloque o "componente de Script" na sua ligação de fluxo de dados e, em seguida, abra-o.
- na secção "colunas de entrada", defina o campo que contém as mensagens de E-Mail para "ReadWrite" (no exemplo 'fieldName').
- Volte para a secção " Script "e carregue em"Editar Script". Então tens de esperar depois do Código abrir.
-
Local este código no método certo:
public override void Input0_ProcessInputRow(Input0Buffer Row) { string email = Row.fieldName; try { System.Net.Mail.MailAddress addr = new System.Net.Mail.MailAddress(email); Row.fieldName= addr.Address.ToString(); } catch { Row.fieldName = "WRONGADDRESS"; } }
Então poderá usar uma separação condicional para filtrar todos os registos inválidos ou o que quiser fazer.
public static bool IsValidEmail(this string email)
{
// skip the exception & return early if possible
if (email.IndexOf("@") <= 0) return false;
try
{
var address = new MailAddress(email);
return address.Address == email;
}
catch
{
return false;
}
}
- num "bloco de tentativa" envie um e-mail de verificação.
- Faça com que o utilizador abra o e-mail e carregue num link que verifique se o e-mail é real.
Até este processo terminar com sucesso, o e-mail é considerado inválido.
Há algum tempo atrás, escrevi um {[1] } que deve validar adequadamente qualquer endereço de E-mail relativamente normal do formulário
local-part@domain
É um System.ComponentModel.DataAnnotations.ValidationAttribute, por isso o uso é muito simples.
E, já que vasculhamos todos os RFCs e errata e reunimos todos os bits necessários para enumerar corretamente todas as regras é...tedioso - na melhor das hipóteses! - Eu postei o código fonte para o validador em a minha resposta para a pergunta C# email Address validation para o codigo.
O meu validador não é perfeito para qualquer tipo de imaginação, embora, para começar, não tenha qualquer suporte integrado para emitir validação javascript do lado do cliente, embora não seja muito difícil acrescentar isso. Da minha resposta acima:Aqui está o atributo de validação que escrevi. Valida praticamente todos os e-mails "raw" endereço, isto é, os do formulário local-part@domain . Não suporta nenhum de restante, mais...construções criativas que os RFCs permitem (esta lista não completo por qualquer meio):
- comments (e.g.,
[email protected] (work))- cadeias de caracteres cotadas (texto escapado, para permitir que os caracteres não sejam permitidos num átomo) {[[30]}
- literais de domínio (ex.
foo@[123.45.67.012])- bang-paths (também conhecido por encaminhamento fonte)
- endereços de ângulo (ex.
John Smith <[email protected]>)- folding whitespace
- caracteres de duplo byte em Parte local oudomínio (7 bits Apenas ASCII).
- etc.
Deve aceitar quase todos os endereços de E-mail que possam ser expressos desta forma
Sem exigir o uso de aspas (
"), colchetes ('') ou parêntesis rectos ([]).Não é feita qualquer tentativa para validar que a legenda dns mais à direita no domínio é válida TLD (domínio de topo). Isso é porque a lista de TLDs é muito maior Agora do que o "big 6" (. com,. edu, .gov,. mil, .net,. org) mais códigos ISO DE País de 2 Letras. a ICANN actualiza a lista TLD diariamente, embora eu suspeite que a lista não muda diariamente. Além disso, [a ICANN acaba de aprovar uma grande expansão do espaço de nomes TLD Genérico] [2]). E alguns endereços de E-mail não têm o que reconhecerias. como um TLD (você sabia que
postmaster@.é teoricamente válido e pode ser enviado por correio? Correio para esse endereço deve ser entregue ao postmaster da zona raiz do DNS.)Estender a expressão regular para suportar literais de domínio não deve ser muito difícil.