Codice C # per convalidare l'indirizzo e-mail

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

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 determinata stringa è una rappresentazione valida di un indirizzo e-mail, non se un indirizzo e-mail è una destinazione valida per inviare un messaggio. Per questo, l'unico vero modo è inviare un messaggio per confermare.

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

• COG @ ruota
• "ruota dentata l'arancia" @ example.com
• 123@$.xyz

Per la maggior parte dei casi d'uso, un falso "non valido" è molto peggio per gli utenti e le prove future rispetto a un falso "valido". Ecco un articolo che era la risposta accettata a questa domanda (da allora la risposta è stata cancellata). Ha molti più dettagli e alcune 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, verificare errori di ortografia dai nomi di dominio comuni (gmail.cmo), ecc. Quindi presentare un avviso che fornisce all'utente un'opportunità per dire "sì, il mio server di posta consente davvero 🌮🍳🎁 come indirizzo e-mail".

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, probabilmente si tratterà di trasformarlo in un indirizzo di posta. Anche se non usi questa funzione esatta, probabilmente vorrai usare lo stesso modello. È inoltre possibile verificare la presenza di tipi specifici di errore rilevando diverse eccezioni : formato null, vuoto o non valido.

Per il commento di Stuart, questo confronta l'indirizzo finale con la stringa originale invece di restituire sempre vero. MailAddress tenta di analizzare una stringa con spazi nelle porzioni "Nome visualizzato" e "Indirizzo", quindi la versione originale restituiva falsi positivi.

--- Ulteriori letture ---

Documentazione per System.Net.Mail.MailAddress

Spiegazione di ciò che costituisce un indirizzo email valido

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

Uso questo metodo a linea singola che fa il lavoro per me-

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

Secondo i commenti, questo "fallirà" se source(l'indirizzo e-mail) è nullo.

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

.net 4.5 ha aggiunto System.ComponentModel.DataAnnotations.EmailAddressAttribute

Puoi sfogliare l'origine EmailAddressAttribute , questo è il Regex che utilizza internamente:

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

Ho preso la risposta di Phil dal n. 1 e ho creato questa lezione. Chiamalo così: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;
    }
}

Personalmente, direi che dovresti solo assicurarti che ci sia un simbolo @, con possibilmente un. carattere. Ci sono molte regex che potresti usare di varia correttezza, ma penso che la maggior parte di questi tralasci indirizzi e-mail validi o li lasci passare non validi. Se le persone vogliono inserire un indirizzo e-mail falso, ne inseriranno uno falso. Se è necessario verificare che l'indirizzo di posta elettronica sia legittimo e che la persona abbia il controllo di tale indirizzo di posta elettronica, è necessario inviare loro un'e-mail con un collegamento codificato speciale in modo che possano verificare che si tratti effettivamente di un indirizzo reale.

Penso che il modo migliore sia il seguente:

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

Puoi avere questa funzione statica in una classe generale.

Codice breve e preciso

string Email = txtEmail.Text;
if (Email.IsValidEmail())
{
   //use code here 
}

public static bool IsValidEmail(this string email)
{
  string pattern = @"^(?!\.)(""([^""\r\\]|\\[""\r\\])*""|" + @"([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)" + @"@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$";    
  var regex = new Regex(pattern, RegexOptions.IgnoreCase);    
  return regex.IsMatch(email);
}

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

Questi metodi:

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

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

• Realizzato da Microsoft per C #. Non è necessario reinventare la ruota.

• Restituisce un risultato bool. True indica che l'e-mail è 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("youremailhere@test.test"));

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 dimostrandoli 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 le specifiche poiché una singola stringa viene utilizzata per contenere 0, uno o più indirizzi e-mail sperati 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, utilizzo la seguente soluzione:

In particolare, utilizzo:

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;

}

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

Non sono mai in grado di convalidare completamente le e-mail. Sai come vedo se fosse davvero valido? Se è stato inviato. Se così non fosse, è male, se così fosse, la vita va bene. Questo è tutto ciò che devo sapere.

Trovo che questa regex sia un buon compromesso tra la ricerca di qualcosa di più del semplice segno @ e l'accettazione di strani casi limite:

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

Almeno ti farà mettere qualcosa intorno al segno @ e almeno un dominio dall'aspetto normale.

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

Dai un'occhiata al mio post sul blog per una discussione sull'argomento e un'implementazione di F # usando FParsec. [/ shameless_plug]

Ecco la mia risposta: la soluzione di Phil fallisce per i domini a lettera singola come "someone@q.com". Che ci crediate o no, è usato =) (va a centurylink, per esempio).

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

Ecco la mia regex. Funzionerà perfettamente con gli attributi di convalida MVC.
- Tutto prima di @ è semplificato, in modo che almeno javascript funzioni. Sto bene rilassando la convalida qui a condizione che Exchange Server non mi dia un 5.1.3. - Tutto ciò che segue @ è 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 utilizzare System.net.mail MailMessage (), quella cosa è MODO flessibile. Certo, C # accetterà l'e-mail, ma poi Exchange Server bombarderà con errore di runtime 5.1.3 non appena si tenta di inviare l'e-mail.

