Code C # pour valider l'adresse e-mail

Quel est le code le plus élégant pour valider qu'une chaîne est une adresse e-mail valide?

Et ça?

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

Pour clarifier, la question demande si une chaîne particulière est une représentation valide d'une adresse de messagerie, et non si une adresse de messagerie est une destination valide pour envoyer un message. Pour cela, le seul vrai moyen est d'envoyer un message pour confirmer.

Notez que les adresses e-mail sont plus indulgentes que vous ne le pensez. Ce sont tous des formulaires parfaitement valables:

• roue dentée
• "roue dentée l'orange" @ example.com
• 123@$.xyz

Pour la plupart des cas d'utilisation, un faux "invalide" est bien pire pour vos utilisateurs et l'épreuve du temps qu'un faux "valide". Voici un article qui était la réponse acceptée à cette question (cette réponse a depuis été supprimée). Il contient beaucoup plus de détails et quelques autres idées sur la façon de résoudre le problème.

Fournir des contrôles d'intégrité est toujours une bonne idée pour l'expérience utilisateur. En supposant que l'adresse e-mail est valide, vous pouvez rechercher des domaines de premier niveau connus, rechercher un enregistrement MX dans le domaine, rechercher des erreurs d'orthographe à partir de noms de domaine communs (gmail.cmo), etc. Ensuite, présenter un avertissement donnant à l'utilisateur une chance de dire "oui, mon serveur de messagerie autorise vraiment 🌮🍳🎁 comme adresse e-mail."

Quant à l'utilisation de la gestion des exceptions pour la logique métier, je suis d'accord que c'est une chose à éviter. Mais c'est l'un de ces cas où la commodité et la clarté peuvent l'emporter sur le dogme.

De plus, si vous faites autre chose avec l'adresse e-mail, cela impliquera probablement de la transformer en MailAddress. Même si vous n'utilisez pas cette fonction exacte, vous voudrez probablement utiliser le même modèle. Vous pouvez également rechercher des types d'échecs spécifiques en interceptant différentes exceptions : format nul, vide ou non valide.

Selon le commentaire de Stuart, cela compare l'adresse finale avec la chaîne d'origine au lieu de toujours retourner true. MailAddress essaie d'analyser une chaîne avec des espaces dans les parties "Nom d'affichage" et "Adresse", de sorte que la version d'origine renvoyait des faux positifs.

--- Lectures complémentaires ---

Documentation pour System.Net.Mail.MailAddress

Explication de ce qui constitue une adresse e-mail valide

C'est une vieille question, mais toutes les réponses que j'ai trouvées sur SO, y compris les plus récentes, reçoivent une réponse similaire à celle-ci. Cependant, dans .Net 4.5 / MVC 4, vous pouvez ajouter une validation d'adresse e-mail à un formulaire en ajoutant l'annotation [EmailAddress] de System.ComponentModel.DataAnnotations, donc je me demandais pourquoi je ne pouvais pas simplement utiliser la fonctionnalité intégrée de. Net en général.

Cela semble fonctionner et me semble assez élégant:

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

J'utilise cette méthode de doublure unique qui fait le travail pour moi-

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

D'après les commentaires, cela "échouera" si source(l'adresse e-mail) est nulle.

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

.net 4.5 a ajouté System.ComponentModel.DataAnnotations.EmailAddressAttribute

Vous pouvez parcourir la source de EmailAddressAttribute , c'est le Regex qu'il utilise en interne:

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])))\.?$";

J'ai pris la réponse de Phil de # 1 et créé cette classe. Appelez ça comme ceci:bool isValid = Validator.EmailIsValid(emailString);

Voici la classe:

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

Personnellement, je dirais que vous devez simplement vous assurer qu'il y a un symbole @, éventuellement avec un. personnage. Il existe de nombreuses expressions rationnelles que vous pourriez utiliser avec une exactitude variable, mais je pense que la plupart d'entre elles omettent des adresses e-mail valides ou laissent passer des adresses invalides. Si les gens veulent mettre une fausse adresse e-mail, ils en mettront une fausse. Si vous devez vérifier que l'adresse e-mail est légitime et que la personne contrôle cette adresse e-mail, vous devrez lui envoyer un e-mail avec un lien codé spécial afin qu'elle puisse vérifier qu'il s'agit bien d'une véritable adresse.

