c# - validate - Validación de correo electrónico Regex

regex expression c# email (28)

yo uso esto

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

expresiones regulares para validar el correo electrónico

([/w/./-]+) - esto es para el dominio de primer nivel (muchas letras y números, también punto y guión)

([/w/-]+) - esto es para dominio de segundo nivel

((/.(/w){2,3})+) - y esto es para otros dominios de nivel (de 3 a infinito) que incluye un punto y 2 o 3 literales

¿Qué pasa con esta expresión regular?

EDITAR: no coincide con el correo electrónico "[email protected]"

Éste evita que los correos electrónicos no válidos mencionados por otros en los comentarios:

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

También evita los correos electrónicos con puntos dobles:

[email protected]

Intente probarlo con tantas direcciones de correo no válidas como pueda encontrar.

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]+)*/.)+[a-z]{2,4}/z") && Regex.IsMatch(email, @"^(?=.{1,64}@.{4,64}$)(?=.{6,100}$).*"); }

Ver validar la dirección de correo electrónico usando la expresión regular en C # .

Creo que @"^([/w/./-]+)@([/w/-]+)((/.(/w){2,3})+)$" debería funcionar.
Necesitas escribirlo como

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

Ten en cuenta que esto no funcionará si:

Hay un subdominio después del símbolo @ .
Utiliza un TLD con una longitud mayor que 3, como .info

Creo que tu signo de cariño y de dólar son parte del problema. También debes modificar un poco la expresión regular, utilizo el siguiente @ "[:] + ([/ w .-] +) @ ([/ w -.]) + ((. (/ w) {2,3}) +) "

El siguiente código se basa en la implementación de anotaciones de datos de Microsoft en github y creo que es la validación más completa para los correos electrónicos:

public static Regex EmailValidation() { 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])))/.?$"; 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); }

Encontré un buen documento en MSDN para él.

Cómo: verificar que las cadenas están en formato de correo electrónico válido here (verifique que este código también admite el uso de caracteres no ASCII para nombres de dominio de Internet. )

Hay 2 implementaciones para .Net 2.0 / 3.0 y para .Net 3.5 y superior.
la versión 2.0 / 3.0 es:

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})(/]?)$"); }

Mis pruebas sobre este método dan:

Este es mi enfoque favorito para esto hasta ahora:

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

Luego use la extensión de cadena creada como:

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

Esto no cumple con todos los requisitos de las RFC 5321 y 5322, pero funciona con las siguientes definiciones.

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

A continuación está el código

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 `@` "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)); }

He estado usando Regex.IsMatch ().

En primer lugar, debe agregar la siguiente declaración:

using System.Text.RegularExpressions;

Entonces el método se ve así:

private bool EmailValidation(string pEmail) { return Regex.IsMatch(pEmail, @"^(?("")("".+?(?<!//)""@)|(([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)); }

Es un método privado debido a mi lógica, pero puedes poner el método como estático en otra capa, como "Utilidades" y llamar desde donde lo necesites.

La mejor expresión de validación de correo electrónico

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

Y es 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);

No hay una expresión regular perfecta, pero creo que esta es bastante fuerte, según el estudio de RFC5322 . Y con la interpolación de cadenas C #, es bastante fácil de seguir, creo, también.

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

Vetted con NUnit 2.x

Para validar su ID de correo electrónico, puede simplemente crear dicho método y 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); }

Esto devolverá verdadero / falso. (ID de correo electrónico válido / no válido)

Patrón de correo electrónico Regex:

^(?:[//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])//]))$

Prueba esto para el tamaño:

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

Prueba esto, está funcionando para mí:

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("."); } }

Pruebe el siguiente código:

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

Se han necesitado muchos intentos para crear un validador de correo electrónico que capte casi todos los requisitos mundiales para el correo electrónico.

Método de extensión con el que puede llamar:

myEmailString.IsValidEmailAddress();

Cadena de patrón Regex que puedes obtener llamando:

var myPattern = Regex.EmailPattern;

El código (principalmente comentarios):

