email-validation validate - Codice C#per convalidare l'indirizzo email




check address (25)

Qual è il codice più elegante per convalidare che una stringa sia un indirizzo email valido?


Answers

Codice breve e preciso

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

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

Ho scritto una funzione per verificare se un'e-mail è valida o meno. Sembra funzionare bene per me nella maggior parte dei casi.

risultati:

[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

Codice:

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

C'è un problema di cultura nella regex in C # piuttosto che in js. Quindi dobbiamo usare regex in modalità USA per il controllo della posta elettronica. Se non si utilizza la modalità ECMAScript, i caratteri speciali della lingua sono impliciti in AZ con espressioni regolari.

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)

Il modo più elegante è usare i metodi integrati di .Net.

Questi metodi:

  • Sono provati e testati. Questi metodi sono usati nei miei progetti professionali.

  • Usa le espressioni regolari internamente, che sono affidabili e veloci.

  • Prodotto da Microsoft per C #. Non c'è bisogno di reinventare la ruota.

  • Restituisce un risultato bool. Vero significa che l'email è valida.

Per utenti di .Net 4.5 e versioni successive

Aggiungi questo riferimento al tuo progetto:

System.ComponentModel.DataAnnotations

Ora puoi usare il seguente codice:

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

Esempio di utilizzo

Ecco alcuni metodi per dichiarare:

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;

}

... e codice che li dimostra in azione:

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

}

Inoltre, questo esempio:

  • Si estende oltre la specifica poiché una singola stringa viene utilizzata per contenere 0, uno o più indirizzi e-mail separati da un punto e virgola ; .
  • Dimostra chiaramente come utilizzare il metodo IsValid dell'oggetto EmailAddressAttribute.

Alternativa, per gli utenti di una versione di .Net inferiore a 4.5

Per situazioni in cui .Net 4.5 non è disponibile, io uso la seguente soluzione:

In particolare, io uso:

public static bool IsValidEmailAddress(string emailAddress)
{
    bool MethodResult = false;

    try
    {
        MailAddress m = new MailAddress(emailAddress);

        MethodResult = m.Address == emailAddress;

    }
    catch //(Exception ex)
    {
        //ex.HandleException();

    }

    return MethodResult;

}

public static List<string> GetInvalidEmailAddresses(List<string> recipients)
{
    List<string> MethodResult = null;

    try
    {
        List<string> InvalidEmailAddresses = new List<string>();

        foreach (string Recipient in recipients)
        {
            if (!IsValidEmail(Recipient) && !InvalidEmailAddresses.Contains(Recipient))
            {
                InvalidEmailAddresses.Add(Recipient);

            }

        }

        MethodResult = InvalidEmailAddresses;

    }
    catch //(Exception ex)
    {
        //ex.HandleException();

    }

    return MethodResult;

}

Il modo semplice per identificare l'e-mail è valido o meno.

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

Che dire di questo?

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

Per chiarire, la domanda è se una particolare stringa sia una rappresentazione valida di un indirizzo e-mail, non se l'indirizzo e-mail sia una destinazione valida per inviare un messaggio. Per questo, l'unico vero modo è quello di inviare un messaggio per confermare.

Si noti che gli indirizzi e-mail sono più indulgenti di quanto si possa supporre. Queste sono tutte forme perfettamente valide:

Per la maggior parte dei casi d'uso, un falso "non valido" è molto peggio per gli utenti e per le prove future di un falso "valido". Ecco un articolo che era la risposta accettata a questa domanda (la risposta è stata cancellata). Ha molti più dettagli e altre idee su come risolvere il problema.

Fornire controlli di integrità è ancora una buona idea per l'esperienza dell'utente. Supponendo che l'indirizzo e-mail sia valido, è possibile cercare domini di primo livello noti, controllare il dominio per un record MX, controllare gli errori di ortografia dai nomi di dominio comuni (gmail.cmo), ecc. Quindi presentare un avviso che fornisce all'utente una possibilità di dire "si, il mio server di posta ti permette davvero ๐ŸŒฎ๐Ÿณ๐ŸŽ come indirizzo email".

