C # code pour valider l'adresse e-mail

StackOverflow https://stackoverflow.com/questions/1365407

  •  21-09-2019
  •  | 
  •  

Question

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

Était-ce utile?

La solution

Qu'en est-ce? 

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

Pour clarifier, la question se pose de savoir si une chaîne particulière est une représentation valide d'une adresse e-mail, pas si une adresse e-mail est une destination valide pour envoyer un message. Pour cela, la seule façon est d'envoyer un message pour confirmer.

Notez que les adresses e-mail sont plus indulgents que vous pourriez d'abord supposer. Ce sont toutes les formes parfaitement valides:

  • roue dentée de @
  • "Cogwheel orange" @ example.com
  • 123 @ $. Xyz

Pour la plupart des cas d'utilisation, un faux « invalide » est bien pire pour vos utilisateurs et Évolutivité qu'un faux « valide ». Voici un

Autres conseils

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

Cela semble fonctionner, et me semble être assez élégante: 

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 unique de ligne qui fait le travail pour moi - 

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

Par les commentaires, cela « échec » si le source (l'adresse e-mail) est nulle. 

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

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

Vous pouvez parcourir la source de la 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])))\.?$";

Je pris la réponse de Phil de # 1 et a créé cette classe. Appelez 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;
    }
}

Pour ma part, je dirais que vous devriez juste vous assurer qu'il est un symbole @ là-dedans, avec peut-être un. personnage. Il y a beaucoup de regexes vous pouvez utiliser des variables correct, mais je pense que la plupart de ces quittent les adresses e-mail valides, ou laissez-les invalides par. Si les gens veulent mettre dans une adresse e-mail faux, ils vont mettre dans un faux. Si vous devez vérifier que l'adresse e-mail est légitime, et que la personne est dans le contrôle de cette adresse e-mail, vous devrez les envoyer un e-mail avec un lien spécial codé afin qu'ils puissent vérifier qu'il est en effet une adresse réelle.

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.

La façon la plus élégante est d'utiliser .Net construit dans les méthodes.

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, qui sont fiables et rapides.

  • Fait par Microsoft pour C #. Il n'y a pas besoin de réinventer la roue.

  • Retourne un résultat bool. True signifie que l'e-mail est valide.

Pour les utilisateurs de .Net 4.5 et plus

Ajoutez cette référence à votre projet:

  

System.ComponentModel.DataAnnotations

vous pouvez 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 le code en faire la démonstration 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:

  • va au-delà de la spécification depuis une seule chaîne est utilisée pour contenir 0, une ou plusieurs adresses e-mail sperated par un point-virgule ;.
  • démontre clairement comment utiliser la méthode IsValid de l'objet EmailAddressAttribute.

Alternative, pour les utilisateurs d'une version de .Net moins de 4,5

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

Plus précisément, je l'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;

}

Code court et précis 

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

Pour être honnête, dans le code de production, le meilleur que je fais est pour vérifier un symbole @.

Je ne suis jamais dans un endroit pour être complètement des e-mails de validation. Tu sais comment je vois si elle était vraiment valable? Si elle fut expulsé. Si elle ne l'a pas, il est mauvais, si elle a fait, la vie est bonne. C'est tout ce que je dois savoir.

Je trouve cela regex être un bon compromis entre la vérification de quelque chose de plus que la marque @, et en acceptant cas de pointe étranges: 

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

Il faire au moins vous mettez quelque chose autour de la marque @, et de mettre au moins un domaine à la recherche normale.

validation d'adresse e-mail est pas aussi facile que cela puisse paraître. Il est en fait théoriquement impossible de valider complètement une adresse e-mail en utilisant seulement une expression régulière.

Regarde mes à ce sujet pour une discussion sur le sujet et une mise en œuvre F # en utilisant FParsec. [/ Shameless_plug]

Voici ma réponse - la solution de Phil échoue pour les domaines une seule lettre comme « someone@q.com ». Croyez-le ou non, qui est utilisé =) (va à CenturyLink, par exemple).

La réponse de Phil va aussi travailler uniquement avec la norme PCRE ... donc C # prendra, mais javascript va à la bombe. Il est trop complexe pour javascript. Donc, vous ne pouvez pas utiliser la solution de Phil pour les attributs de validation mvc.

