Validation Regex Email

Je l’utilise

@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$" 

regexp pour valider l’email

([\w\.\-]+) – ceci est pour le domaine de premier niveau (beaucoup de lettres et de chiffres, aussi point et trait d’union)

([\w\-]+) – ceci est pour le domaine de second niveau

((\.(\w){2,3})+) – et c’est pour les autres domaines de niveau (de 3 à l’infini) qui inclut un point et 2 ou 3 littéraux

Quel est le problème avec cette regex?

EDIT: il ne correspond pas à l’email “[email protected]

Les TLD comme .museum ne sont pas assortis de cette manière, et il y a quelques autres longs TLD. En outre, vous pouvez valider les adresses électroniques à l’aide de la classe MailAddress, comme Microsoft l’explique ici dans une note:

Au lieu d’utiliser une expression régulière pour valider une adresse électronique, vous pouvez utiliser la classe System.Net.Mail.MailAddress. Pour déterminer si une adresse électronique est valide, transmettez l’adresse électronique au constructeur de la classe MailAddress.MailAddress (Ssortingng).

 public bool IsValid(ssortingng emailaddress) { try { MailAddress m = new MailAddress(emailaddress); return true; } catch (FormatException) { return false; } } 

Cela vous évite beaucoup de maux de tête car vous n’avez pas besoin d’écrire (ou d’essayer de comprendre les expressions de quelqu’un d’autre).

Je pense que @"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$" devrait fonctionner.
Vous devez l’écrire comme

 ssortingng email = txtemail.Text; Regex regex = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$"); Match match = regex.Match(email); if (match.Success) Response.Write(email + " is correct"); else Response.Write(email + " is incorrect"); 

Soyez averti que cela échouera si:

  1. Il y a un sous-domaine après le symbole @ .

  2. Vous utilisez un TLD d’une longueur supérieure à 3, tel que .info

J’ai une expression pour vérifier les adresses e-mail que j’utilise.

Comme aucun de ces points n’était aussi court ou précis que le mien, je pensais le poster ici.

 @"^[\w!#$%&'*+\-/=?\^_`{|}~]+(\.[\w!#$%&'*+\-/=?\^_`{|}~]+)*" + "@" + @"((([\-\w]+\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\.){3}[0-9]{1,3}))$"; 

Pour plus d’informations, lisez ceci: Expressions régulières en C # (y compris un nouveau modèle de messagerie complet)

En outre, cela vérifie la validité de la RFC en fonction de la syntaxe du courrier électronique, et non de savoir si le courrier électronique existe réellement. La seule façon de vérifier si un e-mail existe réellement est d’envoyer et d’envoyer des e-mails et de demander à l’utilisateur de vérifier qu’il a bien reçu l’e-mail en cliquant sur un lien ou en saisissant un jeton.

Ensuite, il existe des domaines jetables, tels que Mailinator.com, etc. Cela ne fait rien pour vérifier si un email provient d’un domaine jetable ou non.

J’ai trouvé un bon document sur MSDN pour cela.

Comment: vérifier que les chaînes sont au format de courrier électronique valide http://msdn.microsoft.com/en-us/library/01escwtf.aspx (vérifiez que ce code prend également en charge l’utilisation de caractères non-ASCII pour les noms de domaine Internet. )

Il existe 2 implémentations, pour .Net 2.0 / 3.0 et pour .Net 3.5 et supérieur.
la version 2.0 / 3.0 est:

 bool IsValidEmail(ssortingng strIn) { // Return true if strIn is in valid e-mail format. return Regex.IsMatch(strIn, @"^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$"); } 

Mes tests sur cette méthode donnent:

 Invalid: @majjf.com Invalid: A@b@[email protected] Invalid: Abc.example.com Valid: [email protected] Valid: [email protected] Invalid: js*@proseware.com Invalid: [email protected] Valid: [email protected] Valid: [email protected] Invalid: ma@@jjf.com Invalid: ma@jjf. Invalid: [email protected] Invalid: [email protected] Invalid: ma_@jjf Invalid: ma_@jjf. Valid: [email protected] Invalid: ------- Valid: [email protected] Valid: [email protected] Valid: [email protected] Valid: [email protected] Invalid: [email protected] Valid: j_9@[129.126.118.1] Valid: [email protected] Invalid: js#[email protected] Invalid: [email protected] Invalid: [email protected] Valid: [email protected] Valid: [email protected] Valid: [email protected] Valid: [email protected] Invalid: [email protected] Invalid: [email protected] Valid: [email protected] Valid: [email protected] Valid: [email protected] Valid: [email protected] Valid: [email protected] Valid: [email protected] Valid: [email protected] 

Cela ne répond pas à toutes les exigences des RFC 5321 et 5322, mais fonctionne avec les définitions suivantes.

 @"^([0-9a-zA-Z]([\+\-_\.][0-9a-zA-Z]+)*)+"@(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]*\.)+[a-zA-Z0-9]{2,17})$"; 

