C # -Code zum Überprüfen der E-Mail-Adresse

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

Was ist damit?

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

Zur Verdeutlichung wird die Frage gestellt, ob eine bestimmte Zeichenfolge eine gültige Darstellung einer E-Mail-Adresse ist und nicht, ob eine E-Mail-Adresse ein gültiges Ziel zum Senden einer Nachricht ist. Der einzige wirkliche Weg 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 Formen:

• Zahnrad
• "Zahnrad die Orange" @ example.com
• 123@$.xyz

In den meisten Anwendungsfällen ist ein falsches "ungültig" für Ihre Benutzer und die Zukunftssicherung viel schlechter als ein falsches "gültig". Hier ist ein Artikel, der früher die akzeptierte Antwort auf diese Frage war (diese Antwort wurde inzwischen gelöscht). Es enthält viel mehr Details und einige andere Ideen zur Lösung des Problems.

Die Bereitstellung von Sanity Checks ist immer noch eine gute Idee für die Benutzererfahrung. Angenommen, die E-Mail-Adresse ist gültig, können Sie nach bekannten Domains der obersten Ebene suchen, die Domain auf einen MX-Eintrag überprüfen, nach Rechtschreibfehlern bei allgemeinen Domainnamen (gmail.cmo) suchen usw. Anschließend eine Warnung an den Benutzer senden eine Chance zu sagen "Ja, mein Mailserver erlaubt wirklich 🌮🍳🎁 als E-Mail-Adresse."

Ich stimme zu, dass die Verwendung der Ausnahmebehandlung für die Geschäftslogik vermieden werden sollte. Dies ist jedoch einer der Fälle, in denen die Bequemlichkeit und Klarheit das Dogma überwiegen kann.

Wenn Sie mit der E-Mail-Adresse etwas anderes tun, müssen Sie sie wahrscheinlich in eine Mail-Adresse umwandeln. Auch wenn Sie nicht genau diese Funktion verwenden, möchten Sie wahrscheinlich dasselbe Muster verwenden. Sie können auch nach bestimmten Arten von Fehlern suchen, indem Sie verschiedene Ausnahmen abfangen: null, leer oder ungültiges Format.

Laut Stuarts 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 Bereiche "Anzeigename" und "Adresse" zu analysieren, sodass die ursprüngliche Version falsch positive Ergebnisse zurückgibt.

--- Weiterführende Literatur ---

Dokumentation für System.Net.Mail.MailAddress

Erläuterung, woraus eine gültige E-Mail-Adresse besteht

Dies ist eine alte Frage, aber alle Antworten, die ich auf SO gefunden habe, einschließlich neuerer, werden ähnlich wie diese beantwortet. In .Net 4.5 / MVC 4 können Sie einem Formular jedoch eine E-Mail-Adressüberprüfung hinzufügen, indem Sie die Anmerkung [EmailAddress] aus System.ComponentModel.DataAnnotations hinzufügen. Daher habe ich mich gefragt, warum ich die integrierte Funktionalität von nicht einfach verwenden kann. Netto im Allgemeinen.

Dies scheint zu funktionieren und scheint mir ziemlich elegant zu sein:

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

Ich benutze diese Single-Liner-Methode, die die Arbeit für mich erledigt.

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

Gemäß den Kommentaren wird dies "fehlschlagen", wenn die source(die E-Mail-Adresse) null ist.

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

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

Sie können die Quelle von EmailAddressAttribute durchsuchen. Dies ist der Regex, der intern verwendet wird:

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

Ich habe Phils Antwort von # 1 genommen und diese Klasse erstellt. Nennen Sie es 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;
    }
}

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

Ich denke, der beste Weg ist wie folgt:

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

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

Kurzer und genauer Code

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

Am elegantesten ist es, die in .Net integrierten Methoden zu verwenden.

Diese Methoden:

• Sind bewährt. Diese Methoden werden in meinen eigenen beruflichen Projekten verwendet.

• Verwenden Sie intern reguläre Ausdrücke, die zuverlässig und schnell sind.

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

• Gibt ein Bool-Ergebnis zurück. True 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("youremailhere@test.test"));

Anwendungsbeispiel

Hier sind einige Methoden zum Deklarieren:

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

}

Außerdem dieses Beispiel:

• Erweitert die Spezifikation, da eine einzelne Zeichenfolge 0, eine oder mehrere E-Mail-Adressen enthält, die durch ein Semikolon getrennt sind ;.
• Zeigt deutlich, wie die IsValid-Methode des EmailAddressAttribute-Objekts verwendet wird.

Alternative für Benutzer einer Version von .Net unter 4.5

In Situationen, in denen .Net 4.5 nicht verfügbar ist, verwende ich die folgende Lösung:

Insbesondere benutze 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;

}

Um ehrlich zu sein, suche ich im Produktionscode am besten nach einem @Symbol.

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

Ich finde, dass dieser reguläre Ausdruck ein guter Kompromiss zwischen der Suche nach mehr als nur der @ -Marke und dem Akzeptieren seltsamer Randfälle ist:

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

