validate - regex email c#




Code C#pour valider l'adresse e-mail (20)

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


  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.


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

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.


Il y a un problème de culture dans regex en C # plutôt que js. So we need to use regex in US mode for email check. If you don't use ECMAScript mode, your language special characters are imply in AZ with 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 écrit une fonction pour vérifier si un email est valide ou non. Cela semble fonctionner bien pour moi dans la plupart des cas.

Résultats:

[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected]@asd.cm => FALSE
[email protected] => FALSE
[email protected] => FALSE

[email protected] => TRUE
[email protected] => TRUE
[email protected] => TRUE
[email protected] => 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(@"^[[email protected]]*$");
        valid = valid_checker.IsMatch(email);
        if (valid == false)
        {
            goto End_Func;
        }

        List<int> pos_list = new List<int> { };
        int pos = 0;
        while (email.IndexOf('_', pos) != -1)
        {
            pos_list.Add(email.IndexOf('_', pos));
            pos = email.IndexOf('_', pos) + 1;
        }

        pos = 0;
        while (email.IndexOf('.', pos) != -1)
        {
            pos_list.Add(email.IndexOf('.', pos));
            pos = email.IndexOf('.', pos) + 1;
        }

        pos = 0;
        while (email.IndexOf('-', pos) != -1)
        {
            pos_list.Add(email.IndexOf('-', pos));
            pos = email.IndexOf('-', pos) + 1;
        }

        int sp_cnt = pos_list.Count();
        pos_list.Sort();
        for (int i = 0; i < sp_cnt - 1; i++)
        {
            if (pos_list[i] + 1 == pos_list[i + 1])
            {
                valid = false;
                break;
            }

            if (pos_list[i]+1 == pos_at || pos_list[i]+1 == pos_dot)
            {
                valid = false;
                break;
            }
        }

        if(valid == false)
        {
            goto End_Func;
        }

        if (pos_list[sp_cnt - 1] == email.Length - 1 || pos_list[0] == 0)
        {
            valid = false;
        }

    End_Func:;
        return valid;
    }

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

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

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.


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;

}

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.


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.


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

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

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;

   }

}

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

