email validate - Code C#pour valider l'adresse e-mail




address regex (25)

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


Answers

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

Je ne suis jamais dans un endroit pour valider complètement les emails. Vous savez comment je vois si c'était vraiment valable? Si ça a été envoyé. Si ce n'est pas le cas, c'est mauvais, si c'est le cas, la vie est belle. C'est tout ce que j'ai besoin de savoir.


/ Utilisation de la regex interne utilisée dans la création de "new EmailAddressAttribute ();" composant dans .Net4.5 >>> using System.ComponentModel.DataAnnotations; // Pour valider une adresse e-mail ...... Testée et fonctionnelle.

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

En outre, vous pouvez utiliser ceci:

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


Je trouve que cette regex est un bon compromis entre vérifier quelque chose de plus que la marque @, et accepter des cas bizarres:

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

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


  1. In a "try block" send a verification email.
  2. Make the user open the email and click a link verifying the email is real.

Until this process completes successfully, the email is assumed to be invalid.


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

Code court et précis

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

J'utilise cette méthode de recouvrement unique qui fait le travail pour moi ...

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

Si vous voulez vraiment et vraiment savoir si une adresse e-mail est valide ... demandez à l'échangeur de mail de le prouver, aucune regex nécessaire. Je peux fournir le code si demandé.

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. en utilisant une requête DNS demander si le domaine a un échangeur de courrier 3. ouvrir la connexion tcp à l'échangeur 4. en utilisant le protocole smtp, ouvrir un message au serveur en utilisant l'adresse email comme destinataire 5. analyser la réponse du serveur. 6. quittez le message si vous l'avez fait jusqu'ici, tout va bien.

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


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

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

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


J'ai succincifié 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);
}

In case you are using FluentValidation you could write something as simple as this:

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;

La manière la plus élégante consiste à 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.

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

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

Pour les utilisateurs de .Net 4.5 et supérieur

Ajouter cette référence à votre projet:

System.ComponentModel.DataAnnotations

Vous pouvez maintenant utiliser le code suivant:

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

Exemple d'utilisation

Voici quelques méthodes à 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 du 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());

}

En outre, 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 e-mail spéeré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;

}

Voici ma réponse - La solution de Phil échoue pour les domaines à une lettre comme "[email protected]". Croyez-le ou non, c'est utilisé =) (va à centurylink, par exemple).

La réponse de Phil va aussi fonctionner uniquement avec la norme PCRE ... donc C # va le prendre, 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 bien avec les attributs de validation MVC.
- Tout ce qui précède le @ est simplifié, de sorte qu'au moins javascript fonctionnera. Je suis d'accord relaxant la validation ici tant que le 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 suggérant l'utilisation de system.net.mail MailMessage (), cette façon est flexible. Bien sûr, C # acceptera l'email, mais alors le serveur d'échange bombardera avec l'erreur d'exécution 5.1.3 dès que vous essayerez d'envoyer l'email.


Personnellement, je dirais que vous devriez juste vous assurer qu'il y a un symbole @, avec éventuellement un. personnage. Il y a beaucoup d'expressions rationnelles que vous pouvez 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 vont mettre dans un faux. 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'il puisse vérifier qu'il s'agit bien d'une véritable adresse.


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

Jetez un coup d'œil sur mon blog pour une discussion sur le sujet et une implémentation F # en utilisant FParsec. [/ shameless_plug]


A simple one without using Regex (which I don't like for its poor readability):

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:

It is meant to be simple and therefore it doesn't deal with rare cases like emails with bracketed domains that contain spaces (typically allowed), emails with IPv6 addresses, etc.


I ended up using this regex, as it successfully validates commas, comments, Unicode characters and IP(v4) domain addresses.

Valid addresses will be:

" "@example.org

(comment)[email protected]

тест@example.org

ტესტი@example.org

[email protected][192.168.1.1]

 public const string REGEX_EMAIL = @"^(((\([\w!#$%&'*+\/=?^_`{|}~-]*\))?[^<>()[\]\\.,;:\[email protected]\""]+(\.[^<>()[\]\\.,;:\[email protected]\""]+)*)|(\"".+\""))(\([\w!#$%&'*+\/=?^_`{|}~-]*\))[email protected]((\[[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,}))$";

Vérifiez la chaîne d'email est le bon format ou le mauvais format 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";
        }
    }

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

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 email à 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("[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("[email protected]");                         //false
        bar = foo.IsValid("[email protected]");                     //false
        bar = foo.IsValid("[email protected]");                    //false

        //one-liner
        if (new EmailAddressAttribute().IsValid("[email protected]"))
            bar = true;    
    }
}

Un moyen simple d'identifier l'emailid 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})(\]?)$");
}

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

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

De 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 email doit suivre un nombre relativement élevé de standards et la mise en œuvre de tous dans une expression régulière est pratiquement irréalisable!

Je vous suggère fortement d'essayer notre EmailVerify.NET , une bibliothèque mature .NET qui peut valider les adresses email suivant toutes 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 les messages et peut même dire si une adresse donnée est jetable ou non.

Disclaimer: Je suis le développeur principal pour ce composant.


chaîne est un mot clé et vous ne pouvez pas utiliser chaîne comme identifiant.

String n'est pas un mot clé et vous pouvez l'utiliser comme identifiant:

Exemple

string String = "I am a string";

Le mot clé stringest un alias car, System.Stringmis à part le mot clé problème, les deux sont exactement équivalents.

 typeof(string) == typeof(String) == typeof(System.String)






c# email email-validation