it-swarm.com.de

C # -Code zum Bestätigen der E-Mail-Adresse

Was ist der eleganteste Code, um zu überprüfen, dass eine Zeichenfolge eine gültige E-Mail-Adresse ist?

355
leora

Was ist damit?

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

Zur Klarstellung wird gefragt, ob eine bestimmte Zeichenfolge eine gültige Repräsentation einer E-Mail-Adresse ist und nicht, ob eine E-Mail-Adresse ein gültiges Ziel zum Senden einer Nachricht ist. Die einzige Möglichkeit besteht darin, eine Nachricht zur Bestätigung zu senden.

Beachten Sie, dass E-Mail-Adressen verzeihender sind, als Sie zunächst annehmen könnten. Dies sind alles vollkommen gültige Formulare:

In den meisten Anwendungsfällen ist ein falsches "ungültig" für Ihre Benutzer und zukünftiges Proofing viel schlimmer als ein falsches "ungültig". Hier ist ein Artikel, der die akzeptierte Antwort war auf diese Frage (diese Antwort wurde inzwischen gelöscht). Es hat viel mehr Details und einige andere Ideen, wie das Problem gelöst werden kann.

Die Durchführung von Sanitätsprüfungen ist nach wie vor eine gute Idee für die Benutzererfahrung. Unter der Annahme, dass die E-Mail-Adresse gültig ist, können Sie nach bekannten Top-Level-Domänen suchen, die Domäne auf einen MX-Eintrag überprüfen, auf Rechtschreibfehler bei allgemeinen Domänennamen (gmail.cmo) usw. überprüfen eine Chance zu sagen "Ja, mein Mail-Server erlaubt wirklich ???????????? als E-Mail-Adresse."


In Bezug auf die Ausnahmebehandlung für Geschäftslogik stimme ich zu, dass dies zu vermeiden ist. Dies ist jedoch einer der Fälle, in denen die Bequemlichkeit und Klarheit das Dogma überwiegen kann.

Wenn Sie mit der E-Mail-Adresse irgendetwas anderes tun, wird dies wahrscheinlich in eine E-Mail-Adresse umgewandelt. Selbst wenn Sie diese genaue Funktion nicht verwenden, möchten Sie wahrscheinlich dasselbe Muster verwenden. Sie können auch nach bestimmten Arten von Fehlern suchen, indem Sie unterschiedliche Ausnahmen : null, leeres oder ungültiges Format abrufen.


Laut Stuart's Kommentar vergleicht dies die endgültige Adresse mit der ursprünglichen Zeichenfolge, anstatt immer "true" zurückzugeben. MailAddress versucht, eine Zeichenfolge mit Leerzeichen in die Abschnitte "Anzeigename" und "Adresse" zu parsen, sodass die ursprüngliche Version falsch positive Ergebnisse zurückgegeben hat.


--- Lesen Sie weiter ---

Dokumentation für System.Net.Mail.MailAddress

Erklärung, was eine gültige E-Mail-Adresse ausmacht

626
Cogwheel

Dies ist eine alte Frage, aber alle Antworten, die ich zu SO gefunden habe, einschließlich der neueren, werden ähnlich beantwortet. In .Net 4.5/MVC 4 können Sie jedoch eine E-Mail-Adressvalidierung zu einem Formular hinzufügen, indem Sie die [EmailAddress] -Anmerkung von System.ComponentModel.DataAnnotations hinzufügen. Daher habe ich mich gefragt, warum ich die eingebaute Funktionalität nicht einfach verwenden kann. Netz im Allgemeinen. 

Das scheint zu funktionieren und erscheint mir ziemlich elegant:

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

Ich benutze diese Einschichtmethode, die die Arbeit für mich erledigt.

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

Laut den Kommentaren schlägt dies fehl, wenn source (die E-Mail-Adresse) null ist.

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

.net 4.5 hinzugefügt System.ComponentModel.DataAnnotations.EmailAddressAttribute

Sie können die EmailAddressAttribute-Quelle durchsuchen , dies ist die Regex, die es intern verwendet:

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

Ich nahm Phils Antwort von # 1 und erstellte diese Klasse ... _. Nenne sie so: bool isValid = Validator.EmailIsValid(emailString);

Hier ist die Klasse:

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

