Bestätigen einer E-Mail-Adresse

Ich versuche, eine E-Mail mit c # mit dem folgenden Code zu senden.

<code>MailMessage mail = new MailMessage();
mail.From = new MailAddress(fromAddress, friendlyName);
mail.To.Add(toAddress);
mail.CC.Add(ccAddress);

//set the content
mail.Subject = emailSubject;
mail.Body = emailHeader + "\n" + emailBody;

//send the message
SmtpClient smtp = new SmtpClient(ServerAddress);
smtp.Credentials = CredentialCache.DefaultNetworkCredentials;
mail.IsBodyHtml = true;
smtp.Send(mail);
</code>

Die Zeichenfolge "toAddress", die meine Funktion empfängt, enthält möglicherweise eine einzelne Adresse oder mehrere durch Kommas getrennte Adressen.

Das Problem besteht nun darin, dass bei mehreren durch Kommas getrennten Adressen eine oder zwei von ihnen möglicherweise das falsche E-Mail-Adressformat aufweisen.

Wenn ich also versuche, eine E-Mail mit diesem Code zu senden, erhalte ich die Ausnahme:

"Die angegebene Zeichenfolge hat nicht das für eine E-Mail-Adresse erforderliche Format."

Gibt es eine Möglichkeit, die durch Kommas getrennten E-Mail-Adressen zu überprüfen? Ich hatte irgendwo gelesen, dass die einzige Möglichkeit, eine E-Mail-Adresse zu validieren, darin besteht, eine E-Mail an sie zu senden, da die regulären Ausdrücke zur Validierung einer E-Mail-Adresse erstaunlich umfangreich sein können.

Außerdem habe ich keine Kontrolle über das Design oder darüber, wie diese Adresszeichenfolge zu meiner Funktion kommt. Ich kann die E-Mail-Validierung nicht in der Benutzeroberfläche hinzufügen, daher bin ich dort hilflos ...

Mein Problem ist, dass die E-Mail nicht zugestellt wirdALLES Die Adressen in der durch Kommas getrennten Zeichenfolge, obwohl nurETWAS der Adressen haben das falsche Format.

Gibt es eine Möglichkeit, E-Mail-Adressen in .NET ordnungsgemäß zu überprüfen? Gibt es eine Möglichkeit, die schlechten E-Mail-Adressen auszumerzen und die E-Mail nur an die guten zu senden?

 beyerss16. Juni 2009, 12:54
Ich bin ein wenig verwirrt. Versuchen Sie, eine E-Mail-Adresse oder nur das Format einer E-Mail-Adresse zu überprüfen?

Antworten auf die Frage(12)

ob die E-Mail-Adresse die richtige Form hat (nicht die tatsächlich vorhandene):

private bool isEmail(string inputEmail)
{
    Regex re = new Regex(@"^[A-Z0-9._%+-][email protected][A-Z0-9.-]+\.[A-Z]{2,4}$",
                  RegexOptions.IgnoreCase);
    return re.IsMatch(inputEmail);
}

Ich habe dies mit einem einfacheren Ausdruck (einschließlich Groß- und Kleinschreibung) aktualisiert, um es hoffentlich etwas klarer zu machen.

Im Folgenden finden Sie die Grundlagen des Codes, mit dem überprüft wird, ob die Domäne tatsächlich vorhanden ist:

private bool isRealDomain(string inputEmail)
{
    bool isReal = false;
    try
    {
        string[] host = (inputEmail.Split('@'));
        string hostname = host[1];

        IPHostEntry IPhst = Dns.GetHostEntry(hostname);
        IPEndPoint endPt = new IPEndPoint(IPhst.AddressList[0], 25);
        Socket s = new Socket(endPt.AddressFamily,
                SocketType.Stream, ProtocolType.Tcp);
        s.Connect(endPt);
        s.Close();
        isReal = true;
    }
    catch (<specific exceptions here>)
    {
    }

    return isReal;
}

Sie können noch viel mehr tun, um beispielsweise zu überprüfen, ob die Domain die E-Mails erhält. Außerdem müssen Sie sicherstellen, dass Sie die erforderlichen Ausnahmen abfangen und sie richtig handhaben.

 Jonas Elfström16. Juni 2009, 15:05