Ci-dessous le code

 const Ssortingng pattern = @"^([0-9a-zA-Z]" + //Start with a digit or alphabetical @"([\+\-_\.][0-9a-zA-Z]+)*" + // No continuous or ending +-_. chars in email @")+" + @"@(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]*\.)+[a-zA-Z0-9]{2,17})$"; var validEmails = new[] { "[email protected]", "[email protected]", "[email protected]", "[email protected]", "[email protected]", "[email protected]", "[email protected]", "[email protected]", "[email protected]", "[email protected]", "[email protected]", }; var invalidEmails = new[] { "Abc.example.com", // No `@` "A@b@[email protected]", // multiple `@` "[email protected]", // continuous multiple dots in name "[email protected]", // only 1 char in extension "[email protected]", // continuous multiple dots in domain "ma@@jjf.com", // continuous multiple `@` "@majjf.com", // nothing before `@` "[email protected]", // nothing after `.` "[email protected]", // nothing after `_` "ma_@jjf", // no domain extension "ma_@jjf.", // nothing after `_` and . "ma@jjf.", // nothing after `.` }; foreach (var str in validEmails) { Console.WriteLine("{0} - {1} ", str, Regex.IsMatch(str, pattern)); } foreach (var str in invalidEmails) { Console.WriteLine("{0} - {1} ", str, Regex.IsMatch(str, pattern)); } 

Meilleur regex de validation d’email

 [a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])? 