Persönlich würde ich sagen, dass Sie nur sicherstellen sollten, dass dort ein @ -Zeichen vorhanden ist, möglicherweise mit einem. Charakter. Es gibt viele Ausdrücke, die Sie von unterschiedlicher Korrektheit verwenden können, aber ich denke, die meisten davon lassen gültige E-Mail-Adressen aus oder lassen ungültige Adressen durch. Wenn Menschen eine falsche E-Mail-Adresse eingeben möchten, geben sie eine falsche E-Mail-Adresse ein. Wenn Sie überprüfen müssen, ob die E-Mail-Adresse echt ist und dass die Person diese E-Mail-Adresse kontrolliert, müssen Sie ihnen eine E-Mail mit einem speziellen codierten Link senden, damit sie überprüfen kann, ob es sich tatsächlich um eine echte Adresse handelt.

27
Kibbee

Ich denke, der beste Weg ist wie folgt:

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

Sie können diese statische Funktion in einer allgemeinen Klasse haben.

14
Poyson1

Die eleganteste Methode ist die Verwendung der integrierten Methoden von .Net.

Diese Methoden:

  • Sind getestet und getestet. Diese Methoden werden in meinen eigenen professionellen Projekten verwendet.

  • Verwenden Sie interne Ausdrücke, die zuverlässig und schnell sind. 

  • Hergestellt von Microsoft für C #. Das Rad muss nicht neu erfunden werden.

  • Gib ein bool Ergebnis zurück. Richtig bedeutet, dass die E-Mail gültig ist.

Für Benutzer von .NET 4.5 und höher

Fügen Sie diese Referenz Ihrem Projekt hinzu:

System.ComponentModel.DataAnnotations

Jetzt können Sie den folgenden Code verwenden:

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

Anwendungsbeispiel

Hier sind einige zu deklarierende Methoden:

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;

}

... und Code, der sie in Aktion demonstriert:

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

}

Zusätzlich dieses Beispiel:

  • Wird über die Spezifikation hinaus erweitert, da ein einzelner String 0, eine oder mehrere E-Mail-Adressen enthält, die durch ein Semikolon ; ersetzt werden.
  • Verdeutlicht deutlich die Verwendung der IsValid-Methode des EmailAddressAttribute-Objekts.

Alternative, für Benutzer einer .Net-Version unter 4.5

Für Situationen, in denen .NET 4.5 nicht verfügbar ist, verwende ich die folgende Lösung:

Speziell verwende ich:

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

Um ehrlich zu sein, überprüfe ich im Produktionscode das @ Symbol.

Ich bin nie in der Lage, E-Mails vollständig zu überprüfen. Sie wissen, wie ich sehe, ob es wirklich gültig war? Wenn es gesendet wurde. Wenn nicht, ist es schlecht, wenn nicht, dann ist das Leben gut. Das ist alles was ich wissen muss.

6
Noon Silk

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

Ich finde, dieser Regex ist ein guter Kompromiss zwischen der Suche nach etwas mehr als nur der @-Marke und dem Akzeptieren von seltsamen Edge-Fällen:

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

Es wird mindestens dazu führen, dass Sie etwas um das @ -Zeichen setzen und mindestens eine normal aussehende Domain setzen.

6
Matthew Lock

Hier ist meine Antwort - Phils Lösung schlägt für einzelne Briefdomänen wie "[email protected]" fehl. Ob Sie es glauben oder nicht, das wird verwendet =) (geht beispielsweise zu Centurylink).

Phils Antwort wird auch nur mit dem PCRE-Standard funktionieren ... also wird C # es akzeptieren, aber Javascript wird bombardieren. Es ist zu komplex für Javascript. Daher können Sie die Lösung von Phil nicht für MVC-Validierungsattribute verwenden.

Hier ist meine Regex. Es funktioniert gut mit MVC-Validierungsattributen.
- Alles vor dem @ ist vereinfacht, so dass zumindest Javascript funktioniert. Ich bin in Ordnung, die Validierung hier zu lockern, solange der Exchange-Server mir keine 5.1.3 gibt .- Alles nach dem @ ist Phils Lösung, die für Single-Letter-Domänen modifiziert ist.

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

Für Leute, die die Verwendung von system.net.mail MailMessage () vorschlagen, ist diese Sache WEG zu flexibel. Sicher, C # akzeptiert die E-Mail, aber dann wird der Exchange-Server mit dem Laufzeitfehler 5.1.3 bombiert, sobald Sie versuchen, die E-Mail zu senden.

