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

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 validación de dirección de correo electrónico a un formulario agregando la anotación [EmailAddress] del Sistema.ComponentModel.DataAnnotations, así que me preguntaba por qué no podía usar la funcionalidad incorporada de.Net 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;    
    }
}

. net 4.5 agregado Sistema.ComponentModel.DataAnnotations.EmailAddressAttribute

Puede navegar por la fuente de EmailAddressAttribute , esta es la expresión regular 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])))\.?$";

Tomé la respuesta de Phil del #1 y creé esta clase. Llámalo 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);
}

Personalmente, yo diría que usted debe asegurarse de que hay un símbolo @ allí, con posiblemente un . caracter. Hay muchas expresiones regulares que podría usar de corrección variable, pero creo que la mayoría de ellas omiten direcciones de correo electrónico válidas o dejan pasar las no válidas. Si la gente quiere poner una dirección de correo electrónico falsa, pondrán 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, entonces deberá enviarles una correo electrónico con un enlace codificado especial para que puedan verificar que realmente es una dirección real.

Creo que la mejor manera es la siguiente:

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

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

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

Estos métodos:

• Son probados y probados. Estos métodos se utilizan en mis propios proyectos profesionales.

• Utilice 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. True significa que el correo electrónico es válido.

Para los usuarios de. Net 4.5 y mayor

Añade esta Referencia a tu proyecto:

Sistema.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 demostrándolos 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 una sola cadena se utiliza para contener 0, una o muchas direcciones de correo electrónico sperated por un punto y coma ;.
• Muestra 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 en las que. Net 4.5 no está disponible, utilizo la siguiente solución:

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

}

Encuentro que esta expresión regular es un buen intercambio entre verificar algo más que la marca @ y aceptar casos extremos extraños:

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

Al menos te hará poner algo alrededor de la marca@, y poner al menos un dominio de aspecto normal.

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

La validación de direcciones de correo electrónico no es tan fácil como parece. En realidad, es teóricamente imposible validar completamente una dirección de correo electrónico utilizando solo una expresión regular.

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

Para ser honesto, en código de producción, lo mejor que hago es comprobar si hay 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, es malo, si lo hizo, la vida es buena. Es todo lo que necesito saber.

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

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

Aquí está mi expresión regular. Funcionará muy bien con atributos de validación MVC.
- Todo antes el @ se simplifica, por lo que al menos javascript funcionará. Estoy bien relajando la validación aquí, siempre y cuando Exchange Server no me dé un 5.1.3. - Todo después de la @ es la solución de Phil modificado 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 cosa es MUY flexible. Claro, C# aceptará el correo electrónico, pero luego Exchange Server bombardeará con un error de tiempo de ejecución 5.1.3 tan pronto como intente enviar el correo electrónico.

Si realmente quieres saber si una dirección de correo electrónico es válida...pídale al intercambiador de correo que lo demuestre, no necesita expresiones regulares. Puedo proporcionar el código si se 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 DNS pregunte si el dominio tiene un intercambiador de correo 3. conexión tcp abierta al intercambiador de correo 4. usando el protocolo smtp, abra un mensaje al servidor usando la dirección de correo electrónico como receptor 5. analizar el servidor respuesta. 6. deja el mensaje si llegaste tan lejos, todo está bien.

Esto es como se puede imaginar, muy caro en cuanto al tiempo y se basa en smtp, pero funciona.

En términos generales, una expresión regular para validar direcciones de correo electrónico no es una cosa fácil de llegar a; en el momento de escribir este artículo, la sintaxis de una dirección de correo electrónico debe seguir un número relativamente alto de estándares y la implementación de todos ellos dentro de una expresión regular es prácticamente inviable!

Le sugiero que pruebe nuestro EmailVerify.NET , una biblioteca. NET madura que puede validar direcciones de correo electrónico siguiendo todos de los estándares IETF actuales (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 correo 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.

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

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

/Usando la expresión regular interna usada en la creación del componente "new EmailAddressAttribute();" en .Net4.5 >>> usando System.ComponentModel.DataAnnotations; // Para Validar una Dirección de Correo Electrónico......Probado y trabajando.

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

También puedes usar esto:

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

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;

   }

}

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

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