Voici mon regex. Il va travailler bien avec les attributs de validation MVC.
- Tout avant le signe @ est simplifiée, de sorte qu'au moins javascript fonctionnera. Je suis d'accord validation reposant ici tant que serveur d'échange ne me donne pas un 5.1.3. -. Tout après le @ est la solution de Phil modifiée pour les domaines une seule lettre 

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 utilisant System.Net.Mail suggérant MailMessage (), cette chose est une façon de flexibilité. Bien sûr, C # acceptera l'e-mail, mais le serveur d'échange bombardera avec 5.1.3 erreur d'exécution dès que vous essayez d'envoyer l'e-mail.

Si vous avez vraiment et je veux dire vraiment savoir si une adresse e-mail est valide ... demander à l'échangeur de courrier pour le prouver, pas regex nécessaire. Je peux fournir le code à la demande.

Les étapes générales sont les suivantes: 1. L'adresse e-mail ont une partie du nom de domaine? (Indice de @> 0) 2. À l'aide d'une requête DNS demande si domaine a un échangeur mail 3. connexion tcp ouvert à l'échangeur mail 4. en utilisant le protocole smtp, ouvrez un message au serveur en utilisant l'adresse e-mail comme recepteur 5. analyser la réponse du serveur. 6. Quittez le message si vous l'avez fait jusque-là, tout est bon.

Ceci est comme vous pouvez l'imaginer, le temps très coûteux sage et repose sur smtp, mais il 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 où nous écrivons ces lignes, la syntaxe d'une adresse e-mail doit suivre un nombre relativement élevé de normes et mettre en œuvre tous dans une expression régulière est pratiquement impossible!

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

Disclaimer: Je suis le développeur principal de cette composante

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

Il y a beaucoup de réponses fortes ici. Cependant, je recommande que nous prenons un pas en arrière. @Cogwheel répond à la question https://stackoverflow.com/a/1374644/388267 . Néanmoins, il pourrait être coûteux dans un scénario de validation en vrac, si beaucoup de l'adresse e-mail en cours de validation ne sont pas valides. Je suggère que nous employons un peu de logique avant d'entrer dans son bloc try-catch. Je sais que le code suivant peut être écrit en utilisant RegEx mais cela pourrait être coûteux pour les nouveaux développeurs à comprendre. Ceci est ma valeur de twopence: 

    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é est de @Cogwheel meilleure réponse mais j'ai essayé de mettre en œuvre la méthode de chaîne de trim() il coupera tous les espaces de l'utilisateur de la chaîne début à la fin. Vérifiez le code ci-dessous par 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);
}

string Vérifiez e-mail est format ou format incorrect par 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 du Regex interne utilisé dans la création de la "nouvelle EmailAddressAttribute ();" composant en utilisant .Net4.5 >>> 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

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

J'ai écrit une fonction pour vérifier si un email est valide ou non. Il semble bien fonctionner pour moi dans la plupart des cas.

Résultats: 

dasddas-@.com => FALSE
-asd@das.com => FALSE
as3d@dac.coas- => FALSE
dsq!a?@das.com => FALSE
_dasd@sd.com => FALSE
dad@sds => FALSE
asd-@asd.com => FALSE
dasd_-@jdas.com => FALSE
asd@dasd@asd.cm => FALSE
da23@das..com => FALSE
_dasd_das_@9.com => FALSE

d23d@da9.co9 => TRUE
dasd.dadas@dasd.com => TRUE
dda_das@das-dasd.com => TRUE
dasd-dasd@das.com.das => TRUE

Code: 

    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(@"^[a-zA-Z0-9_@.-]*$");
        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;
    }

Une façon simple d'identifier l'identifiant email 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 regex en C # plutôt que js. Nous devons donc utiliser regex en mode US pour l'enregistrement électronique. Si vous n'utilisez pas le mode ECMAScript, votre langue sont des caractères spéciaux impliquent dans A-Z 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)

Je fini par utiliser cette expression régulière, car il valide avec succès des virgules, des commentaires, des caractères Unicode et adresses de domaine IP (v4).

Les adresses valides sont les suivants:

  

» « @ example.org

     

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

Voici une réponse à votre question pour vous de 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;

   }

}

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

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;

Selon la réponse de @Cogwheel je veux partager une solution modifiée qui fonctionne pour SSIS et le « Component Script »:

  1. Placez le « composant Script » dans votre flux de données se connecter et puis ouvrez-le.
  2. Dans la section définir le champ "Colonnes d'entrée" qui contient l'E-Mail Adresses à "ReadWrite" (dans l'exemple 'fieldName').
  3. Revenez à la section « Script » et cliquez sur « Modifier le script ». Ensuite, vous devez attendre après le code ouvre.

  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.

une petite modification à @Cogwheel réponse 

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;
  }
}
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top