validar regular expresion electronico correo c# email email-validation

regular - Código C#para validar la dirección de correo electrónico



expresion regular email c# (30)

.net 4.5 agregó System.ComponentModel.DataAnnotations.EmailAddressAttribute

Puede navegar por la fuente de EmailAddressAttribute , este es el 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])))/.?$";

¿Cuál es el código más elegante para validar que una cadena es una dirección de correo electrónico válida?

/ Usando el Regex interno utilizado en la creación del "nuevo EmailAddressAttribute ();" componente en .Net4.5 >>> usando System.ComponentModel.DataAnnotations; // Para validar una dirección de correo electrónico ...... Probado y en funcionamiento.

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

Además, puedes usar esto:

http://msdn.microsoft.com/en-us/library/01escwtf(v=vs.110).aspx

Aquí está mi respuesta: la solución de Phil falla para dominios de una sola letra como "[email protected]". Lo creas o no, se usa =) (va a centurylink, por ejemplo).

La respuesta de Phil también funcionará solo con el estándar PCRE ... así que C # lo tomará, pero javascript va a explotar. Es demasiado complejo para javascript. Entonces no puedes usar la solución de Phil para los atributos de validación de mvc.

Aquí está mi expresión regular. Funcionará bien con los atributos de validación de MVC.
- Todo antes de la @ se simplifica, por lo que al menos javascript funcionará. Estoy bien relajando la validación aquí siempre que el servidor de Exchange no me dé un 5.1.3. - Todo después de la @ es la solución de Phil modificada para dominios de una sola letra.

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 las personas que sugieren usar system.net.mail MailMessage (), esa es una manera muy flexible. Claro, C # aceptará el correo electrónico, pero el servidor de intercambio bombardeará con un error de tiempo de ejecución 5.1.3 tan pronto como intentes enviar el correo electrónico.

Aquí hay una respuesta a su pregunta para que la compruebe.

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

Considero que esta expresión regular es un buen intercambio entre la comprobación de algo más que la marca @, y la aceptación de casos de borde extraño:

^[^@/s]+@[^@/s]+(/.[^@/s]+)+$

Al menos hará que coloques algo alrededor de la marca @, y pongas al menos un dominio de aspecto normal.

Creo que la mejor manera es como sigue:

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

Puedes tener esta función estática en una clase general.

En términos generales, una expresión regular para validar direcciones de correo electrónico no es algo fácil de encontrar; En el momento de escribir este documento, la sintaxis de una dirección de correo electrónico debe seguir un número relativamente alto de estándares, y su implementación en una expresión regular es prácticamente inviable.

Le sugiero que pruebe nuestra EmailVerify.NET , una biblioteca .NET madura que puede validar las direcciones de correo electrónico siguiendo todos los estándares actuales de IETF (RFC 1123, RFC 2821, RFC 2822, RFC 3696, RFC 4291, RFC 5321 y RFC 5322) , prueba los registros DNS relacionados, comprueba si los buzones de destino pueden aceptar mensajes e incluso pueden decir si una dirección dada es desechable o no.

Descargo de responsabilidad: Soy el desarrollador principal de este componente.

Escribí una función para verificar si un correo electrónico es válido o no. Parece funcionar bien para mí en la mayoría de los 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; }

Esta es una pregunta antigua, pero todas las respuestas que he encontrado en SO, incluidas las más recientes, se responden de manera similar a esta. Sin embargo, en .Net 4.5 / MVC 4 puede agregar la validación de la dirección de correo electrónico a un formulario agregando la anotación [Dirección de correo electrónico] desde System.ComponentModel.DataAnnotations, así que me preguntaba por qué no podía usar la funcionalidad incorporada de. Red en general.

Esto parece funcionar, y me parece bastante elegante:

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

Hay muchas respuestas fuertes aquí. Sin embargo, recomiendo que demos un paso atrás. @Cogwheel responde a la pregunta https://.com/a/1374644/388267 . Sin embargo, podría ser costoso en un escenario de validación masiva, si muchas de las direcciones de correo electrónico que se validan no son válidas. Sugiero que utilicemos un poco de lógica antes de entrar en su bloque try-catch. Sé que el siguiente código podría escribirse usando RegEx pero eso podría ser costoso para los nuevos desarrolladores entenderlo. Esta es mi valor de dos peniques:

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://.com/a/1374644/388267 try { var addr = new System.Net.Mail.MailAddress(input); return addr.Address == input; } catch { return false; } }