I created an email address validation routine based on Wikipedia's documented rules and sample addresses. For those that don't mind looking at a little more code, here you go. Honestly, I had no idea how many crazy rules there were in the email address specification. I don't fully validate the hostname or ipaddress, but it still passes all of the test cases on wikipedia.

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace EmailValidateUnitTests
{
    [TestClass]
    public class EmailValidationUnitTests
    {
        [TestMethod]
        public void TestEmailValidate()
        {
            // Positive Assertions
            Assert.IsTrue("[email protected]".IsValidEmailAddress());
            Assert.IsTrue("[email protected]".IsValidEmailAddress());
            Assert.IsTrue("[email protected]".IsValidEmailAddress());
            Assert.IsTrue("[email protected]".IsValidEmailAddress());
            Assert.IsTrue("\"much.more unusual\"@example.com".IsValidEmailAddress());
            Assert.IsTrue("\"[email protected]\"@example.com".IsValidEmailAddress()); //"[email protected]"@example.com
            Assert.IsTrue("\"very.(),:;<>[]\\\".VERY.\\\"[email protected]\\\\ \\\"very\\\".unusual\"@strange.example.com".IsValidEmailAddress()); //"very.(),:;<>[]\".VERY.\"[email protected]\\ \"very\".unusual"@strange.example.com
            Assert.IsTrue("[email protected]".IsValidEmailAddress());
            Assert.IsTrue("#!$%&'*+-/=?^_`{}|[email protected]".IsValidEmailAddress());
            Assert.IsTrue("\"()<>[]:,;@\\\\\\\"!#$%&'*+-/=?^_`{}| ~.a\"@example.org".IsValidEmailAddress()); //"()<>[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.a"@example.org
            Assert.IsTrue("\" \"@example.org".IsValidEmailAddress()); //" "@example.org (space between the quotes)
            Assert.IsTrue("[email protected]".IsValidEmailAddress());
            Assert.IsTrue("[email protected]".IsValidEmailAddress());
            Assert.IsTrue("[email protected]".IsValidEmailAddress());
            Assert.IsTrue("[email protected]".IsValidEmailAddress());
            Assert.IsTrue("[email protected][IPv6:2001:db8::1]".IsValidEmailAddress());
            Assert.IsTrue("[email protected][192.168.2.1]".IsValidEmailAddress());
            Assert.IsTrue("(comment and stuff)[email protected]".IsValidEmailAddress());
            Assert.IsTrue("joe(comment and stuff)@gmail.com".IsValidEmailAddress());
            Assert.IsTrue("[email protected](comment and stuff)gmail.com".IsValidEmailAddress());
            Assert.IsTrue("[email protected](comment and stuff)".IsValidEmailAddress());

            // Failure Assertions
            Assert.IsFalse("joe(fail me)[email protected]".IsValidEmailAddress());
            Assert.IsFalse("[email protected](fail me)il.com".IsValidEmailAddress());
            Assert.IsFalse("[email protected](comment and stuff".IsValidEmailAddress());
            Assert.IsFalse("Abc.example.com".IsValidEmailAddress());
            Assert.IsFalse("[email protected]@[email protected]".IsValidEmailAddress());
            Assert.IsFalse("a\"b(c)d,e:f;g<h>i[j\\k][email protected]".IsValidEmailAddress()); //a"b(c)d,e:f;g<h>i[j\k][email protected]
            Assert.IsFalse("just\"not\"[email protected]".IsValidEmailAddress()); //just"not"[email protected]
            Assert.IsFalse("this is\"not\\[email protected]".IsValidEmailAddress()); //this is"not\[email protected]
            Assert.IsFalse("this\\ still\\\"not\\\\[email protected]".IsValidEmailAddress());//this\ still\"not\\[email protected]
            Assert.IsFalse("[email protected]".IsValidEmailAddress());
            Assert.IsFalse("[email protected]".IsValidEmailAddress());
            Assert.IsFalse(" [email protected]".IsValidEmailAddress());
            Assert.IsFalse("[email protected] ".IsValidEmailAddress());
        }
    }

    public static class ExtensionMethods
    {
        private const string ValidLocalPartChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'*+-/=?^_`{|}~";
        private const string ValidQuotedLocalPartChars = "(),:;<>@[]. ";
        private const string ValidDomainPartChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-:";

        private enum EmailParseMode
        {
            BeginLocal, Local, QuotedLocalEscape, QuotedLocal, QuotedLocalEnd, LocalSplit, LocalComment,
            At,
            Domain, DomainSplit, DomainComment, BracketedDomain, BracketedDomainEnd
        };

        public static bool IsValidEmailAddress(this string s)
        {
            bool valid = true;

            bool hasLocal = false, hasDomain = false;
            int commentStart = -1, commentEnd = -1;
            var mode = EmailParseMode.BeginLocal;
            for (int i = 0; i < s.Length; i++)
            {
                char c = s[i];
                if (mode == EmailParseMode.BeginLocal || mode == EmailParseMode.LocalSplit)
                {
                    if (c == '(') { mode = EmailParseMode.LocalComment; commentStart = i; commentEnd = -1; }
                    else if (c == '"') { mode = EmailParseMode.QuotedLocal; }
                    else if (ValidLocalPartChars.IndexOf(c) >= 0) { mode = EmailParseMode.Local; hasLocal = true; }
                    else { valid = false; break; }
                }
                else if (mode == EmailParseMode.LocalComment)
                {
                    if (c == ')')
                    {
                        mode = EmailParseMode.Local; commentEnd = i;
                        // comments can only be at beginning and end of parts...
                        if (commentStart != 0 && ((commentEnd + 1) < s.Length) && s[commentEnd + 1] != '@') { valid = false; break; }
                    }
                }
                else if (mode == EmailParseMode.Local)
                {
                    if (c == '.') mode = EmailParseMode.LocalSplit;
                    else if (c == '@') mode = EmailParseMode.At;
                    else if (c == '(') { mode = EmailParseMode.LocalComment; commentStart = i; commentEnd = -1; }
                    else if (ValidLocalPartChars.IndexOf(c) >= 0) { hasLocal = true; }
                    else { valid = false; break; }
                }
                else if (mode == EmailParseMode.QuotedLocal)
                {
                    if (c == '"') { mode = EmailParseMode.QuotedLocalEnd; }
                    else if (c == '\\') { mode = EmailParseMode.QuotedLocalEscape; }
                    else if (ValidLocalPartChars.IndexOf(c) >= 0 || ValidQuotedLocalPartChars.IndexOf(c) >= 0) { hasLocal = true; }
                    else { valid = false; break; }
                }
                else if (mode == EmailParseMode.QuotedLocalEscape)
                {
                    if (c == '"' || c == '\\') { mode = EmailParseMode.QuotedLocal; hasLocal = true; }
                    else { valid = false; break; }
                }
                else if (mode == EmailParseMode.QuotedLocalEnd)
                {
                    if (c == '.') { mode = EmailParseMode.LocalSplit; }
                    else if (c == '@') mode = EmailParseMode.At;
                    else if (c == '(') { mode = EmailParseMode.LocalComment; commentStart = i; commentEnd = -1; }
                    else { valid = false; break; }
                }
                else if (mode == EmailParseMode.At)
                {
                    if (c == '[') { mode = EmailParseMode.BracketedDomain; }
                    else if (c == '(') { mode = EmailParseMode.DomainComment; commentStart = i; commentEnd = -1; }
                    else if (ValidDomainPartChars.IndexOf(c) >= 0) { mode = EmailParseMode.Domain; hasDomain = true; }
                    else { valid = false; break; }
                }
                else if (mode == EmailParseMode.DomainComment)
                {
                    if (c == ')')
                    {
                        mode = EmailParseMode.Domain;
                        commentEnd = i;
                        // comments can only be at beginning and end of parts...
                        if ((commentEnd + 1) != s.Length && (commentStart > 0) && s[commentStart - 1] != '@') { valid = false; break; }
                    }
                }
                else if (mode == EmailParseMode.DomainSplit)
                {
                    if (ValidDomainPartChars.IndexOf(c) >= 0) { mode = EmailParseMode.Domain; hasDomain = true; }
                    else { valid = false; break; }
                }
                else if (mode == EmailParseMode.Domain)
                {
                    if (c == '(') { mode = EmailParseMode.DomainComment; commentStart = i; commentEnd = -1; }
                    else if (c == '.') { mode = EmailParseMode.DomainSplit; }
                    else if (ValidDomainPartChars.IndexOf(c) >= 0) { hasDomain = true; }
                    else { valid = false; break; }
                }
                else if (mode == EmailParseMode.BracketedDomain)
                {
                    if (c == ']') { mode = EmailParseMode.BracketedDomainEnd; }
                    else if (c == '.' || ValidDomainPartChars.IndexOf(c) >= 0) { hasDomain = true; }
                    else { valid = false; break; }
                }
                else if (mode == EmailParseMode.BracketedDomain)
                {
                    if (c == '(') { mode = EmailParseMode.DomainComment; commentStart = i; commentEnd = -1; }
                    else { valid = false; break; }
                }
            }
            bool unfinishedComment = (commentEnd == -1 && commentStart >= 0);

            return hasLocal && hasDomain && valid && !unfinishedComment;
        }
    }
}

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