Je pense que la meilleure façon est la suivante:

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

Vous pouvez avoir cette fonction statique dans une classe générale.

Code court et précis

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 manière la plus élégante est d'utiliser les méthodes intégrées de .Net.

Ces méthodes:

• Sont essayés et testés. Ces méthodes sont utilisées dans mes propres projets professionnels.

• Utilisez des expressions régulières en interne, fiables et rapides.

• Fabriqué par Microsoft pour C #. Inutile de réinventer la roue.

• Renvoie un résultat booléen. Vrai signifie que l'e-mail est valide.

Pour les utilisateurs de .Net 4.5 et supérieur

Ajoutez cette référence à votre projet:

System.ComponentModel.DataAnnotations

Vous pouvez maintenant utiliser le code suivant:

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

Exemple d'utilisation

Voici quelques méthodes pour déclarer:

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;

}

... et un code les démontrant en action:

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

}

De plus, cet exemple:

• S'étend au-delà de la spécification, car une seule chaîne est utilisée pour contenir 0, une ou plusieurs adresses électroniques séparées par un point-virgule ; .
• Montre clairement comment utiliser la méthode IsValid de l'objet EmailAddressAttribute.

Alternative, pour les utilisateurs d'une version de .Net inférieure à 4,5

Pour les situations où .Net 4.5 n'est pas disponible, j'utilise la solution suivante:

Plus précisément, j'utilise:

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;

}

Pour être honnête, dans le code de production, le mieux que je fais est de rechercher un @symbole.

Je ne suis jamais en mesure de valider complètement les e-mails. Vous savez comment je vois si c'était vraiment valable? Si elle a été envoyée. Si ce n'est pas le cas, c'est mauvais, si c'est le cas, la vie est belle. C'est tout ce que je dois savoir.

Je trouve que cette expression régulière est un bon compromis entre la vérification de quelque chose de plus que la simple marque @ et l'acceptation de cas étranges:

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

Cela vous fera au moins mettre quelque chose autour de la marque @ et mettre au moins un domaine d'apparence normale.

La validation des adresses e-mail n'est pas aussi simple que cela puisse paraître. Il est en fait théoriquement impossible de valider complètement une adresse e-mail en utilisant simplement une expression régulière.

Consultez mon blog à ce sujet pour une discussion sur le sujet et une implémentation F # à l'aide de FParsec. [/ shameless_plug]

Voici ma réponse - la solution de Phil échoue pour les domaines à lettre unique comme "quelqu'un@q.com". Croyez-le ou non, c'est utilisé =) (va à centurylink, par exemple).

La réponse de Phil ne fonctionnera également qu'avec la norme PCRE ... donc C # le prendra, mais javascript va exploser. C'est trop complexe pour javascript. Vous ne pouvez donc pas utiliser la solution de Phil pour les attributs de validation mvc.

Voici mon regex. Cela fonctionnera parfaitement avec les attributs de validation MVC.
- Tout avant le @ est simplifié, de sorte qu'au moins javascript fonctionne. Je suis d'accord pour relaxer la validation ici tant que le serveur d'échange ne me donne pas de 5.1.3. - Tout après la @ est la solution de Phil modifiée pour les domaines à lettre unique.

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]$";

Pour les personnes suggérant d'utiliser system.net.mail MailMessage (), cette chose est FAIBLE à flexible. Bien sûr, C # acceptera l'e-mail, mais le serveur d'échange bombardera avec une erreur d'exécution 5.1.3 dès que vous essayez d'envoyer l'e-mail.

Si vous voulez vraiment et je veux vraiment savoir si une adresse e-mail est valide ... demandez à l'échangeur de courrier de le prouver, aucune expression régulière n'est nécessaire. Je peux fournir le code sur demande.

Les étapes générales sont les suivantes: 1. l'adresse e-mail comporte-t-elle une partie de nom de domaine? (index de @> 0) 2. à l'aide d'une requête DNS, demandez si le domaine dispose d'un échangeur de messagerie 3. ouvrez la connexion TCP à l'échangeur de messagerie 4. à l'aide du protocole smtp, ouvrez un message au serveur en utilisant l'adresse e-mail comme récepteur 5. analyser la réponse du serveur. 6. quittez le message si vous êtes arrivé jusqu'ici, tout va bien.

