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

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

¿Qué 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 forma 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 primero. Estas son todas formas perfectamente válidas:

• rueda dentada
• "rueda dentada la naranja" @ 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 se ha eliminado desde entonces). Tiene muchos más detalles y algunas otras ideas sobre cómo resolver el problema.

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

En cuanto al uso de 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 donde la conveniencia y la claridad pueden ser mayores que el dogma.

Además, si hace algo más con la dirección de correo electrónico, probablemente implicará convertirlo en una dirección de correo electrónico. Incluso si no usa esta función exacta, probablemente quiera usar el mismo patrón. También puede verificar si hay tipos específicos de fallas al detectar diferentes excepciones : nulo, vacío o formato 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 partes "Nombre para mostrar" y "Dirección", por lo que la versión original estaba devolviendo 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.

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 [EmailAddress] de System.ComponentModel.DataAnnotations, por lo que me preguntaba por qué no podía usar la funcionalidad incorporada. Neto 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("someone@somewhere.com");         //true
        bar = foo.IsValid("someone@somewhere.co.uk");       //true
        bar = foo.IsValid("someone+tag@somewhere.net");     //true
        bar = foo.IsValid("futureTLD@somewhere.fooo");      //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("someone@somewhere.com"))
            bar = true;    
    }
}

Utilizo este método de línea única que hace el trabajo por mí.

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

Según los comentarios, esto "fallará" si source(la dirección de correo electrónico) es nula.

public static bool IsValidEmailAddress(this string address) => address != null && new EmailAddressAttribute().IsValid(address);

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

Puede navegar por la fuente de EmailAddressAttribute , esta es la expresión regular que utiliza 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;
    }
}

Personalmente, diría que debes asegurarte de que haya un símbolo @ allí, posiblemente con un. personaje. Hay muchas expresiones regulares que podría usar con una 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 las personas desean ingresar una dirección de correo electrónico falsa, ingresarán una dirección 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á enviarles un 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 expression = "\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";

        if (Regex.IsMatch(email, expression))
        {
            if (Regex.Replace(email, expression, string.Empty).Length == 0)
            {
                return true;
            }
        }
        return false;
    }

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

Código corto y preciso

string Email = txtEmail.Text;
if (Email.IsValidEmail())
{
   //use code here 
}

public static bool IsValidEmail(this string email)
{
  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 forma más elegante es utilizar los métodos integrados de .Net.

Estos métodos:

• Son probados y probados. Estos métodos se utilizan 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 superior

Agregue esta referencia a su proyecto:

System.ComponentModel.DataAnnotations

Ahora puede usar el siguiente código:

(new EmailAddressAttribute().IsValid("youremailhere@test.test"));

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 que los demuestra 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 usa para contener 0, una o varias direcciones de correo electrónico escritas por un punto y coma ;.
• Demuestra claramente cómo utilizar 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, 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;

}

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 por completo los correos electrónicos. ¿Sabes cómo veo si fue 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.

Considero que esta expresión regular es una buena compensación entre verificar algo más que solo la marca @ y aceptar casos extraños:

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

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

La validación de la dirección 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.

Consulte mi publicación de blog al respecto para una discusión sobre el tema y una implementación de F # usando FParsec. [/ shameless_plug]

Aquí está mi respuesta: la solución de Phil falla para dominios de una letra como "someone@q.com". Lo creas o no, eso se usa =) (va a centurylink, por ejemplo).

La respuesta de Phil también funcionará solo con el estándar PCRE ... por lo que C # lo tomará, pero JavaScript va a bombardear. Es demasiado complejo para javascript. Por lo tanto, no puede 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 MVC.
- Todo antes de @ se simplifica, por lo que al menos JavaScript funcionará. Estoy bien relajando la validación aquí, siempre y cuando el servidor de intercambio no me dé un 5.1.3. - Todo después de @ es la solución de Phil modificada para dominios de una 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 (), eso es MANERA de ser flexible. Claro, C # aceptará el correo electrónico, pero luego el servidor de Exchange bombardeará con un error de tiempo de ejecución 5.1.3 tan pronto como intente enviar el correo electrónico.

Si realmente quiere decir si quiere saber si una dirección de correo electrónico es válida ... pídale al intercambiador de correo que lo pruebe, no se necesita regex. 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 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, como puede imaginar, un tiempo muy costoso y depende de smtp, pero funciona.

En términos generales, una expresión regular para validar direcciones de correo electrónico no es algo fácil de inventar; 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 recomiendo que pruebe nuestro 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 correo de destino pueden aceptar mensajes e incluso puede decir si una dirección determinada es desechable o no.

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

For the simple email like goerge@xxx.com, 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;
        }

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;

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

Hay muchas respuestas fuertes aquí. Sin embargo, recomiendo que demos un paso atrás. @Cogwheel responde la pregunta https://stackoverflow.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 empleemos 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. Este 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://stackoverflow.com/a/1374644/388267 
        try
        {
            var addr = new System.Net.Mail.MailAddress(input);
            return addr.Address == input;
        }
        catch
        {
            return false;
        }
    }

La respuesta más votada de @Cogwheel es la mejor respuesta, sin embargo, he intentado implementar el trim()método de cadena para que recorte todo el espacio en blanco del usuario de principio a fin. Verifique el código a continuación para ver un 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;
    }
}

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

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

/ Uso de la expresión regular interna utilizada para crear el "nuevo EmailAddressAttribute ();" componente en .Net4.5 >>> usando System.ComponentModel.DataAnnotations; // Para validar una dirección de correo electrónico ...... Probado y funcionando.

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

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

Una forma simple de identificar el correo electrónico 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. Por lo tanto, necesitamos usar expresiones regulares en modo estadounidense para la verificación de correo electrónico. Si no usa el modo ECMAScript, los caracteres especiales de su idioma están implícitos 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)

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) prueba@ejemplo.org

тест@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 simple sin usar Regex (que no me gusta por su poca legibilidad):

bool IsValidEmail(string email)
{
    string emailTrimed = email.Trim();

    if (!string.IsNullOrEmpty(emailTrimed))
    {
        bool hasWhitespace = emailTrimed.Contains(" ");

        int indexOfAtSign = emailTrimed.LastIndexOf('@');

        if (indexOfAtSign > 0 && !hasWhitespace)
        {
            string afterAtSign = emailTrimed.Substring(indexOfAtSign + 1);

            int indexOfDotAfterAtSign = afterAtSign.LastIndexOf('.');

            if (indexOfDotAfterAtSign > 0 && afterAtSign.Substring(indexOfDotAfterAtSign).Length > 1)
                return true;
        }
    }

    return false;
}

Ejemplos:

• IsValidEmail("@b.com") // false
• IsValidEmail("a@.com") // false
• IsValidEmail("a@bcom") // false
• IsValidEmail("a.b@com") // false
• IsValidEmail("a@b.") // false
• IsValidEmail("a b@c.com") // false
• IsValidEmail("a@b c.com") // false
• IsValidEmail("a@b.com") // true
• IsValidEmail("a@b.c.com") // true
• IsValidEmail("a+b@c.com") // true
• IsValidEmail("a@123.45.67.89") // true

Se pretende que sea simple y, por lo tanto, no trata casos raros como correos electrónicos con dominios entre corchetes que contienen espacios (generalmente permitidos), correos electrónicos con direcciones IPv6, etc.

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

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;

   }

}

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

1. Coloque el "Componente de secuencia de comandos" 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 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.