Convalida dell’e-mail Regex

Io uso questo

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

regexp per convalidare l’email

([\w\.\-]+) – questo è per il dominio di primo livello (molte lettere e numeri, anche punto e trattino)

([\w\-]+) – questo è per il dominio di secondo livello

((\.(\w){2,3})+) – e questo è per altri domini di livello (da 3 a infinito) che include un punto e 2 o 3 letterali

cosa c’è di sbagliato in questa espressione regolare?

EDIT: non corrisponde alla email “[email protected]

Il tipo di museo di TLD non è abbinato in questo modo, e ci sono altri TLD lunghi. Inoltre, puoi convalidare gli indirizzi email usando la class MailAddress come Microsoft spiega qui in una nota:

Invece di utilizzare un’espressione regolare per convalidare un indirizzo email, è ansible utilizzare la class System.Net.Mail.MailAddress. Per determinare se un indirizzo e-mail è valido, passare l’indirizzo e-mail al costruttore della class MailAddress.MailAddress (String).

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

Questo ti evita un sacco di mal di testa perché non devi scrivere (o cercare di capire qualcun altro) espressioni regolari.

Penso che @"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$" dovrebbe funzionare.
Devi scriverlo come

 string 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"); 

Stai attento che questo fallirà se:

  1. C’è un sottodominio dopo il simbolo @ .

  2. Si utilizza un TLD con una lunghezza maggiore di 3, ad esempio .info

Ho un’espressione per controllare gli indirizzi e-mail che uso.

Dato che nessuno di questi è stato il più breve o preciso come il mio, ho pensato di pubblicarlo qui.

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

Per maggiori informazioni leggi qui: Espressioni regolari in C # (incluso un nuovo modello di email completo)

Inoltre, verifica la validità della RFC in base alla syntax della posta elettronica, non per stabilire se l’email esiste realmente. L’unico modo per verificare l’effettiva esistenza di una e-mail è inviare e-mail e chiedere all’utente di aver ricevuto l’e-mail facendo clic su un collegamento o inserendo un token.

Poi ci sono domini throw-away, come Mailinator.com, e così via. Questo non fa nulla per verificare se un’email proviene da un dominio usa e getta o no.

Ho trovato un bel documento su MSDN per questo.

Procedura: verificare che le stringhe siano nel formato di posta valido http://msdn.microsoft.com/en-us/library/01escwtf.aspx (verificare che questo codice supporti anche l’uso di caratteri non ASCII per i nomi di dominio Internet. )

Esistono 2 implementazioni, per .Net 2.0 / 3.0 e per .Net 3.5 e versioni successive.
la versione 2.0 / 3.0 è:

 bool IsValidEmail(string 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})(\]?)$"); } 

I miei test su questo metodo danno:

 Invalid: @majjf.com Invalid: [email protected]@[email protected] Invalid: Abc.example.com Valid: [email protected] Valid: [email protected] Invalid: js*@proseware.com Invalid: [email protected]e..com Valid: [email protected] Valid: [email protected] Invalid: [email protected]@jjf.com Invalid: [email protected] Invalid: [email protected] Invalid: [email protected] Invalid: [email protected] Invalid: [email protected] Valid: [email protected] Invalid: ------- Valid: [email protected] Valid: [email protected] Valid: [email protected] Valid: [email protected] Invalid: [email protected] Valid: [email protected][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] 

Questo non soddisfa tutti i requisiti delle RFC 5321 e 5322, ma funziona con le seguenti definizioni.

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

Di seguito è riportato il codice

 const String 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 `@` "[email protected]@[email protected]", // multiple `@` "[email protected]", // continuous multiple dots in name "[email protected]", // only 1 char in extension "[email protected]", // continuous multiple dots in domain "[email protected]@jjf.com", // continuous multiple `@` "@majjf.com", // nothing before `@` "[email protected]", // nothing after `.` "[email protected]", // nothing after `_` "[email protected]", // no domain extension "[email protected]", // nothing after `_` and . "[email protected]", // 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)); } 

Migliore regex di convalida della posta elettronica

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

Ed è l’uso: –

 bool isEmail = Regex.IsMatch(emailString, @"\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); 

Prova questo per dimensioni:

 public static bool IsValidEmailAddress(this string 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); } 

Questo impedisce le e-mail non valide menzionate da altri nei commenti:

 [email protected] [email protected] [email protected] [email protected] [email protected] 

Previene anche le e-mail con doppi punti:

 [email protected] 

Prova a testarlo con tanti indirizzi email non validi che puoi trovare.

 using System.Text.RegularExpressions; public static bool IsValidEmail(string 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}$).*"); } 

Vedi convalidare l’indirizzo email usando l’espressione regolare in C # .

Prova questo, funziona per me:

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

Perché non utilizzare la convalida dell’e-mail basata sugli attributi EF6?

Come si può vedere sopra, la convalida del Regex per l’e-mail ha sempre qualche lacuna. Se si utilizzano annotazioni di dati EF6, è ansible ottenere facilmente convalida e-mail affidabile e più forte con l’attributo di annotazione dei dati EmailAddress disponibile. Ho dovuto rimuovere la convalida regex che ho usato prima per l’e-mail quando ho ottenuto un errore di espressione regolare specifico del dispositivo mobile nel campo di input della posta elettronica. Quando l’attributo di annotazione dei dati utilizzato per la convalida della posta elettronica, il problema sui dispositivi mobili è stato risolto.

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