C'est comme vous pouvez l'imaginer, très coûteux en temps et repose sur smtp, mais cela fonctionne.

D'une manière générale, une expression régulière pour valider les adresses e-mail n'est pas une chose facile à trouver; au moment d'écrire ces lignes, la syntaxe d'une adresse e-mail doit suivre un nombre relativement élevé de normes et leur mise en œuvre au sein d'une expression régulière est pratiquement impossible!

Je vous suggère fortement d'essayer notre EmailVerify.NET , une bibliothèque .NET mature qui peut valider les adresses e-mail après tout les normes IETF actuelles (RFC 1123, RFC 2821, RFC 2822, RFC 3696, RFC 4291, RFC 5321 et RFC 5322) , teste les enregistrements DNS associés, vérifie si les boîtes aux lettres cibles peuvent accepter des messages et peuvent même dire si une adresse donnée est jetable ou non.

Avertissement: je suis le développeur principal de ce composant.

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

Si vous utilisez FluentValidation, vous pouvez écrire quelque chose d'aussi simple que ceci:

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;

une petite modification de la réponse @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;
  }
}

Il y a beaucoup de réponses solides ici. Cependant, je recommande que nous prenions du recul. @Cogwheel répond à la question https://stackoverflow.com/a/1374644/388267 . Néanmoins, cela pourrait être coûteux dans un scénario de validation en masse, si une grande partie de l'adresse e-mail en cours de validation n'est pas valide. Je suggère que nous employions un peu de logique avant d'entrer dans son bloc try-catch. Je sais que le code suivant pourrait être écrit à l'aide de RegEx mais cela pourrait être coûteux à comprendre pour les nouveaux développeurs. C'est ma valeur de deux cents:

    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 réponse la plus votée de @Cogwheel est la meilleure réponse, mais j'ai essayé d'implémenter trim()une méthode de chaîne afin de réduire tous les espaces blancs de l'utilisateur du début à la fin de la chaîne. Vérifiez le code ci-dessous pour un exemple complet-

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

Vérifiez que la chaîne de courrier électronique est au bon format ou au mauvais format en 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";
        }
    }

/ Utilisation de la regex interne utilisée pour créer le "nouveau EmailAddressAttribute ();" composant dans .Net4.5 >>> using System.ComponentModel.DataAnnotations; // Pour valider une adresse e-mail ...... testé et fonctionnel.

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

Vous pouvez également utiliser ceci:

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

J'ai succincté la réponse de Poyson 1 comme ceci:

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

Un moyen simple d'identifier l'e-mail est valide ou non.

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

Il y a un problème de culture dans l'expression régulière en C # plutôt qu'en js. Nous devons donc utiliser l'expression régulière en mode américain pour la vérification des e-mails. Si vous n'utilisez pas le mode ECMAScript, les caractères spéciaux de votre langue sont implicites en AZ avec 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)

J'ai fini par utiliser cette expression régulière, car elle valide avec succès les virgules, les commentaires, les caractères Unicode et les adresses de domaine IP (v4).

Les adresses valides seront:

"" @ example.org

(comment)test@example.org

тест@example.org

ტესტი @ example.org

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

Un simple sans utiliser Regex (que je n'aime pas pour sa mauvaise lisibilité):

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

Exemples:

• 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

Il est censé être simple et ne traite donc pas de rares cas comme les e-mails avec des domaines entre crochets qui contiennent des espaces (généralement autorisés), les e-mails avec des adresses IPv6, etc.

Voici une réponse à votre question à vérifier.

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;

   }

}

Sur la base de la réponse de @Cogwheel, je souhaite partager une solution modifiée qui fonctionne pour SSIS et le "composant de script":

1. Placez le «composant de script» dans votre connexion de flux de données, puis ouvrez-le.
2. Dans la section "Colonnes d'entrée", définissez le champ qui contient les adresses e-mail sur "ReadWrite" (dans l'exemple 'fieldName').
3. Revenez à la section "Script" et cliquez sur "Modifier le script". Ensuite, vous devez attendre l'ouverture du code.

4. Placez ce code dans la bonne méthode:

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

Ensuite, vous pouvez utiliser un fractionnement conditionnel pour filtrer tous les enregistrements non valides ou tout ce que vous voulez faire.