/// <summary> /// Validates the string is an Email Address... /// </summary> /// <param name="emailAddress"></param> /// <returns>bool</returns> 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: a-z 0-9 ! # _ % & '' " = ` { } ~ - + * ? ^ | / $ // Cannot have period immediately before @ sign. // Cannot have two @ symbols // In the domain, valid characters are: a-z 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); } /// <summary> /// Validates the string is an Email Address or a delimited string of email addresses... /// </summary> /// <param name="emailAddress"></param> /// <returns>bool</returns> 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 { /// <summary> /// Set of Unicode Characters currently supported in the application for email, etc. /// </summary> public static readonly string UnicodeCharacters = "À-ÿ/p{L}/p{M}ÀàÂâÆæÇçÈèÉéÊêËëÎîÏïÔôŒœÙùÛûÜü«»€₣äÄöÖüÜß"; // German and French /// <summary> /// 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. /// </summary> public static readonly string SymbolCharacters = @"!#%&''""=`{}~/./-/+/*/?/^/|///$"; /// <summary> /// 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. /// </summary> public static readonly string EmailPattern = String.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 ); }

TLD''s like .museum no se corresponden de esta manera, y hay otros TLD largos. Además, puede validar las direcciones de correo electrónico utilizando la clase MailAddress como explica Microsoft here en una nota:

En lugar de usar una expresión regular para validar una dirección de correo electrónico, puede usar la clase System.Net.Mail.MailAddress. Para determinar si una dirección de correo electrónico es válida, pase la dirección de correo electrónico al constructor de la clase MailAddress.MailAddress (String).

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

Esto le ahorra muchos dolores de cabeza porque no tiene que escribir (o tratar de entender la expresión regular de otra persona).

Tengo una expresión para verificar la dirección de correo electrónico que uso.

Dado que ninguno de los anteriores era tan breve o tan preciso como el mío, pensé que lo publicaría aquí.

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

Para obtener más información, lee aquí: Expresiones regulares en C # (incluido un nuevo patrón de correo electrónico completo)

Una combinación de las respuestas anteriores. Usaría el enfoque preferido de Microsoft para usar MailAddress pero lo implementaría como una extensión de cadena:

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

Luego simplemente valide cualquier cadena como una dirección de correo electrónico con:

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

Limpio simple y portátil. Espero que ayude a alguien. Regex para correos electrónicos es complicado.

Dicho esto, MattSwanson tiene un blog sobre este tema y sugiere encarecidamente NO usar expresiones regulares y, en su lugar, solo verificar si tiene "@" y quizás un punto. Lea su explicación aquí: https://mdswanson.com/blog/2013/10/14/how-not-to-validate-email-addresses.html

Visual Studio tuvo esto por años.

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

¡Espero que esto ayude!

¿Por qué no utilizar la validación de correo electrónico basada en atributos EF6?

Como puede ver arriba, la validación de Regex para correo electrónico siempre tiene algún problema. Si está utilizando anotaciones de datos EF6, puede lograr fácilmente una validación de correo electrónico confiable y más fuerte con el atributo de anotación de datos EmailAddress disponible para eso. Tuve que eliminar la validación de expresiones regulares que usaba antes para el correo electrónico cuando recibí una falla de expresión regular específica del dispositivo móvil en el campo de entrada de correo electrónico. Cuando se utilizó el atributo de anotación de datos para la validación de correo electrónico, se resolvió el problema en el dispositivo móvil.

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

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

^(([^<>()[/]//.,;:/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,}))$

BÚSQUEDA DE CUERDAS CON EL MÉTODO REGEX EN C #

¿Cómo validar un correo electrónico por expresión regular?

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

Usar el método Reference String.Regex ()

Este código ayudará a validar la identificación del correo electrónico usando expresiones regex en c # .Net .. es fácil de usar

if (!System.Text.RegularExpressions.Regex.IsMatch("<Email String Here>", @"^([/w/./-]+)@([/w/-]+)((/.(/w){2,3})+)$")) { MessageBox.show("Incorrect Email Id."); }

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+//-.%]+@[//w//-.]+//.[A-Za-z] {2,4}[//W]*,{1}[//W]*)*([//w+//-.%]+@[//w//-.]+//.[A-Za-z]{2,4})[//W]*$"); return validateEmail.IsMatch(strEmail); }

public bool checkEmailAddress(string emailAddress) { // FullKade.COm string patternStrict = @"^(([^<>()[/]//.,;:/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 reStrict = new Regex(patternStrict); bool isStrictMatch = reStrict.IsMatch(emailAddress); return isStrictMatch; // FullKade.COm }

public static bool ValidateEmail(string str) { return Regex.IsMatch(str, @"/w+([-+.'']/w+)*@/w+([-.]/w+)*/./w+([-.]/w+)*"); }

Uso el código anterior para validar la dirección de correo electrónico.

string patternEmail = @"(?<email>/w+@/w+/.[a-z]{0,3})"; Regex regexEmail = new Regex(patternEmail);