Code C # pour valider l'adresse email
Quel est le code le plus élégant pour valider qu’une chaîne est une adresse électronique valide?
Et ça?
bool IsValidEmail(string email)
{
try {
var addr = new System.Net.Mail.MailAddress(email);
return addr.Address == email;
}
catch {
return false;
}
}
Pour clarifier, la question est de savoir si une chaîne particulière est une représentation valide d'une adresse électronique, et non si une adresse électronique est une destination valide pour envoyer un message. Pour cela, le seul moyen réel consiste à envoyer un message à confirmer.
Notez que les adresses e-mail sont plus indulgentes que vous ne le supposiez. Ce sont toutes des formes parfaitement valables:
- roue dentée
- "cogwheel the orange" @ example.com
- 123@$.xyz
Pour la plupart des cas d'utilisation, un faux "invalide" est bien pire pour vos utilisateurs et pour le futur qu'un faux "valide". Voici un article qui était la réponse acceptée à cette question (cette réponse a été supprimée depuis). Il contient beaucoup plus de détails et d’autres idées sur la façon de résoudre le problème.
Fournir des contrôles de cohérence est toujours une bonne idée pour l'expérience utilisateur. En supposant que l'adresse e-mail soit valide, vous pouvez rechercher des domaines de premier niveau connus, rechercher dans le domaine un enregistrement MX, rechercher des erreurs d'orthographe dans les noms de domaine courants (gmail.cmo), etc. une chance de dire "oui, mon serveur de messagerie permet vraiment ???????????? comme une adresse e-mail."
En ce qui concerne l'utilisation de la gestion des exceptions pour la logique métier, je conviens que c'est une chose à éviter. Mais c’est l’un des cas où la commodité et la clarté peuvent l'emporter sur le dogme.
De plus, si vous faites autre chose avec l'adresse de messagerie, vous devrez probablement la transformer en adresse MailAddress. Même si vous n'utilisez pas cette fonction exacte, vous voudrez probablement utiliser le même motif. Vous pouvez également rechercher des types d'échec spécifiques en interceptant différentes exceptions : un format nul, vide ou non valide.
Selon le commentaire de Stuart, l'adresse finale est comparée à la chaîne d'origine au lieu de toujours être vraie. MailAddress essaie d'analyser une chaîne avec des espaces dans les portions "Nom complet" et "Adresse", de sorte que la version d'origine renvoyait de faux positifs.
--- Lectures supplémentaires ---
C'est une vieille question, mais toutes les réponses que j'ai trouvées sur SO, y compris les plus récentes, reçoivent une réponse similaire à celle-ci. Cependant, dans .Net 4.5/MVC 4, vous pouvez ajouter une validation d'adresse électronique à un formulaire en ajoutant l'annotation [EmailAddress] de System.ComponentModel.DataAnnotations. Je me demandais donc pourquoi je ne pouvais pas simplement utiliser la fonctionnalité intégrée. Net en général.
Cela semble fonctionner et me semble assez élégant:
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;
}
}
J'utilise cette méthode de doublure qui fait le travail pour moi-
using System.ComponentModel.DataAnnotations;
public bool IsValidEmail(string source)
{
return new EmailAddressAttribute().IsValid(source);
}
Selon les commentaires, cela "échouera" si la source (l'adresse e-mail) est nulle.
public static bool IsValidEmailAddress(this string address) => address != null && new EmailAddressAttribute().IsValid(address);
.net 4.5 ajouté System.ComponentModel.DataAnnotations.EmailAddressAttribute
Vous pouvez parcourir les sources de EmailAddressAttribute , il s’agit du regex qu’il utilise en interne:
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])))\.?$";
J'ai pris la réponse de Phil du n ° 1 et créé cette classe . Appelez-la comme ceci: bool isValid = Validator.EmailIsValid(emailString);
Voici la 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;
}
}
Personnellement, je dirais que vous devriez simplement vous assurer qu’il ya un symbole @, avec éventuellement un. personnage. Vous pouvez utiliser plusieurs expressions rationnelles plus ou moins correctes, mais je pense que la plupart d’entre elles laissent de côté les adresses électroniques valides ou les laisser invalides. Si les gens veulent mettre une fausse adresse e-mail, ils en mettront une fausse. Si vous devez vérifier que l'adresse e-mail est légitime et que la personne en a le contrôle, vous devrez alors lui envoyer un e-mail contenant un lien codé spécial afin de vérifier qu'il s'agit bien d'une adresse réelle.
Je pense que le meilleur moyen est le suivant:
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;
}
}
Vous pouvez avoir cette fonction statique dans une classe générale.
La méthode la plus élégante consiste à utiliser les méthodes intégrées de .Net.
Ces méthodes:
Sont essayés et testés. Ces méthodes sont utilisées dans mes propres projets professionnels.
Utilisez des expressions régulières en interne, qui sont fiables et rapides.
Fabriqué par Microsoft pour C #. Il n'y a pas besoin de réinventer la roue.
Renvoie un résultat bool. True signifie que l'e-mail est valide.
Pour les utilisateurs de .Net 4.5 et supérieur
Ajoutez cette référence à votre projet:
System.ComponentModel.DataAnnotations
Maintenant, vous pouvez utiliser le code suivant:
(new EmailAddressAttribute().IsValid("[email protected]"));
Exemple d'utilisation
Voici quelques méthodes pour déclarer:
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;
}
... et du code les démontrant en action:
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());
}
De plus, cet exemple:
- S'étend au-delà de la spécification puisqu'une seule chaîne est utilisée pour contenir 0, une ou plusieurs adresses e-mail sperées par un point-virgule
;. - Montre clairement comment utiliser la méthode IsValid de l'objet EmailAddressAttribute.
Alternative, pour les utilisateurs d'une version de .Net inférieure à 4.5
Pour les situations où .Net 4.5 n'est pas disponible, j'utilise la solution suivante:
Plus précisément, j'utilise:
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;
}
Pour être honnête, dans le code de production, le mieux que je fasse est de rechercher un symbole @.
Je ne suis jamais en position de valider complètement les emails. Vous savez comment je vois si c'était vraiment valable? Si cela a été envoyé. Si ce n'est pas le cas, c'est mauvais, si c'est le cas, la vie est belle. C'est tout ce que j'ai besoin de savoir.
Code court et précis
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);
}
Je trouve que cette regex est un bon compromis entre vérifier quelque chose de plus que la marque @ et accepter des cas Edge étranges:
^[^@\s]+@[^@\s]+(\.[^@\s]+)+$
Cela vous incitera au moins à placer quelque chose autour de la marque @ et à au moins un domaine d'aspect normal.
Voici ma réponse: la solution de Phil échoue pour les domaines comportant une seule lettre, tels que "quelqu'[email protected]". Croyez-le ou non, c'est utilisé =) (va à Centurylink, par exemple).
La réponse de Phil ne fonctionnera également qu'avec le standard PCRE ... donc C # le prendra, mais javascript va exploser. C'est trop complexe pour javascript. Vous ne pouvez donc pas utiliser la solution de Phil pour les attributs de validation MVC.
Voici mon regex. Cela fonctionnera bien avec les attributs de validation MVC.
- Tout ce qui précède le @ est simplifié, de sorte qu'au moins le javascript fonctionne. Je suis d'accord pour relâcher la validation ici tant que le serveur Exchange ne me donne pas la version 5.1.3 .- Tout ce qui suit la @ est la solution de Phil modifiée pour les domaines à lettre unique.
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]$";
Pour les personnes suggérant d’utiliser system.net.mail MailMessage (), c’est WAY to flexible. Bien sûr, C # acceptera l’e-mail, mais ensuite Exchange Server explosera avec une erreur d’exécution 5.1.3 dès que vous tenterez d’envoyer l’e-mail.
La validation des adresses e-mail n’est pas aussi facile que cela puisse paraître. Il est en réalité théoriquement impossible de valider entièrement une adresse email en utilisant simplement une expression régulière.
Consultez mon blog about about pour une discussion sur le sujet et une implémentation de F # avec FParsec. [/ shameless_plug]
Si vous voulez vraiment savoir si une adresse e-mail est valide, demandez à l’échangeur de mails de le prouver, sans regex. Je peux fournir le code si demandé.
Les étapes générales sont les suivantes: 1. l'adresse e-mail a-t-elle une partie de nom de domaine? (index de @> 0) 2. en utilisant une requête DNS, demandez si le domaine a un échangeur de messagerie 3. ouvrir la connexion TCP à l’échangeur de courrier 4. en utilisant le protocole smtp, ouvrez un message au serveur en utilisant l’adresse e-mail comme destinataire 5. analyser la réponse du serveur . 6. quittez le message si vous en êtes arrivé là, tout va bien.
C’est comme vous pouvez l’imaginer, très coûteux en temps et qui repose sur smtp, mais cela fonctionne.
La réponse la plus votée de @Cogwheel est la meilleure, mais j'ai essayé d'implémenter la méthode chaîne trim() afin de supprimer tous les espaces blancs de l'utilisateur du début à la fin de la chaîne. Vérifiez le code ci-dessous pour un exemple complet-
bool IsValidEmail(string email)
{
try
{
email = email.Trim();
var addr = new System.Net.Mail.MailAddress(email);
return addr.Address == email;
}
catch
{
return false;
}
}
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;
}
De manière générale, une expression régulière pour valider des adresses électroniques n'est pas une chose facile à trouver; Au moment d'écrire ces lignes, la syntaxe d'une adresse e-mail doit respecter un nombre relativement élevé de normes et leur implémentation dans une expression régulière est pratiquement irréalisable!
Je vous suggère fortement d’essayer notre EmailVerify.NET , une bibliothèque .NET mature qui peut valider les adresses électroniques suivant tous des normes IETF actuelles (RFC 1123, RFC 2821, RFC 2822, RFC 3696, RFC 4291, RFC 5321 et RFC 5322), teste les enregistrements DNS associés, vérifie si les boîtes aux lettres cibles peuvent accepter les messages et peuvent même dire si une adresse donnée est disponible ou non.
Avertissement: Je suis le développeur principal de ce composant.
Vérifiez que la chaîne de l'e-mail est au bon format ou au mauvais format de 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";
}
}
Il y a beaucoup de réponses fortes ici. Cependant, je recommande que nous prenions un peu de recul. @Cogwheel répond à la question https://stackoverflow.com/a/1374644/388267 . Néanmoins, un scénario de validation en bloc peut s'avérer coûteux si plusieurs adresses électroniques en cours de validation sont non valides. Je suggère que nous employions un peu de logique avant d'entrer dans son bloc try-catch. Je sais que le code suivant pourrait être écrit en utilisant RegEx mais que cela pourrait être coûteux pour les nouveaux développeurs. Ceci est ma valeur de deux fois:
public static bool IsEmail(this string input)
{
if (string.IsNullOrWhiteSpace(input)) return false;
// MUST CONTAIN ONE AND ONLY ONE @
var atCount = input.Count(c => c == '@');
if (atCount != 1) return false;
// MUST CONTAIN PERIOD
if (!input.Contains(".")) return false;
// @ MUST OCCUR BEFORE LAST PERIOD
var indexOfAt = input.IndexOf("@", StringComparison.Ordinal);
var lastIndexOfPeriod = input.LastIndexOf(".", StringComparison.Ordinal);
var atBeforeLastPeriod = lastIndexOfPeriod > indexOfAt;
if (!atBeforeLastPeriod) return false;
// CODE FROM COGWHEEL'S ANSWER: https://stackoverflow.com/a/1374644/388267
try
{
var addr = new System.Net.Mail.MailAddress(input);
return addr.Address == input;
}
catch
{
return false;
}
}
/ Utilisation de la regex interne utilisée dans la création du "nouveau EmailAddressAttribute ();" composant dans .Net4.5 >>> using System.ComponentModel.DataAnnotations; // Valider une adresse e-mail ...... Testé et fonctionnel.
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;
}
}
En outre, vous pouvez utiliser ceci:
http://msdn.Microsoft.com/en-us/library/01escwtf(v=vs.110).aspx
Voici une réponse à votre question à vérifier.
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;
}
}
Il y a un problème de culture dans les expressions rationnelles en C # plutôt que js. Nous devons donc utiliser regex en mode américain pour vérifier les e-mails. Si vous n'utilisez pas le mode ECMAScript, les caractères spéciaux de votre langue sont impliqués dans A à Z avec 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)
J'ai écrit une fonction pour vérifier si un email est valide ou non. Cela semble bien fonctionner pour moi dans la plupart des cas.
Résultats:
[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
Code:
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;
}
Basé sur la réponse de @Cogwheel, je souhaite partager une solution modifiée qui fonctionne pour SSIS et le "composant de script":
- Placez le "composant de script" dans votre connexion de flux de données, puis ouvrez-le.
- Dans la section "Colonnes d'entrée", définissez le champ contenant les adresses de messagerie sur "ReadWrite" (dans l'exemple 'nom de champ').
- Revenez à la section "Script" et cliquez sur "Editer le script". Ensuite, vous devez attendre après l'ouverture du code.
Placez ce code dans la bonne méthode:
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"; } }
Vous pouvez ensuite utiliser un fractionnement conditionnel pour filtrer tous les enregistrements non valides ou ce que vous souhaitez faire.
Une autre réponse à Regex Match:
/// <summary>
/// Validates the email input
/// </summary>
internal static bool ValidateEmail(string _emailAddress)
{
string _regexPattern = @"^(([\w-]+\.)+[\w-]+|([a-zA-Z]{1}|[\w-]{2,}))@"
+ @"((([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\.([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\."
+ @"([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\.([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])){1}|"
+ @"([a-zA-Z]+[\w-]+\.)+[a-zA-Z]{2,4})$";
return (string.IsNullOrEmpty(_emailAddress) == false && System.Text.RegularExpressions.Regex.IsMatch(_emailAddress, _regexPattern))
? true
: false;
}
Un moyen simple d'identifier l'id de messagerie est valide ou non.
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})(\]?)$");
}
J'ai fini par utiliser cette expression rationnelle, car elle valide avec succès les virgules, les commentaires, les caractères Unicode et les adresses de domaine IP (v4).
Les adresses valides seront:
"" @ example.org
(comment)[email protected]
тест@example.org
example @ example.org
test @ [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,}))$";
une petite modification à la réponse @Cogwheel
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;
}
}
Si vous utilisez FluentValidation vous pourriez écrire quelque chose d'aussi simple que ceci:
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;
J'ai résumé la réponse de Poyson 1 comme suit:
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);
}
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);
}