[email protected] ist eine vollkommen legale E-Mail-Adresse, aber Ihre Regex glaubt, dass dies nicht der Fall ist.
 ChrisF18. Sept. 2011, 22:10
@CodeInChaos - Ich habe nie gesagt, dass es perfekt ist;) Aber warum nicht bearbeiten?
 John Saunders16. Juni 2009, 16:57
@ ChrisF: Denken Sie stattdessen daran, ein gutes Beispiel zu geben. Siekennt Wie viele Leute finden diese Antworten und kopieren Sie den Code und fügen Sie ihn ein.Sie Ich weiß, es ist nur ein BeispielI Ich weiß, es ist nur ein Beispiel, aber viele von ihnen lesen nicht, bevor sie kopieren und einfügen.
 John Saunders16. Juni 2009, 15:02
IMHO haben Sie viel zu viele Anweisungen innerhalb des "try", als dass Sie alle Ausnahmen mit einem "catch" ignorieren könnten. All dies könnte aus Gründen fehlschlagen, die nichts mit der Gültigkeit der E-Mail-Adresse zu tun haben, und Sie werden es nicht wissen.
 ChrisF16. Juni 2009, 16:48
@jonelf - Ich muss zugeben, dass ich die Regex "ausgeliehen" habe und keine Zeit hatte, sie richtig zu überprüfen. Vielen Dank für die Köpfe hoch.
 CodesInChaos18. Sept. 2011, 16:15
Was ist mit Nicht-ASCII-Domänen? Was ist mit TLDs mit mehr als 4 Zeichen? Und die Kultur sieht auch falsch aus.
 ChrisF16. Juni 2009, 17:08
@ John - so wahr. Hoffentlich wird es mit den Kommentaren und der <bestimmten Ausnahme hier> klarer und ich werde den Code später aktualisieren.
 ChrisF16. Juni 2009, 16:49
@ John Saunders - der Code ist nur als Beispiel da. Ich werde den Versuch entfernen ... zu fangen, wenn Sie das Gefühl haben, es wird in die Quere kommen.
 ChrisF16. Juni 2009, 19:34
@jonelf - Ich habe die Regex aktualisiert, die jetzt mit "+" in E-Mails fertig wird. Ein erneuter Test ergab auch einen Fehler in einem nachfolgenden Code. Nochmals vielen Dank, dass Sie darauf hingewiesen haben.

Sie können verwendenRegex. Schreiben Sie einfach den folgenden Code.

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

werde ich es versuchen. Dies stammt aus dem Produktionscode und hat nichts mit dem Problem der TLD mit einem Buchstaben zu tun ([email protected]).

private bool IsEmailSyntaxValid(string emailToValidate)
{
    return System.Text.RegularExpressions.Regex.IsMatch(emailToValidate,
        @"^([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})(\]?)$");
}

Ich kann mich nicht erinnern, woher ich das habe, aber wie gesagt, es funktioniert bei mir in der Produktion.

 Warren Rumak05. Juni 2012, 21:02
Entschuldigung. - "[email protected]" wird nicht validiert.
 Ryan O'Neill07. Juni 2012, 18:06
Ah, kein Problem. Ich habe das nicht gesehen.

E-Mail-Adressen zu validieren.

Ich habe bis jetzt keinen regulären Ausdruck gefunden, der korrekt validiert werden kann. Ich hatte Fälle, in denen E-Mail-Adressen von Regex blockiert wurden. Daher ist es unser Ziel sicherzustellen, dass die MailMessage während eines Sendens keine Ausnahme auslöst. In diesem Fall können wir die Benutzer benachrichtigen. Wenn Sie jedoch eine falsche E-Mail-Adresse angeben, erhalten Sie keine E-Mail.

teilen Sie die E-Mail-Zeichenfolge am Trennzeichen auf und überprüfen Sie dann jede E-Mail-Adresse. Hier ist ein Beispiel, das bei der zweiten E-Mail-Adresse (foo # bar.com) fehlschlägt. Ich habe den regulären Ausdruck aus dem Steuerelement für reguläre Ausdrücke von asp.net verwendet, um die Adressen zu überprüfen.

String email = "[email protected];foo#bar.com";

String expression = @"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*";

Regex regex = new Regex(expression);

String[] emails = email.Split(new Char[] { ';' });

foreach (String s in emails)
{

    Match m = regex.Match(s);

    if (!m.Success)
     {
        // Validation fails.

     }
}

Sie können den regulären Ausdruck immer unter verwendenDiese Seite es istenorm und völlig unlesbar, aber es bekommt die meisten Randfälle.

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ 
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
 \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
 \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
 \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
?:\r\n)?[ \t])*))*)?;\s*)
string uname = Convert.ToString(string);
string expression = @"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*";