Se tu e davvero intendiamo davvero sapere se un indirizzo e-mail è valido ... chiedi allo scambiatore di posta 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. usando una query DNS chiedi se il dominio ha uno scambiatore di posta 3. apri la connessione tcp allo scambiatore di posta 4. usando il protocollo smtp, apri un messaggio al server usando l'indirizzo e-mail come ricevitore 5. analizzare la risposta del server. 6. abbandonare il messaggio se lo hai fatto fino a questo punto, tutto va bene.

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

In generale, un'espressione regolare per convalidare gli indirizzi e-mail non è una cosa facile da inventare; al momento in cui scrivo, la sintassi di un indirizzo e-mail deve seguire un numero relativamente elevato di standard e implementarli tutti in un'espressione regolare è praticamente impossibile!

Consiglio vivamente di provare il nostro EmailVerify.NET , una libreria .NET matura che può convalidare gli indirizzi e-mail seguendo tutti gli standard IETF attuali (RFC 1123, RFC 2821, RFC 2822, RFC 3696, RFC 4291, RFC 5321 e RFC 5322) , verifica i relativi record DNS, verifica se le cassette postali di destinazione possono accettare messaggi e possono persino stabilire se un determinato indirizzo è usa e getta o meno.

Disclaimer: sono lo sviluppatore principale di questo componente.

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

Nel caso in cui stai usando FluentValidation potresti scrivere qualcosa di così semplice:

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;

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

Ci sono molte risposte forti qui. Tuttavia, raccomando di fare un passo indietro. @Cogwheel risponde alla domanda https://stackoverflow.com/a/1374644/388267 . Tuttavia, potrebbe essere costoso in uno scenario di convalida in blocco, se molti degli indirizzi e-mail in fase di convalida non sono validi. Suggerisco di usare 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 da capire per i nuovi sviluppatori. Questo vale il mio 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 risposta più votata da @Cogwheel è la risposta migliore, tuttavia ho cercato di implementare il trim()metodo stringa in modo da tagliare tutto lo spazio bianco dell'utente dall'inizio alla fine della stringa. Controlla il codice qui sotto per un esempio completo-

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

Verifica che la stringa di posta elettronica sia nel formato giusto o nel formato sbagliato 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 EmailAddressAttribute ();" componente in .Net4.5 >>> utilizzando System.ComponentModel.DataAnnotations; // Per convalidare un indirizzo e-mail ...... 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

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

Il modo semplice per identificare l'emailid è 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})(\]?)$");
}

C'è un problema di cultura in regex in C # piuttosto che in js. Quindi dobbiamo usare regex in modalità USA per il controllo della posta elettronica. Se non usi la modalità ECMAScript, i caratteri speciali della tua lingua sono impliciti in AZ con 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)

Ho finito per usare questo regex, poiché convalida con successo virgole, commenti, caratteri Unicode e indirizzi di dominio IP (v4).

Gli indirizzi validi saranno:

"" @ example.org

(comment)test@example.org

тест@example.org

ტესტი @ example.org

test @ [192.168.1.1]

 public const string REGEX_EMAIL = @"^(((\([\w!#$%&'*+\/=?^_`{|}~-]*\))?[^<>()[\]\\.,;:\s@\""]+(\.[^<>()[\]\\.,;:\s@\""]+)*)|(\"".+\""))(\([\w!#$%&'*+\/=?^_`{|}~-]*\))?@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$";

Un semplice senza usare Regex (che non mi piace per la sua scarsa leggibilità):

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

Esempi:

• IsValidEmail("@b.com") // false
• IsValidEmail("a@.com") // false
• IsValidEmail("a@bcom") // false
• IsValidEmail("a.b@com") // false
• IsValidEmail("a@b.") // false
• IsValidEmail("a b@c.com") // false
• IsValidEmail("a@b c.com") // false
• IsValidEmail("a@b.com") // true
• IsValidEmail("a@b.c.com") // true
• IsValidEmail("a+b@c.com") // true
• IsValidEmail("a@123.45.67.89") // true

È pensato per essere semplice e quindi non tratta casi rari come e-mail con domini tra parentesi che contengono spazi (in genere consentiti), e-mail con indirizzi IPv6, ecc.

Ecco una risposta alla tua domanda da verificare.

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;

   }

}

Sulla base della risposta di @Cogwheel, voglio condividere una soluzione modificata che funziona per SSIS e il "Componente di script":

1. Posiziona il "Componente script" nella connessione al flusso di dati, quindi aprilo.
2. Nella sezione "Colonne di input" impostare il campo che contiene gli indirizzi e-mail su "ReadWrite" (nell'esempio "fieldName").
3. Torna alla sezione "Script" e fai 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 suddivisione condizionale per filtrare tutti i record non validi o qualunque cosa tu voglia fare.