Escribí una función para comprobar si un correo electrónico es válido o no. Parece que funciona 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;
    }

Una forma sencilla de identificar el emailid 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})(\]?)$");
}

Hay un problema de cultura en regex en C# en lugar de js. Así que tenemos que utilizar regex en el modo de EE.UU. para la verificación de correo electrónico. Si no utiliza el modo ECMAScript, los caracteres especiales de su idioma se implican en A-Z con expresiones regulares.

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)

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

Las direcciones válidas serán:

"" @example.org

(comentario)[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,}))$";

En caso de que esté utilizando FluentValidation podría 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;

Basado en la respuesta de @Cogwheel quiero compartir una solución modificada que funciona para SSIS y el"Componente Script":

1. Coloque el "Componente 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". Luego, debe esperar después de que se abra el código.

4. Coloque esto 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";
       }
   }
   

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

Una pequeña modificación a @Cogwheel respuesta

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

1. En un "bloque de prueba" envíe un correo electrónico de verificación.
2. Haga que el usuario abra el correo electrónico y haga clic en un enlace verificando que el correo electrónico es real.

Hasta que este proceso se complete con éxito, se asume que el correo electrónico no es válido.

Hace algún tiempo, escribí un EmailAddressValidationAttribute que debería validar correctamente casi cualquier dirección de correo electrónico relativamente normal del formulario

local-part@domain

Es un System.ComponentModel.DataAnnotations.ValidationAttribute, por lo que el uso es realmente simple.

Y, desde excavar a través de todos los RFC y erratas y ensamblar todos los bits necesarios para enumerar correctamente todas las reglas es...tedioso-en el mejor de los casos! - Publiqué el código fuente para el validador en mi respuesta a la pregunta Validación de la dirección de correo electrónico C# para la fuente codificar.

Mi validador no es perfecto por ningún tramo de la imaginación, aunque solo para empezar, no tiene ningún soporte incorporado para emitir validación de javascript del lado del cliente, aunque no sería demasiado difícil agregarlo. De mi respuesta anterior:

Aquí está el atributo de validación que escribí. Valida prácticamente todos los correos" raw" dirección, es decir, las de la forma local-part@domain. No es compatible con ninguno de el otro, más...creativo construcciones que permiten los RFC (esta lista no es comprehensive by any means):

• comentarios (e. g., [email protected] (work))
• cadenas entrecomilladas (texto escapado, para permitir caracteres no permitidos en un átomo)
• literales de dominio (por ejemplo, foo@[123.45.67.012])
• bang-paths (también conocido como enrutamiento de fuentes)
• direcciones de ángulo (por ejemplo, John Smith <[email protected]>)
• plegando espacios en blanco
• caracteres de doble byte en local-parto dominio (solo ASCII de 7 bits).
• etc.

Debe aceptar casi cualquier dirección de correo electrónico que se pueda expresar de esta manera

• [email protected]

Sin requerir el uso de comillas ("), corchetes angulares ('') o entre corchetes ([]).

No se intenta validar que la etiqueta dns más a la derecha en el dominio es válida TLD (dominio de nivel superior). Esto se debe a que la lista de TLDs es mucho más grande ahora que el "big 6" (. com,. edu,. gov,. mil,. net,. org) más códigos de país ISO de 2 letras. La ICANN actualiza diariamente la lista de TLD, aunque sospecho que la lista en realidad no cambia diariamente. Además, [la ICANN acaba de aprobar una gran espacio de nombres genérico de TLD] [2]). Y algunas direcciones de correo electrónico no tienen lo que reconocerías como TLD (¿sabías que postmaster@. es teóricamente válido y se puede enviar por correo? Correo a esa dirección debe ser entregada al postmaster de la zona raíz DNS.)

Extendiendo el la expresión para soportar literales de dominio no debería ser demasiado difícil.