4
Ralph N

Die Überprüfung der E-Mail-Adresse ist nicht so einfach, wie es scheint. Es ist theoretisch unmöglich, eine E-Mail-Adresse mit einem regulären Ausdruck vollständig zu überprüfen.

In meinem blog post darüber finden Sie eine Diskussion zu diesem Thema und eine F # - Implementierung mit FParsec. [/ shameless_plug]

4

Wenn Sie und ich wirklich wissen möchten, ob eine E-Mail-Adresse gültig ist ... bitten Sie den Mail-Exchanger, dies zu beweisen, es ist kein Regex erforderlich. Ich kann den Code auf Anfrage zur Verfügung stellen.

Allgemeine Schritte sind wie folgt: 1. Hat die E-Mail-Adresse einen Domänennamen? (Index von @> 0) 2. Verwenden einer DNS-Abfrage Fragen Sie, ob die Domäne über einen Mail-Exchanger verfügt 3. Öffnen Sie die TCP-Verbindung zum Mail Exchanger 4. Öffnen Sie mithilfe des SMTP-Protokolls eine Nachricht an den Server, und verwenden Sie die E-Mail-Adresse als Empfänger 5. Analysieren Sie die Antwort des Servers . 6. Beenden Sie die Nachricht, wenn Sie es soweit geschafft haben, alles ist gut.

Das ist, wie Sie sich vorstellen können, sehr zeitaufwendig und auf SMTP angewiesen, aber es funktioniert.

3
Joe Caffeine

Die am meisten gewählte Antwort von @Cogwheel ist die beste Antwort. Ich habe jedoch versucht, die trim() string-Methode zu implementieren, damit der gesamte Leerraum des Benutzers vom Anfang bis zum Ende des Strings abgeschnitten wird. Überprüfen Sie den Code unten für vollständige Beispiele-

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

Im Allgemeinen ist ein regulärer Ausdruck zur Überprüfung von E-Mail-Adressen keine einfache Sache. Zum Zeitpunkt der Erstellung dieses Dokuments muss die Syntax einer E-Mail-Adresse einer relativ hohen Anzahl von Standards entsprechen. Die Implementierung dieser Werte in einen regulären Ausdruck ist praktisch nicht durchführbar!

Ich empfehle Ihnen dringend, unser EmailVerify.NET auszuprobieren, eine ausgereifte .NET-Bibliothek, die E-Mail-Adressen nach all der aktuellen IETF-Standards (RFC 1123, RFC 2821, RFC 2822, RFC 3696, RFC) validiert 4291, RFC 5321 und RFC 5322), prüft die zugehörigen DNS-Einträge, prüft, ob die Zielpostfächer Nachrichten annehmen können, und kann sogar feststellen, ob eine bestimmte Adresse verfügbar ist oder nicht.

Haftungsausschluss: Ich bin der Hauptentwickler für diese Komponente.

2
Efran Cobisi

Prüfen Sie, ob die E-Mail-Zeichenfolge das richtige Format oder ein falsches Format hat, indem Sie 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

Hier gibt es viele starke Antworten. Ich empfehle jedoch, dass wir einen Schritt zurücktreten. @Cogwheel beantwortet die Frage https://stackoverflow.com/a/1374644/388267 . In einem Massenvalidierungsszenario kann es jedoch teuer werden, wenn viele der überprüften E-Mail-Adressen ungültig sind. Ich schlage vor, dass wir ein bisschen Logik anwenden, bevor wir in seinen Try-Catch-Block einsteigen. Ich weiß, dass der folgende Code mit RegEx geschrieben werden könnte, was aber für neue Entwickler teuer sein kann. Das ist meine Zweiheit wert:

    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

/ Verwendung des internen Regex, der zum Erstellen der "neuen EmailAddressAttribute ();" verwendet wird Komponente in .Net4.5 >>> using System.ComponentModel.DataAnnotations; // So überprüfen Sie eine E-Mail-Adresse ... Getestet und funktioniert.

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

Sie können dies auch verwenden:

http://msdn.Microsoft.com/de-de/library/01escwtf(v=vs.110).aspx

1
Aina Ademola C

Hier ist eine Antwort auf Ihre Frage, die Sie überprüfen können.

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

