risposta-alla-domanda-sullo-sviluppo-web-bd.com

Codice C # per convalidare l'indirizzo email

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

355
leora

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 è chiedersi 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 è 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 (quella 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 da 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 un 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 MailAddress. Anche se non usi questa funzione esatta, probabilmente vorrai usare lo stesso schema. È inoltre possibile verificare specifici tipi di errore rilevando diverse eccezioni : 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.


--- Ulteriore lettura ---

Documentazione per System.Net.Mail.MailAddress

Spiegazione di cosa costituisce un indirizzo email valido

626
Cogwheel

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

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

Come per i commenti, questo "fallirà" se source (l'indirizzo email) è nullo.

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

.net 4.5 aggiunto System.ComponentModel.DataAnnotations.EmailAddressAttribute

Puoi sfogliare l'origine EmailAddressAttribute , questo è il Regex che usa 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])))\.?$";
35
Chad Grant

Ho preso la risposta di Phil dal numero 1 e ho creato questa classe . Chiamala 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;
    }
}
31

Personalmente, direi che dovresti solo assicurarti che ci sia un simbolo @, con possibilmente a. personaggio. Ci sono molte regex che puoi usare di varia correttezza, ma penso che la maggior parte di esse non contenga indirizzi email validi, o ne facciano passare quelli non validi. Se le persone vogliono inserire un falso indirizzo e-mail, ne inseriranno uno falso. Se è necessario verificare che l'indirizzo e-mail sia legittimo e che la persona abbia il controllo di tale indirizzo e-mail, sarà necessario inviare loro un'e-mail con uno speciale collegamento codificato in modo che possano verificare che si tratti effettivamente di un indirizzo reale.

27
Kibbee

Penso che il modo migliore sia il seguente:

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

Puoi avere questa funzione statica in una classe generale.

14
Poyson1

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 utenti di una versione di .Net inferiore a 4.5

Per le 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;

}
13

Per essere onesti, nel codice di produzione, il meglio che faccio è controllare 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.

6
Noon Silk

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);
        }
6
Naveen Soni

Trovo che questa regex sia un buon compromesso tra il controllo di qualcosa di più del solo simbolo @ e l'accettazione di casi di Edge strani:

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

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

6
Matthew Lock

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.

4
Ralph N

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

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

4

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 email 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. usando il protocollo smtp, apri un messaggio al server usando l'indirizzo email come ricevitore 5. analizzare la risposta del server . 6. lascia il messaggio se ce l'hai fatta fin qui, tutto è buono.

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

3
Joe Caffeine

La risposta più votata da @Cogwheel è la migliore risposta, tuttavia, ho provato ad implementare il metodo stringa trim() in modo da tagliare tutto lo spazio bianco dell'utente dalla stringa dall'inizio alla fine. 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;
    }
}
2
Liakat Hossain
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;
        }
2
user2211290

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!

Consiglio vivamente di provare la nostra EmailVerify.NET , una libreria .NET matura in grado di convalidare gli indirizzi e-mail seguendo all degli 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ò persino stabilire se un determinato indirizzo è disponibile o meno.

Disclaimer: Sono lo sviluppatore principale di questo componente.

2
Efran Cobisi

Controlla che la stringa email sia nel formato corretto o nel formato errato di 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";
        }
    }
2
RKTUXYN

Ci sono molte risposte forti qui. Tuttavia, ti consiglio di fare un passo indietro. @Cogwheel risponde alla domanda https://stackoverflow.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://stackoverflow.com/a/1374644/388267 
        try
        {
            var addr = new System.Net.Mail.MailAddress(input);
            return addr.Address == input;
        }
        catch
        {
            return false;
        }
    }
1
CarneyCode

/ 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

1
Aina Ademola C

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;

   }

}
1
Parsa Karami

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 A-Z 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)
0
mkysoft

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;
    }
0
Louis Tran

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

  1. Inserisci il "Componente script" nella connessione Flusso di dati, quindi aprilo.
  2. Nella sezione "Colonne di input" imposta il campo che contiene gli indirizzi di posta elettronica in "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 usare una divisione condizionale per filtrare tutti i record non validi o qualunque cosa tu voglia fare.

0
user3772108

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,}))$";
0
d.popov

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

Nel caso tu stia usando FluentValidation potresti 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;
0
Ulysses Alves

Ho brevettato 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);
}
0
B. Clay Shannon
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);
}
0
ErwanLent