Per quanto riguarda l'utilizzo della gestione delle eccezioni per la logica aziendale, sono d'accordo che è una cosa da evitare. Ma questo è uno di quei casi in cui la convenienza e la chiarezza possono superare il dogma.

Inoltre, se fai qualcos'altro con l'indirizzo e-mail, è probabile che implichi il passaggio a un indirizzo mail. Anche se non usi questa funzione esatta, probabilmente vorrai usare lo stesso schema. Puoi anche verificare specifici tipi di errore rilevando eccezioni diverse : formato nullo, vuoto o non valido.

Il commento di Per Stuart, confronta l'indirizzo finale con la stringa originale invece di restituire sempre true. MailAddress tenta di analizzare una stringa con spazi nelle porzioni "Visualizza nome" e "Indirizzo", quindi la versione originale restituiva i falsi positivi.

--- Ulteriori letture ---

Documentazione per System.Net.Mail.MailAddress

Spiegazione di cosa costituisce un indirizzo email valido


Nel caso in cui si utilizzi FluentValidation è possibile scrivere qualcosa di semplice come questo:

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;

Io uso questo metodo a singolo liner che fa il lavoro per me-

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

Questa è una vecchia domanda, ma tutte le risposte che ho trovato su SO, comprese quelle più recenti, hanno una risposta simile a questa. Tuttavia, in .Net 4.5 / MVC 4 è possibile aggiungere la convalida dell'indirizzo e-mail a un modulo aggiungendo l'annotazione [EmailAddress] da System.ComponentModel.DataAnnotations, quindi mi chiedevo perché non potevo semplicemente utilizzare la funzionalità integrata da. Net in generale.

Questo sembra funzionare, e mi sembra abbastanza elegante:

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

Ecco la mia risposta: la soluzione di Phil fallisce per domini a lettera singola come "[email protected]". Che ci crediate o no, è usato =) (per esempio, va al centurylink).

La risposta di Phil funzionerà anche solo con lo standard PCRE ... quindi C # lo prenderà, ma javascript sta per bombardare. È troppo complesso per javascript. Quindi non è possibile utilizzare la soluzione di Phil per gli attributi di convalida di mvc.

Ecco la mia espressione regolare. Funzionerà bene con gli attributi di convalida MVC.
- Tutto ciò che precede la @ è semplificato, così almeno javascript funzionerà. Sto bene la convalida rilassante qui finché il server di scambio non mi dà un 5.1.3. - Tutto dopo il @ è la soluzione di Phil modificata per i domini a lettera singola.

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

Per le persone che suggeriscono di usare system.net.mail MailMessage (), quella cosa è MODO flessibile. Certo, C # accetterà l'e-mail, ma il server di scambio bombarderà con l'errore di runtime 5.1.3 non appena proverai a inviare l'e-mail.


Ho finito per usare questo regex, in quanto convalida correttamente virgole, commenti, caratteri Unicode e indirizzi di dominio IP (v4).

Gli indirizzi validi saranno:

"" @ example.org

(comment)[email protected]

ั‚ะตัั‚@example.org

แƒขแƒ”แƒกแƒขแƒ˜ @ example.org

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

Ci sono molte risposte forti qui. Tuttavia, ti consiglio di fare un passo indietro. @Cogwheel risponde alla domanda https://.com/a/1374644/388267 . Tuttavia, potrebbe essere costoso in uno scenario di convalida di massa, se molti degli indirizzi di posta elettronica convalidati non sono validi. Suggerisco di impiegare un po 'di logica prima di entrare nel suo blocco try-catch. So che il seguente codice potrebbe essere scritto usando RegEx, ma potrebbe essere costoso per i nuovi sviluppatori capire. Questo è il mio twopence vale la pena:

    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://.com/a/1374644/388267 
        try
        {
            var addr = new System.Net.Mail.MailAddress(input);
            return addr.Address == input;
        }
        catch
        {
            return false;
        }
    }

In generale, un'espressione regolare per convalidare gli indirizzi e-mail non è una cosa facile da inventare; al momento della stesura di questo documento, la sintassi di un indirizzo e-mail deve seguire un numero relativamente elevato di standard e l'implementazione di tutti loro all'interno di un'espressione regolare è praticamente irrealizzabile!