Et c’est l’usage: –

 bool isEmail = Regex.IsMatch(emailSsortingng, @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z", RegexOptions.IgnoreCase); 

Essayez ceci pour la taille:

 public static bool IsValidEmailAddress(this ssortingng s) { var regex = new Regex(@"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?"); return regex.IsMatch(s); } 

Celui-ci empêche les courriels invalides mentionnés par d’autres dans les commentaires:

 [email protected] [email protected] name@hotmail [email protected] [email protected] 

Il empêche également les emails avec des points doubles:

 [email protected] 

Essayez de le tester avec autant d’adresses e-mail invalides que possible.

 using System.Text.RegularExpressions; public static bool IsValidEmail(ssortingng email) { return Regex.IsMatch(email, @"\A[a-z0-9]+([-._][a-z0-9]+)*@([a-z0-9]+(-[a-z0-9]+)*\.)+[az]{2,4}\z") && Regex.IsMatch(email, @"^(?=.{1,64}@.{4,64}$)(?=.{6,100}$).*"); } 

Voir Valider l’adresse email en utilisant l’expression régulière en C # .

Essayez ceci, ça marche pour moi:

 public bool IsValidEmailAddress(ssortingng s) { if (ssortingng.IsNullOrEmpty(s)) return false; else { var regex = new Regex(@"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*"); return regex.IsMatch(s) && !s.EndsWith("."); } } 

Pourquoi ne pas utiliser la validation de courrier électronique basée sur les atsortingbuts EF6?

Comme vous pouvez le voir ci-dessus, la validation Regex pour les messages électroniques comporte toujours des lacunes. Si vous utilisez des annotations de données EF6, vous pouvez facilement obtenir une validation de messagerie électronique fiable et renforcée avec l’atsortingbut d’annotation de données EmailAddress disponible pour cela. J’ai dû supprimer la validation regex que j’avais utilisée auparavant pour le courrier électronique en cas d’échec de regex spécifique à un périphérique mobile dans le champ de saisie du courrier électronique. Lorsque l’atsortingbut d’annotation de données utilisé pour la validation du courrier électronique, le problème sur mobile a été résolu.

 public class LoginViewModel { [EmailAddress(ErrorMessage = "The email format is not valid")] public ssortingng Email{ get; set; } 

Le code suivant est basé sur l’implémentation des annotations de données Microsoft sur github et je pense que c’est la validation la plus complète pour les emails:

 public static Regex EmailValidation() { const ssortingng pattern = @"^((([az]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([az]|\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)))@((([az]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([az]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([az]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([az]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([az]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([az]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([az]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([az]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$"; const RegexOptions options = RegexOptions.Comstackd | RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture; // Set explicit regex match timeout, sufficient enough for email parsing // Unless the global REGEX_DEFAULT_MATCH_TIMEOUT is already set TimeSpan matchTimeout = TimeSpan.FromSeconds(2); try { if (AppDomain.CurrentDomain.GetData("REGEX_DEFAULT_MATCH_TIMEOUT") == null) { return new Regex(pattern, options, matchTimeout); } } catch { // Fallback on error } // Legacy fallback (without explicit match timeout) return new Regex(pattern, options); } 

Il a fallu de nombreuses tentatives pour créer un validateur de courrier électronique qui répond à presque toutes les exigences mondiales en matière de courrier électronique.

Méthode d’extension que vous pouvez appeler avec:

 myEmailSsortingng.IsValidEmailAddress(); 

Chaîne de motifs de regex que vous pouvez obtenir en appelant:

 var myPattern = Regex.EmailPattern; 

Le code (principalement des commentaires):

  ///  /// Validates the ssortingng is an Email Address... ///  ///  /// bool public static bool IsValidEmailAddress(this ssortingng emailAddress) { var valid = true; var isnotblank = false; var email = emailAddress.Trim(); if (email.Length > 0) { // Email Address Cannot start with period. // Name portion must be at least one character // In the Name, valid characters are: az 0-9 ! # _ % & ' " = ` { } ~ - + * ? ^ | / $ // Cannot have period immediately before @ sign. // Cannot have two @ symbols // In the domain, valid characters are: az 0-9 - . // Domain cannot start with a period or dash // Domain name must be 2 characters.. not more than 256 characters // Domain cannot end with a period or dash. // Domain must contain a period isnotblank = true; valid = Regex.IsMatch(email, Regex.EmailPattern, RegexOptions.IgnoreCase) && !email.StartsWith("-") && !email.StartsWith(".") && !email.EndsWith(".") && !email.Contains("..") && !email.Contains(".@") && !email.Contains("@."); } return (valid && isnotblank); } ///  /// Validates the ssortingng is an Email Address or a delimited ssortingng of email addresses... ///  ///  /// bool public static bool IsValidEmailAddressDelimitedList(this ssortingng emailAddress, char delimiter = ';') { var valid = true; var isnotblank = false; ssortingng[] emails = emailAddress.Split(delimiter); foreach (ssortingng e in emails) { var email = e.Trim(); if (email.Length > 0 && valid) // if valid == false, no reason to continue checking { isnotblank = true; if (!email.IsValidEmailAddress()) { valid = false; } } } return (valid && isnotblank); } public class Regex { ///  /// Set of Unicode Characters currently supported in the application for email, etc. ///  public static readonly ssortingng UnicodeCharacters = "À-ÿ\p{L}\p{M}ÀàÂâÆæÇçÈèÉéÊêËëÎîÏïÔôŒœÙùÛûÜü«»€₣äÄöÖüÜß"; // German and French ///  /// Set of Symbol Characters currently supported in the application for email, etc. /// Needed if a client side validator is being used. /// Not needed if validation is done server side. /// The difference is due to subtle differences in Regex engines. ///  public static readonly ssortingng SymbolCharacters = @"!#%&'""=`{}~\.\-\+\*\?\^\|\/\$"; ///  /// Regular Expression ssortingng pattern used to match an email address. /// The following characters will be supported anywhere in the email address: /// ÀàÂâÆæÇçÈèÉéÊêËëÎîÏïÔôŒœÙùÛûÜü«»€₣äÄöÖüÜß[a - z][A - Z][0 - 9] _ /// The following symbols will be supported in the first part of the email address(before the @ symbol): /// !#%&'"=`{}~.-+*?^|\/$ /// Emails cannot start or end with periods,dashes or @. /// Emails cannot have two @ symbols. /// Emails must have an @ symbol followed later by a period. /// Emails cannot have a period before or after the @ symbol. ///  public static readonly ssortingng EmailPattern = Ssortingng.Format( @"^([\w{0}{2}])+@{1}[\w{0}]+([-.][\w{0}]+)*\.[\w{0}]+([-.][\w{0}]+)*$", // @"^[{0}\w]+([-+.'][{0}\w]+)*@[{0}\w]+([-.][{0}\w]+)*\.[{0}\w]+([-.][{0}\w]+)*$", UnicodeCharacters, "{1}", SymbolCharacters ); } 
 public static bool ValidateEmail(ssortingng str) { return Regex.IsMatch(str, @"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*"); } 

J’utilise le code ci-dessus pour valider l’adresse email.

  public bool VailidateEnsortingesForAccount() { if (!(txtMailId.Text.Trim() == ssortingng.Empty)) { if (!IsEmail(txtMailId.Text)) { Logger.Debug("Entered invalid Email ID's"); MessageBox.Show("Please enter valid Email Id's" ); txtMailId.Focus(); return false; } } } private bool IsEmail(ssortingng strEmail) { Regex validateEmail = new Regex("^[\\W]*([\\w+\\-.%]+@[\\w\\-.]+\\.[A-Za-z] {2,4}[\\W]*,{1}[\\W]*)*([\\w+\\-.%]+@[\\w\\-.]+\\.[A-Za-z]{2,4})[\\W]*$"); return validateEmail.IsMatch(strEmail); } 
 ssortingng patternEmail = @"(?\w+@\w+\.[az]{0,3})"; Regex regexEmail = new Regex(patternEmail); 

Pour valider votre identifiant de messagerie, vous pouvez simplement créer cette méthode et l’utiliser.

  public static bool IsValidEmail(ssortingng email) { var r = new Regex(@"^([0-9a-zA-Z]([-\.\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})$"); return !Ssortingng.IsNullOrEmpty(email) && r.IsMatch(email); } 

Cela retournera True / False. (Identifiant valide / invalide)

Ceci est mon approche préférée jusqu’à présent:

 public static class CommonExtensions { public static bool IsValidEmail(this ssortingng thisEmail) => !ssortingng.IsNullOrWhiteSpace(thisEmail) && new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$").IsMatch(thisEmail); } 

Ensuite, utilisez l’extension de chaîne créée comme:

 if (!emailAsSsortingng.IsValidEmail()) throw new Exception("Invalid Email"); 

Essayez le code suivant:

 using System.Text.RegularExpressions; if (!Regex.IsMatch(txtEmail.Text, @"^[az,AZ]{1,10}((-|.)\w+)*@\w+.\w{3}$")) MessageBox.Show("Not valid email."); 

RECHERCHE DE CHAÎNES À L’AIDE DE LA MÉTHODE REGEX EN C #

Comment valider un email par expression régulière?

 ssortingng EmailPattern = @"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*"; if (Regex.IsMatch(Email, EmailPattern, RegexOptions.IgnoreCase)) { Console.WriteLine("Email: {0} is valid.", Email); } else { Console.WriteLine("Email: {0} is not valid.", Email); } 

Utiliser la méthode Ssortingng.Regex () de référence

1

 ^[\w!#$%&'*+\-/=?\^_`{|}~]+(\.[\w!#$%&'*+\-/=?\^_`{|}~]+)*@((([\-\w]+\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\.){3}[0-9]{1,3}))$ 

2

 ^(([^<>()[\]\\.,;:\s@\""]+(\.[^<>()[\]\\.,;:\s@\""]+)*)|(\"".+\""))@((\[[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,}))$ 

Je pense que votre signe caret et votre signe dollar font partie du problème. Vous devriez également modifier un peu la regex, j’utilise le prochain @ “[:] + ([\ w .-] +) @ ([\ w -.]) + ((. (\ w) {2,3}) +) ”

Regex Email Pattern:

 ^(?:[\\w\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`\\{\\|\\}\\~]+\\.)*[\\w\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`\\{\\|\\}\\~]+@(?:(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9\\-](?!\\.)){0,61}[a-zA-Z0-9]?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9\\-](?!$)){0,61}[a-zA-Z0-9]?)|(?:\\[(?:(?:[01]?\\d{1,2}|2[0-4]\\d|25[0-5])\\.){3}(?:[01]?\\d{1,2}|2[0-4]\\d|25[0-5])\\]))$ 

J’ai utilisé le Regex.IsMatch ().

Tout d’abord, vous devez append la déclaration suivante:

 using System.Text.RegularExpressions; 

Ensuite, la méthode ressemble à:

 private bool EmailValidation(ssortingng pEmail) { return Regex.IsMatch(pEmail, @"^(?("")("".+?(? 

C'est une méthode privée en raison de ma logique, mais vous pouvez mettre la méthode en statique dans un autre calque tel que "Utilities" et l'appeler là où vous en avez besoin.

Il n’y a pas d’expression régulière parfaite, mais celle-ci est assez forte, je pense, basée sur l’étude de la RFC5322 . Et avec une interpolation de chaîne C #, je pense que c’est très facile à suivre.

 const ssortingng atext = @"a-zA-Z\d!#\$%&'\*\+-/=\?\^_`\{\|\}~"; var localPart = $"[{atext}]+(\\.[{atext}]+)*"; var domain = $"[{atext}]+(\\.[{atext}]+)*"; Assert.That(() => EmailRegex = new Regex($"^{localPart}@{domain}$", Comstackd), Throws.Nothing); 

Testé avec NUnit 2.x

Faites le moi savoir si ça ne marche pas 🙂

 public static bool isValidEmail(this ssortingng email) { ssortingng[] mail = email.Split(new ssortingng[] { "@" }, SsortingngSplitOptions.None); if (mail.Length != 2) return false; //check part before ...@ if (mail[0].Length < 1) return false; System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"^[a-zA-Z0-9_\-\.]+$"); if (!regex.IsMatch(mail[0])) return false; //check part after @... string[] domain = mail[1].Split(new string[] { "." }, StringSplitOptions.None); if (domain.Length < 2) return false; regex = new System.Text.RegularExpressions.Regex(@"^[a-zA-Z0-9_\-]+$"); foreach (string d in domain) { if (!regex.IsMatch(d)) return false; } //get TLD if (domain[domain.Length - 1].Length < 2) return false; return true; } 

Le studio visuel a eu ceci pendant des années.

 \w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)* 

J’espère que cela t’aides!

Motif ^[a-z0-9][-a-z0-9._]+@([-a-z0-9]+\.)+[az]{2,5}$ devrait fonctionner

Ce code aidera à valider les identifiants d’e-mail en utilisant l’expression regex dans c # .Net .. il est facile à utiliser

 if (!System.Text.RegularExpressions.Regex.IsMatch("", @"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$")) { MessageBox.show("Incorrect Email Id."); } 
 public bool checkEmailAddress(ssortingng emailAddress) { // FullKade.COm ssortingng patternSsortingct = @"^(([^<>()[\]\\.,;:\s@\""]+" + @"(\.[^<>()[\]\\.,;:\s@\""]+)*)|(\"".+\""))@" + @"((\[[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,}))$"; Regex reSsortingct = new Regex(patternSsortingct); bool isSsortingctMatch = reSsortingct.IsMatch(emailAddress); return isSsortingctMatch; // FullKade.COm } 

Une combinaison des réponses ci-dessus. J’utiliserais l’approche Microsoft préférée d’utiliser MailAddress mais implémenter comme une extension de chaîne:

 public static bool IsValidEmailAddress(this ssortingng emailaddress) { try { MailAddress m = new MailAddress(emailaddress); return true; } catch (FormatException) { return false; } } 

Ensuite, validez n’importe quelle chaîne en tant qu’adresse email avec:

 ssortingng customerEmailAddress = "[email protected]"; customerEmailAddress.IsValidEmailAddress() 

Nettoyer simple et portable. J’espère que ça aide quelqu’un. Regex pour les emails est en désordre.

Cela dit, MattSwanson a un blog sur ce sujet et il suggère fortement de ne PAS utiliser de regex, mais plutôt de vérifier «@» et peut-être un point. Lisez son explication ici: https://mdswanson.com/blog/2013/10/14/how-not-to-validate-email-addresses.html