Regex regex = new Regex(expression);
Match m = regex.Match(uname);

if (m.Success)
{
    emailId = uname; 
}
 Sayed Azharuddin22. Apr. 2014, 16:04
Probieren Sie es einfach aus, um eine beliebige Zeichenfolge als E-Mail-ID zu validieren. Es wird funktionieren.

ktualisiert und es funktioniert hervorragend. Verknüpfung:https://docs.microsoft.com/en-us/dotnet/standard/base-types/how-to-verify-that-strings-are-in-valid-email-format

Snippet:

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class RegexUtilities
{
   bool invalid = false;

   public bool IsValidEmail(string strIn)
   {
       invalid = false;
       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 email format.
       try {
          return Regex.IsMatch(strIn,
                @"^(?("")("".+?(?<!\\)""@)|(([0-9a-z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))" +
                @"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-0-9a-z]*[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;
   }
}

100% RFC-konforme E-Mail-Validierungist schwer, sehendiese Antwort für Details. In .NET gibt es zwei relativ einfache MöglichkeitenMail Adresse

try {
    new MailAddress("invalid_email");
} catch (FormatException) {
    // invalid
}

Oder ein strengerer Regex-basierter Ansatz vonMSDN (behandelt IDN- und Regex-Parsing-Timeout für .NET 4.5):

// NET 4.0
Boolean mappingInvalid = false;
emailString = Regex.Replace(emailString, @"(@)(.+)$", match => {
    String domainName = match.Groups[2].Value;
    try {
        domainName = new IdnMapping().GetAscii(domainName);
    } catch (ArgumentException) {
        mappingInvalid = true;
    }
    return match.Groups[1].Value + domainName;
});
if (mappingInvalid) {
    return false;
}
return Regex.IsMatch(emailString,
        @"^(?("")(""[^""]+?""@)|(([0-9a-z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))" +
        @"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-\w]*[0-9a-z]*\.)+[a-z0-9]{2,17}))$",
        RegexOptions.IgnoreCase);
 Liedman29. Jan. 2014, 10:53
Die erste Lösung ist unkompliziert und basiert auf einem (wahrscheinlich) sehr gut getesteten Code, auf den alle .NET-Programmierer Zugriff haben. Gute Arbeit!
Lösung für das Problem

e E-Mail-Adresse mit einem einfachen (oder großen) regulären E-Mail-Ausdruck überprüfen. Oder erstellen Sie eineMailAddress Objekt; Es unterstützt auch einige grundlegende Überprüfungen der Adresse.

 Repo Man04. Mai 2012, 17:16
Zu Ihrer Information: Die Verwendung von MailAddress zur Validierung einer E-Mail-Adresse ist nicht kinderleicht. Es scheint einige schlechte Adressen zuzulassen, die nicht durchkommen sollten, wie "bob. @ Mysite.com" oder "bob..smith @ mysite.com".
 Fredrik Leijon31. Okt. 2012, 15:32
Nun, die einzig narrensichere Methode, um festzustellen, ob die E-Mail korrekt ist, besteht darin, ihr eine E-Mail mit einem benutzerdefinierten Link zum Klicken zu senden (dh Aktivierungslinks, die heutzutage auf den meisten Websites verwendet werden).
 Kobi16. Juni 2009, 14:55
Oh. Ich bin veraltet Aber Semikolons werden immer noch häufig verwendet, nicht wahr? Outlook benutzt sie immer noch, wenn das ein Hinweis ist ... Danke @ashwnacharya.
 Kobi16. Juni 2009, 13:05
Sie sollten auch beachten, dass E-Mails normalerweise durch Semikolons und nicht durch Kommas getrennt sind.
 Jared Harley17. Juni 2009, 00:45
@Kobi - ja, Outlook verwendet sie weiterhin sowie OWA (Outlook Web Access). Jedes Mal, wenn ich eine E-Mail an zwei Personen sende und ein Komma verwende, erhalte ich die Fehlermeldung "John.Smith, Jane.Doe ist keine gültige E-Mail".
 ashwnacharya16. Juni 2009, 13:22
Kobi, früher war es so ... Jetzt werden nur Kommas akzeptiert.rstew.blogspot.com/2007/06/specified-string-is-not-in-form.html
 AlexDrenea16. Juni 2009, 12:59
Du hast Sekunden vor mir mit der Antwort, also habe ich sie nicht erneut gepostet ... +1
 Matthew Flaschen16. Juni 2009, 13:00
+1. Ich denke, der MailAddress-Konstruktor ist mehr als ausreichend für seine aktuellen Zwecke (eine schnelle Überprüfung vor dem ersten Senden).

den wir in der Produktion haben (sogar ein Komma für Sie hinzugefügt). Normalerweise sollten Sie try / catch nicht zur Validierung verwenden, aber es funktioniert hier gut. Ich glaube, es ist besser, als zu versuchen, den Validator neu zu codieren.

string[] allToAddresses = to.Split(";,".ToCharArray(),
                                 StringSplitOptions.RemoveEmptyEntries)
foreach (string toAddress in allToAddresses)
    {
        try
        {
            message.To.Add(toAddress);
        }
        catch (FormatException)
        {
            //do nothing, illformed address. screw it.
        }
    }
 Kobi16. Juni 2009, 14:51
Ich wusste, dass das nicht beliebt sein würde - aber ja. Ansehenmsdn.microsoft.com/en-us/library/ms144695.aspx - zwei Ausnahmen für null und leer sowie eine FormatException. Ich schätze, Sie können immer eine exotische Ausnahme bekommen (etwa aus dem Gedächtnis oder so etwas Verrücktes), also werde ich es ändern. Vielen Dank.
 John Saunders16. Juni 2009, 13:28
Sind Sie sicher, dassjeden Ausnahme durch Hinzufügen ausgelöst impliziert eine falsche Adresse? Sie sollten nur die Ausnahmen abfangen, die tatsächlich vorliegentun meine eine schlechte Adresse. Ihr Code verhindert, dass Sie diese einzige Ausnahme sehen, die besagt, dass "etwas schrecklich falsch ist; ich hoffe, dass jemand dies sieht und etwas dagegen unternimmt; ich werde jetzt sterben; auf Wiedersehen".
 John Saunders16. Juni 2009, 15:04
.NET ist auch nicht Java, und Microsoft kann im Laufe der Zeit Ausnahmen hinzufügen. Es wäre besser, wenn Sie keine Ausnahme machen würdentut implizieren eine ungültige E-Mail-Adresse, als eine Ausnahme zu fangen und zu ignorieren, die impliziert, dass etwas Schreckliches passiert.

ür uns :)

public static bool IsValidEmail(string email)
{
    // source: http://thedailywtf.com/Articles/Validating_Email_Addresses.aspx
    Regex rx = new Regex(
    @"^[-!#$%&'*+/0-9=?A-Z^_a-z{|}~](\.?[-!#$%&'*+/0-9=?A-Z^_a-z{|}~])*@[a-zA-Z](-?[a-zA-Z0-9])*(\.[a-zA-Z](-?[a-zA-Z0-9])*)+$");
    return rx.IsMatch(email);
}

Bitte benutze dies:

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])
 TheVillageIdiot17. Juni 2009, 10:43
yep das ist nicht gut :(
 Jonas Elfström16. Juni 2009, 15:16
Dieser überprüft [email protected], aber es gibt keine TLDs mit einem Buchstaben.
 beyond-code08. Jan. 2013, 16:16
Der erste in dieser Antwort ist der beste, den ich bisher gefunden habe ... obwohl ipv6 oder Sonderzeichen in Anführungszeichen nicht korrekt validiert werden. Der zweite ist leider überhaupt nicht gut.
 Narnian12. Apr. 2012, 16:44
Punkte, um deine Arbeit zu zeigen. Ich musste nur den regulären Ausdruck ändern.
 Vincent Buscarello23. Feb. 2019, 20:35
Hier ist dies auf Regexr, sieht ziemlich kugelsicher aus?regexr.com/48vms

Ihre Antwort auf die Frage