Es gibt ein Kulturproblem in Regex in C # statt js. Wir müssen also Regex im US-Modus für die E-Mail-Überprüfung verwenden. Wenn Sie den ECMAScript-Modus nicht verwenden, werden Ihre Sprach-Sonderzeichen in A-Z mit Regex impliziert.

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

Ich habe eine Funktion geschrieben, um zu überprüfen, ob eine E-Mail gültig ist oder nicht. Es scheint für mich in den meisten Fällen gut zu funktionieren.

Ergebnisse:

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

[email protected] => TRUE
[email protected] => TRUE
[email protected] => TRUE
[email protected] => TRUE

Code:

    private bool IsValidEmail(string email)
    {
        bool valid = false;
        try
        {
            var addr = new System.Net.Mail.MailAddress(email);
            valid = true;
        }
        catch
        {
            valid = false;
            goto End_Func;
        }

        valid = false;
        int pos_at = email.IndexOf('@');
        char checker = Convert.ToChar(email.Substring(pos_at + 1, 1));
        var chars = "qwertyuiopasdfghjklzxcvbnm0123456789";
        foreach (char chr in chars)
        {
            if (checker == chr)
            {
                valid = true;
                break;
            }
        }
        if (valid == false)
        {
            goto End_Func;
        } 

        int pos_dot = email.IndexOf('.', pos_at + 1);
        if(pos_dot == -1)
        {
            valid = false;
            goto End_Func;
        }

        valid = false;
        try
        {
            checker = Convert.ToChar(email.Substring(pos_dot + 1, 1));
            foreach (char chr in chars)
            {
                if (checker == chr)
                {
                    valid = true;
                    break;
                }
            }
        }
        catch
        {
            valid = false;
            goto End_Func;
        }

        Regex valid_checker = new Regex(@"^[[email protected]]*$");
        valid = valid_checker.IsMatch(email);
        if (valid == false)
        {
            goto End_Func;
        }

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

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

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

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

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

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

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

    End_Func:;
        return valid;
    }
0
Louis Tran

Basierend auf der Antwort von @Cogwheel möchte ich eine modifizierte Lösung freigeben, die für SSIS und die "Skriptkomponente" funktioniert:

  1. Fügen Sie die "Skriptkomponente" in Ihre Datenflussverbindung ein und öffnen Sie sie.
  2. Setzen Sie im Abschnitt "Eingabespalten" das Feld, das die E-Mail-Adressen enthält, auf "ReadWrite" (im Beispiel 'fieldName').
  3. Wechseln Sie wieder in den Bereich "Skript" und klicken Sie auf "Skript bearbeiten". Dann müssen Sie warten, nachdem der Code geöffnet wurde.
  4. Platzieren Sie diesen Code in der richtigen Methode:

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

Dann können Sie eine bedingte Aufteilung verwenden, um alle ungültigen Datensätze oder das, was Sie tun möchten, herauszufiltern.

0
user3772108

Eine weitere Regex Match-Antwort:

   /// <summary>
   /// Validates the email input
   /// </summary>
   internal static bool ValidateEmail(string _emailAddress)
   { 

        string _regexPattern = @"^(([\w-]+\.)+[\w-]+|([a-zA-Z]{1}|[\w-]{2,}))@"
                + @"((([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\.([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\."
                + @"([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\.([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])){1}|"
                + @"([a-zA-Z]+[\w-]+\.)+[a-zA-Z]{2,4})$";

        return (string.IsNullOrEmpty(_emailAddress) == false && System.Text.RegularExpressions.Regex.IsMatch(_emailAddress, _regexPattern))
            ? true
            : false;
    }
0
karsnen

Eine einfache Möglichkeit, die E-Mail-ID zu identifizieren, ist gültig oder nicht.

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

Am Ende habe ich diesen regulären Ausdruck verwendet, da er erfolgreich Kommas, Kommentare, Unicode-Zeichen und IP-Adressen (v4) überprüft. 

Gültige Adressen sind:

"" @ example.org

(comment)[email protected]

тест@example.org

example @ 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

eine kleine Änderung an @Cogwheel answer

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

Falls Sie FluentValidation verwenden, könnten Sie etwas so einfaches schreiben:

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

Ich habe die Antwort von Poyson 1 so zusammengefasst:

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