Es wird Sie zumindest dazu bringen, etwas um die @ -Marke zu setzen und zumindest eine normal aussehende Domain.

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

In meinem Blogbeitrag finden Sie eine Diskussion zu diesem Thema und eine F # -Implementierung mit FParsec. [/ shameless_plug]

Hier ist meine Antwort: Phils Lösung schlägt für Domänen mit einem Buchstaben wie "jemand@q.com" fehl. Ob Sie es glauben oder nicht, das wird verwendet =) (geht zum Beispiel zu centurylink).

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

Hier ist meine Regex. Es funktioniert gut mit MVC-Validierungsattributen.
- Alles vor dem @ wird 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 Domänen mit einem Buchstaben geändert wurde.

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 vorschlagen, system.net.mail MailMessage () zu verwenden, ist dieses Ding viel zu flexibel. Sicher, C # akzeptiert die E-Mail, aber dann wird der Exchange-Server mit dem Laufzeitfehler 5.1.3 bombardiert, sobald Sie versuchen, die E-Mail zu senden.

Wenn Sie wirklich und ich meine wirklich wissen wollen, ob eine E-Mail-Adresse gültig ist ... bitten Sie den Mail-Austauscher, dies zu beweisen, es ist keine Regex erforderlich. Ich kann den Code auf Anfrage bereitstellen.

Die allgemeinen Schritte lauten wie folgt: 1. Hat die E-Mail-Adresse einen Domainnamen-Teil? (Index von @> 0) 2. Fragen Sie mithilfe einer DNS-Abfrage, ob die Domäne über einen Mail-Austauscher verfügt. 3. Öffnen Sie die TCP-Verbindung zum Mail-Austauscher. 4. Öffnen Sie mithilfe des SMTP-Protokolls eine Nachricht an den Server, indem Sie die E-Mail-Adresse als Empfänger verwenden. 5. Analysieren Sie die Antwort des Servers. 6. Beenden Sie die Nachricht, wenn Sie es bis hierher geschafft haben. Alles ist gut.

Dies ist, wie Sie sich vorstellen können, zeitlich sehr teuer und basiert auf SMTP, aber es funktioniert.

Im Allgemeinen ist es nicht einfach, einen regulären Ausdruck zum Überprüfen von E-Mail-Adressen zu finden. Zum Zeitpunkt dieses Schreibens muss die Syntax einer E-Mail-Adresse einer relativ hohen Anzahl von Standards entsprechen, und die Implementierung aller Standards in einem regulären Ausdruck ist praktisch nicht durchführbar!

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

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

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

Falls Sie verwenden FluentValidation könnten Sie etwas so einfach wie 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;

eine kleine Änderung an @Cogwheel Antwort

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

Hier gibt es viele starke Antworten. Ich empfehle jedoch, einen Schritt zurückzutreten. @Cogwheel beantwortet die Frage https://stackoverflow.com/a/1374644/388267 . In einem Massenvalidierungsszenario kann es jedoch kostspielig sein, wenn viele der zu validierenden E-Mail-Adressen ungültig sind. Ich schlage vor, dass wir ein bisschen Logik anwenden, bevor wir in seinen Try-Catch-Block eintreten. Ich weiß, dass der folgende Code mit RegEx geschrieben werden kann, aber das Verständnis für neue Entwickler kann kostspielig sein. Das ist meine zwei Pence 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;
        }
    }

Die am häufigsten gewählte Antwort von @Cogwheel ist die beste Antwort. Ich habe jedoch versucht, die trim()Zeichenfolgenmethode zu implementieren , damit der gesamte Leerraum des Benutzers vom Anfang bis zum Ende der Zeichenfolge abgeschnitten wird . Überprüfen Sie den Code unten für ein vollständiges Beispiel.

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

Überprüfen Sie, ob die E-Mail-Zeichenfolge das richtige oder das falsche Format hat 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";
        }
    }

/ Verwenden des internen Regex, der beim Erstellen des "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 auch Folgendes verwenden:

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

Ich habe die Antwort von Poyson 1 folgendermaßen 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);
}

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

Es gibt ein Kulturproblem in Regex in C # und nicht in js. Daher müssen wir Regex im US-Modus für die E-Mail-Prüfung verwenden. Wenn Sie den ECMAScript-Modus nicht verwenden, werden Ihre Sprach-Sonderzeichen in AZ mit Regex angezeigt.

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)

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

Gültige Adressen sind:

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

Eine einfache ohne Regex (die ich wegen ihrer schlechten Lesbarkeit nicht mag):

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

Beispiele:

• 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

Es soll einfach sein und behandelt daher keine seltenen Fälle wie E-Mails mit Domänen in Klammern, die Leerzeichen enthalten (normalerweise zulässig), E-Mails mit IPv6-Adressen usw.

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;

   }

}

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

1. Platzieren Sie die "Skriptkomponente" in Ihrer Datenflussverbindung 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 zurück zum Abschnitt "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";
       }
   }

Anschließend können Sie eine bedingte Aufteilung verwenden, um alle ungültigen Datensätze herauszufiltern oder was auch immer Sie tun möchten.