Ti consiglio vivamente di provare la nostra EmailVerify.NET , una libreria .NET matura in grado di convalidare gli indirizzi email seguendo tutti gli attuali standard IETF (RFC 1123, RFC 2821, RFC 2822, RFC 3696, RFC 4291, RFC 5321 e RFC 5322) , verifica i relativi record DNS, controlla se le cassette postali di destinazione possono accettare messaggi e può anche stabilire se un determinato indirizzo è disponibile o meno.

Disclaimer: Sono lo sviluppatore principale di questo componente.


Per essere onesti, nel codice di produzione, il meglio che faccio è cercare un simbolo @ .

Non sono mai in un posto dove convalidare completamente le email. Sai come vedo se fosse veramente valido? Se è stato inviato. Se così non fosse, sarebbe male, se così fosse, la vita è buona. Questo è tutto ciò che ho bisogno di sapere.


Se davvero e intendo davvero voglio sapere se un indirizzo email è valido ... chiedi allo scambista di posta elettronica di provarlo, non è necessaria alcuna regex. Posso fornire il codice se richiesto.

I passaggi generali sono i seguenti: 1. l'indirizzo e-mail ha una parte del nome di dominio? (indice di @> 0) 2. utilizzando una query DNS chiedere se il dominio ha uno scambiatore di posta 3. aprire la connessione tcp allo scambiatore di posta 4. utilizzando il protocollo smtp, aprire un messaggio al server utilizzando l'indirizzo di posta elettronica come ricevitore 5. analizzare la risposta del server. 6. esci dal messaggio se lo hai fatto fino a questo punto, tutto è buono.

Questo è come puoi immaginare, molto costoso in termini di tempo e si basa su smtp, ma funziona.


La convalida dell'indirizzo e-mail non è così semplice come potrebbe sembrare. In realtà è teoricamente impossibile convalidare completamente un indirizzo email usando solo un'espressione regolare.

Controlla il mio post sul blog per una discussione sull'argomento e un'implementazione di F # usando FParsec. [/ Shameless_plug]


Sulla base della risposta di @Cogwheel voglio condividere una soluzione modificata che funzioni per SSIS e "Script Component":

  1. Inserisci il "Componente script" nel tuo flusso di dati Connetti e quindi aprilo.
  2. Nella sezione "Colonne di input" impostare il campo che contiene gli indirizzi di posta elettronica su "ReadWrite" (nell'esempio "fieldName").
  3. Tornare alla sezione "Script" e fare clic su "Modifica script". Quindi è necessario attendere dopo l'apertura del codice.
  4. Inserisci questo codice nel metodo giusto:

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

Quindi puoi utilizzare una divisione condizionale per filtrare tutti i record non validi o qualsiasi altra cosa tu voglia fare.


Ho succintificato la risposta di Poyson 1 in questo modo:

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

Ho preso la risposta di Phil dal numero 1 e ho creato questa lezione. Chiamalo in questo modo: bool isValid = Validator.EmailIsValid(emailString);

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

Ecco una risposta alla tua domanda per te da controllare.

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;

   }

}

una piccola modifica alla risposta di @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;
  }
}

Controlla la stringa di posta elettronica è formato corretto o formato errato da 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";
        }
    }

/ Utilizzo del Regex interno utilizzato nella creazione del "nuovo indirizzo EmailAddress ();" componente in .Net4.5 >>> utilizzando System.ComponentModel.DataAnnotations; // Convalidare un indirizzo email ...... Testato e funzionante.

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

Inoltre, puoi usare questo:

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


Questo è un metodo di conversione sicura consapevole dell'enumerazione dei flag:

public static bool TryConvertToEnum<T>(this int instance, out T result)
  where T: struct
{
  var enumType = typeof (T);
  if (!enumType.IsEnum)
  {
    throw new ArgumentException("The generic type must be an enum.");
  }
  var success = Enum.IsDefined(enumType, instance);
  if (success)
  {
    result = (T)Enum.ToObject(enumType, instance);
  }
  else
  {
    result = default(T);
  }
  return success;
}




c# email email-validation