La forma más elegante es usar los métodos incorporados de .Net.

Estos métodos:

  • Se prueban y se prueban. Estos métodos son utilizados en mis propios proyectos profesionales.

  • Use expresiones regulares internamente, que son confiables y rápidas.

  • Hecho por Microsoft para C #. No hay necesidad de reinventar la rueda.

  • Devuelve un resultado bool. Verdadero significa que el correo electrónico es válido.

Para usuarios de .Net 4.5 y superiores.

Agregue esta referencia a su proyecto:

System.ComponentModel.DataAnnotations

Ahora puedes usar el siguiente código:

(new EmailAddressAttribute().IsValid("[email protected]"));

Ejemplo de uso

Aquí hay algunos 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; }

... y código demostrando en acción:

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

Además, este ejemplo:

  • Se extiende más allá de la especificación, ya que se utiliza una sola cadena para contener 0, una o varias direcciones de correo electrónico separadas por un punto y coma ; .
  • Demuestra claramente cómo usar el método IsValid del objeto EmailAddressAttribute.

Alternativa, para usuarios de una versión de .Net inferior a 4.5.

Para situaciones donde .Net 4.5 no está disponible, uso la siguiente solución:

Específicamente, yo 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; }

La validación de la dirección de correo electrónico no es tan fácil como parece. En realidad, en teoría es imposible validar completamente una dirección de correo electrónico usando solo una expresión regular.

Echa un vistazo a mi blog para obtener una discusión sobre el tema y una implementación de F # con FParsec. [/ shameless_plug]

Para ser honesto, en el código de producción, lo mejor que hago es buscar un símbolo @ .

Nunca estoy en un lugar para validar completamente los correos electrónicos. ¿Sabes cómo veo si era realmente válido? Si fue enviado. Si no lo hizo, es malo, si lo hizo, la vida es buena. Éso es Todo lo que Necesito Saber.

Personalmente, diría que debería asegurarse de que haya un símbolo @ allí, posiblemente con un. personaje. Hay muchas expresiones regulares que puede usar de corrección variable, pero creo que la mayoría de ellas omiten las direcciones de correo electrónico válidas, o dejan pasar las inválidas. Si la gente quiere poner una dirección de correo electrónico falsa, la pondrá en una falsa. Si necesita verificar que la dirección de correo electrónico es legítima y que la persona tiene el control de esa dirección de correo electrónico, deberá enviar un correo electrónico con un enlace codificado especial para que pueda verificar que realmente es una dirección real.

Que hay de esto

bool IsValidEmail(string email) { try { var addr = new System.Net.Mail.MailAddress(email); return addr.Address == email; } catch { return false; } }

Para aclarar, la pregunta es si una cadena en particular es una representación válida de una dirección de correo electrónico, no si una dirección de correo electrónico es un destino válido para enviar un mensaje. Para eso, la única manera real es enviar un mensaje para confirmar.

Tenga en cuenta que las direcciones de correo electrónico son más indulgentes de lo que podría suponer. Estas son todas las formas perfectamente válidas:

  • rueda dentada
  • "cogwheel the orange" @ example.com
  • 123@$.xyz

Para la mayoría de los casos de uso, un falso "inválido" es mucho peor para sus usuarios y pruebas futuras que un falso "válido". Aquí hay un artículo que solía ser la respuesta aceptada a esta pregunta (esa respuesta ya se ha eliminado). Tiene muchos más detalles y algunas otras ideas de cómo resolver el problema.

Proporcionar controles de cordura sigue siendo una buena idea para la experiencia del usuario. Asumiendo que la dirección de correo electrónico es válida, puede buscar dominios conocidos de nivel superior, verificar el dominio para un registro MX, verificar errores ortográficos de nombres de dominio comunes (gmail.cmo), etc. Luego, presente una advertencia que indica al usuario una oportunidad de decir "sí, mi servidor de correo realmente permite 🌮🍳🎁 como una dirección de correo electrónico".