Il seguente codice è basato sull’implementazione delle annotazioni dei dati di Microsoft su github e penso che sia la convalida più completa per le e-mail:

 public static Regex EmailValidation() { const string 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.Compiled | 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); } 

Ci sono voluti molti tentativi per creare un validatore di e-mail che cattura quasi tutti i requisiti mondiali per la posta elettronica.

Metodo di estensione che puoi chiamare con:

 myEmailString.IsValidEmailAddress(); 

Stringa di pattern Regex che puoi ottenere chiamando

 var myPattern = Regex.EmailPattern; 

Il codice (principalmente commenti):

  ///  /// Validates the string is an Email Address... ///  ///  /// bool public static bool IsValidEmailAddress(this string 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 protected]") && !email.Contains("@."); } return (valid && isnotblank); } ///  /// Validates the string is an Email Address or a delimited string of email addresses... ///  ///  /// bool public static bool IsValidEmailAddressDelimitedList(this string emailAddress, char delimiter = ';') { var valid = true; var isnotblank = false; string[] emails = emailAddress.Split(delimiter); foreach (string 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 string 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 string SymbolCharacters = @"!#%&'""=`{}~\.\-\+\*\?\^\|\/\$"; ///  /// Regular Expression string 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 string EmailPattern = String.Format( @"^([\w{0}{2}])[email protected]{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(string str) { return Regex.IsMatch(str, @"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*"); } 

Io uso il codice sopra per convalidare l’indirizzo email.

  public bool VailidateEntriesForAccount() { if (!(txtMailId.Text.Trim() == string.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(string strEmail) { Regex validateEmail = new Regex("^[\\W]*([\\w+\\-.%][email protected][\\w\\-.]+\\.[A-Za-z] {2,4}[\\W]*,{1}[\\W]*)*([\\w+\\-.%][email protected][\\w\\-.]+\\.[A-Za-z]{2,4})[\\W]*$"); return validateEmail.IsMatch(strEmail); } 
 string patternEmail = @"(?\[email protected]\w+\.[az]{0,3})"; Regex regexEmail = new Regex(patternEmail); 

Per convalidare il tuo ID e-mail, puoi semplicemente creare tale metodo e usarlo.

  public static bool IsValidEmail(string 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 !String.IsNullOrEmpty(email) && r.IsMatch(email); } 

Questo restituirà True / False. (ID email valido / non valido)

Questo è il mio approccio preferito fino ad ora:

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

Quindi utilizzare l’estensione della stringa creata come:

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

Prova il seguente codice:

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

RICERCA DI STRING UTILIZZANDO IL METODO DI REGEX IN C #

Come convalidare un’e-mail mediante un’espressione regolare?

 string 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); } 

Utilizzare il metodo Reference String.Regex ()

1

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

2

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

Penso che il tuo segno di omissione e il simbolo del dollaro siano parte del problema Dovresti anche modificare un po ‘la regex, io uso il prossimo @ “[:] + ([\ w .-] +) @ ([\ w -.]) + ((. (\ w) {2,3}) +)”

Regex Email Pattern:

 ^(?:[\\w\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`\\{\\|\\}\\~]+\\.)*[\\w\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`\\{\\|\\}\\~][email protected](?:(?:(?:[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])\\]))$ 

Sto usando Regex.IsMatch ().

Prima di tutto è necessario aggiungere la prossima dichiarazione:

 using System.Text.RegularExpressions; 

Quindi il metodo sembra:

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

È un metodo privato a causa della mia logica, ma puoi mettere il metodo come statico in un altro livello come "Utilità" e chiamarlo da dove ti serve.

Non esiste un’espressione regolare perfetta, ma questa è piuttosto forte, penso, basata sullo studio di RFC5322 . E con l’interpolazione della stringa C #, abbastanza facile da seguire, penso anch’io.

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

Allenato con NUnit 2.x

Fammi sapere SE non funziona 🙂

 public static bool isValidEmail(this string email) { string[] mail = email.Split(new string[] { "@" }, StringSplitOptions.None); if (mail.Length != 2) return false; //check part before [email protected] 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; } 

Lo studio visivo ha avuto questo per anni.

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

Spero che questo ti aiuti!

Modello ^[a-z0-9][-a-z0-9._][email protected]([-a-z0-9]+\.)+[az]{2,5}$ dovrebbe funzionare

Questo codice aiuterà a convalidare l’id della mail usando espressioni regolari in c #. Net..it è facile da usare

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

Una combinazione delle risposte di cui sopra. Vorrei utilizzare l’approccio Microsoft preferito per l’uso di MailAddress, ma implementarlo come un’estensione della stringa:

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

Quindi convalida qualsiasi stringa come indirizzo email con:

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

Pulisci semplice e portatile. Spero che aiuti qualcuno. Regex per le email sono disordinate.

Detto questo, MattSwanson ha un blog su questo argomento e suggerisce vivamente di non usare espressioni regolari e invece di controllare semplicemente “@” e forse un punto. Leggi la sua spiegazione qui: https://mdswanson.com/blog/2013/10/14/how-not-to-validate-email-addresses.html