Some time back, I wrote an EmailAddressValidationAttribute that should properly validate pretty much any relatively normal email address of the form

[email protected]

It's a System.ComponentModel.DataAnnotations.ValidationAttribute , so usage is really simple.

And, since digging through all the RFCs and errata and assembling all the bits required to properly enumerate all the rules is...tedious — at best! — I posted the source code for the validator in my answer to the question C# Email Address validation for the source code.

My validator isn't perfect by any stretch of the imagination, though Just for starters, it doesn't have any built-in support for emitting client-side javascript validation, though it wouldn't be too difficult to add that in. From my answer above:

Here's the validation attribute I wrote. It validates pretty much every "raw" email address, that is those of the form [email protected] . It doesn't support any of the other, more...creative constructs that the RFCs allow (this list is not comprehensive by any means):

  • comments (eg, [email protected] (work) )
  • quoted strings (escaped text, to allow characters not allowed in an atom)
  • domain literals (eg [email protected][123.45.67.012] )
  • bang-paths (aka source routing)
  • angle addresses (eg John Smith <[email protected]> )
  • folding whitespace
  • double-byte characters in either local-part or domain (7-bit ASCII only).
  • etc.

It should accept almost any email address that can be expressed thusly

without requiring the use of quotes ( " ), angle brackets ('<>') or square brackets ( [] ).

No attempt is made to validate that the rightmost dns label in the domain is a valid TLD (top-level domain). That is because the list of TLDs is far larger now than the "big 6" (.com, .edu, .gov, .mil, .net, .org) plus 2-letter ISO country codes. ICANN actually updates the TLD list daily , though I suspect that the list doesn't actually change daily. Further, [ICANN just approved a big expansion of the generic TLD namespace][2]). And some email addresses don't have what you'd recognize as a TLD (did you know that [email protected] is theoretically valid and mailable? Mail to that address should get delivered to the postmaster of the DNS root zone.)

Extending the regular expression to support domain literals shouldn't be too difficult.


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




email-validation