En cuanto al uso del manejo de excepciones para la lógica empresarial, estoy de acuerdo en que es algo que debe evitarse. Pero este es uno de esos casos en los que la conveniencia y la claridad pueden superar al dogma.

Además, si hace algo más con la dirección de correo electrónico, probablemente implique convertirla en una dirección de correo. Incluso si no usa esta función exacta, probablemente querrá usar el mismo patrón. También puede verificar tipos específicos de fallas capturando diferentes excepciones : formato nulo, vacío o no válido.

Según el comentario de Stuart, esto compara la dirección final con la cadena original en lugar de devolver siempre verdadero. MailAddress intenta analizar una cadena con espacios en las secciones "Nombre para mostrar" y "Dirección", por lo que la versión original devolvía falsos positivos.

--- Otras lecturas ---

Documentación para System.Net.Mail.MailAddress

Explicación de lo que constituye una dirección de correo electrónico válida

Si realmente quiere decir que realmente queremos saber si una dirección de correo electrónico es válida ... pídale al intercambiador de correo que lo pruebe, no se necesita una expresión regular. Puedo proporcionar el código si así lo solicita.

Los pasos generales son los siguientes: 1. ¿La dirección de correo electrónico tiene una parte de nombre de dominio? (índice de @> 0) 2. usando una consulta de DNS pregunte si el dominio tiene un intercambiador de correo 3. abra la conexión tcp al intercambiador de correo 4. usando el protocolo smtp, abra un mensaje al servidor usando la dirección de correo electrónico como el receptor 5. analizar la respuesta del servidor. 6. Salga del mensaje si llegó hasta aquí, todo está bien.

Esto es lo que puede imaginar, es muy costoso y depende de smtp, pero funciona.

Sucinticé la respuesta de Poyson 1 así:

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

Tomé la respuesta de Phil del # 1 y creé esta clase. Llámelo así: bool isValid = Validator.EmailIsValid(emailString);

Aquí está la clase:

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

Utilizo este método de revestimiento único que hace el trabajo por mí-

using System.ComponentModel.DataAnnotations; public bool IsValidEmail(string source) { return new EmailAddressAttribute().IsValid(source); }

Verifique que la cadena de correo electrónico tenga el formato correcto o el formato incorrecto 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"; } }

Código corto y 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); }

Según la respuesta de @Cogwheel, quiero compartir una solución modificada que funciona para SSIS y el "Componente de script":

  1. Coloque el "componente de script" en su conexión de flujo de datos y luego ábralo.
  2. En la sección "Columnas de entrada", establezca el campo que contiene las direcciones de correo electrónico en "ReadWrite" (en el ejemplo ''fieldName'').
  3. Vuelva a la sección "Script" y haga clic en "Editar Script". Entonces necesitas esperar después de que se abra el código.

  4. Coloque este código en el método correcto:

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

Luego puede usar una división condicional para filtrar todos los registros no válidos o lo que quiera hacer.

Terminé usando esta expresión regular, ya que valida con éxito las comas, comentarios, caracteres Unicode y direcciones de dominio IP (v4).

Las direcciones válidas serán:

"" @ example.org

(comment)[email protected]

тест@example.org

ტესტი @ example.org

prueba @ [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,}))$";

Una forma sencilla de identificar el email es válida o no.

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

Una pequeña modificación a la respuesta de @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; } }

En caso de que estés usando FluentValidation , podrías escribir algo tan simple como esto:

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;

Hay un problema de cultura en expresiones regulares en C # en lugar de js. Por lo tanto, necesitamos usar expresiones regulares en el modo de EE. UU. Para verificar el correo electrónico. Si no usa el modo ECMAScript, los caracteres especiales de su idioma están implicados en AZ con 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)

La respuesta más votada de @Cogwheel es la mejor, sin embargo, he intentado implementar el trim()método de cadena para que recorte todo el espacio en blanco del usuario desde la cadena de principio a fin. Verifique el código de abajo para ver el ejemplo completo.

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

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