Regex E-Mail-Validierung


215

ich benutze das

@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$"

regexp, um die E-Mail zu validieren

([\w\.\-]+)- Dies gilt für die Domäne der ersten Ebene (viele Buchstaben und Zahlen, auch Punkt und Bindestrich).

([\w\-]+)Dies gilt für die Domäne der zweiten Ebene.

((\.(\w){2,3})+)Dies gilt für Domänen der anderen Ebene (von 3 bis unendlich), die einen Punkt und 2 oder 3 enthalten Literale

Was ist los mit dieser Regex?

BEARBEITEN: Es stimmt nicht mit der E-Mail "Something@someth.ing" überein


1
Abgesehen davon, dass Sie keine gültigen Zeichen einschließen, wie in den RFCs 5321 und 5322 angegeben - nichts.
Brad Christie


Ich denke, Sie müssen uns sagen, was los ist, und dann können andere hier Ihnen helfen, das Falsche zu beheben.
Uwe Keim

10
Du hast ein Problem -> du denkst 'Regex' -> jetzt hast du 2 Probleme ;-)
Jakub Konecki

1
Nur ein Kommentar zu Ihrer Regex. Mit diesen neuen .amsterdam, .info und anderen Domains sollte der reguläre Ausdruck sein:@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,})+)$""
Ton Snoei

Antworten:


371

TLDs wie .museum stimmen auf diese Weise nicht überein, und es gibt einige andere lange TLDs. Sie können E-Mail-Adressen auch mithilfe der MailAddress-Klasse überprüfen, wie Microsoft hier in einem Hinweis erläutert :

Anstatt einen regulären Ausdruck zum Überprüfen einer E-Mail-Adresse zu verwenden, können Sie die System.Net.Mail.MailAddress-Klasse verwenden. Um festzustellen, ob eine E-Mail-Adresse gültig ist, übergeben Sie die E-Mail-Adresse an den Klassenkonstruktor MailAddress.MailAddress (String).

public bool IsValid(string emailaddress)
{
    try
    {
        MailAddress m = new MailAddress(emailaddress);

        return true;
    }
    catch (FormatException)
    {
        return false;
    }
}

Dies erspart Ihnen viel Kopfschmerzen, da Sie keinen regulären Ausdruck schreiben (oder versuchen müssen, den Regex eines anderen zu verstehen).


63
Dies hat weder doppelte Punkte ".." noch Inline-Leerzeichen "." Aufgefangen. Ich werde stattdessen mit der Regex gehen
Benny Skogberg

33
Trotzdem ist eine beliebte Antwort. Es ist nicht richtig, mindestens zwei ungültige Formate nicht abzufangen: "Abc. @ Example.com", "Abc..123 @ example.com"
sean717

12
@ sean717: Siehe RFC und / oder Link . Ich bin damit einverstanden, dass Ihre Beispiele in der realen Welt wahrscheinlich nicht funktionieren, aber das macht sie nicht ungültig.
Dan Pichelman

13
Es wird nicht empfohlen, Try Catch zur Validierung der Eingabe zu verwenden oder nicht. Regex ist definitiv der bessere Weg.
Herr

159
-1 Schlechter Code. Das Abfangen einer Ausnahme ist nicht die Möglichkeit, Felder zu validieren.
ken2k

99

Ich denke @"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$"sollte funktionieren.
Sie müssen es wie schreiben

string email = txtemail.Text;
Regex regex = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
Match match = regex.Match(email);
if (match.Success)
    Response.Write(email + " is correct");
else
    Response.Write(email + " is incorrect");

Seien Sie gewarnt, dass dies fehlschlagen wird, wenn:

  1. Nach dem @Symbol befindet sich eine Subdomain .

  2. Sie verwenden eine TLD mit einer Länge von mehr als 3, z .info


2
Gibt test@-online.com als gültig zurück. Sollte ungültig sein.
Mathias F

7
Ich glaube, dass dies bei den neuen TLDs, die ausgegeben werden, fehlschlagen wird, da Sie jetzt TLDs mit mehr als 3 Zeichen haben können.
AaronLS

Diese Regex erlaubt "somename@gmail.com.in.in.in.in" als gültig.
Neugier

14
gmail.com.in.in.in.in ist ein vollkommen gültiger Domainname, daher kann ich nicht verstehen, warum dies nicht zulässig sein sollte.
Larsw

Stimmen Sie mit @larsw überein, der Regex sollte nicht verwendet werden
Boris Sokolov

68

Ich habe einen Ausdruck zum Überprüfen der von mir verwendeten E-Mail-Adressen.

Da keines der oben genannten so kurz oder genau war wie meins, dachte ich, ich würde es hier posten.

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

Weitere Informationen finden Sie hier: C # - Regulärer Ausdruck per E-Mail

Außerdem wird die RFC-Gültigkeit anhand der E-Mail-Syntax überprüft, nicht jedoch, ob die E-Mail tatsächlich vorhanden ist. Die einzige Möglichkeit, um zu testen, ob eine E-Mail tatsächlich vorhanden ist, besteht darin, sie zu senden und per E-Mail zu senden und den Benutzer überprüfen zu lassen, ob er die E-Mail erhalten hat, indem er auf einen Link klickt oder ein Token eingibt.

Dann gibt es Wegwerfdomains wie Mailinator.com und so. Dadurch wird nicht überprüft, ob eine E-Mail von einer Wegwerfdomäne stammt oder nicht.


Das ist der, den ich gesucht habe - Danke! Nimmt sowohl Doppelpunkte ".." als auch Leerzeichen ".".
Benny Skogberg

5
Ich habe mein Projekt für reguläre Ausdrücke aktualisiert, um Unit-Tests durchzuführen, und sogar einige Fehler behoben: C # - E-Mail für reguläre Ausdrücke rhyous.com/2010/06/15/csharp-email-regular-expression
Rhyous

Bei den neuen TLDs sollten wir möglicherweise [a-zA-Z] {2,4} in der dritten Zeile durch eine {0} ersetzen und dann ein string.format (Muster, pipeSeparatedAllowedTlds) ausführen, bei dem pipeSeparatedAllowedTlds von erstellt werden müssten Durchlaufen dieser Datei: data.iana.org/TLD/tlds-alpha-by-domain.txt
Rhyous

12
Parth. Können Sie mir sagen, gegen welche RFC-Regel Ihre E-Mail verstößt? Weil weißt du was? Laut RFC ist es gültig !!!! Wenn Sie die URL in.in gekauft haben, können Sie diese E-Mail-Adresse erstellen. Verstehen?
Rhyous

2
Eigentlich habe ich das auf meinem Github hier bereits aktualisiert: github.com/rhyous/EmailRegEx . \ W kann jedoch Unterstriche enthalten, sodass ich es möglicherweise aus Gründen der Genauigkeit bearbeiten muss.
Rhyous

36

Ich habe ein schönes Dokument auf MSDN dafür gefunden.

Gewusst wie: Überprüfen Sie, ob die Zeichenfolgen im gültigen E-Mail-Format vorliegen: http://msdn.microsoft.com/en-us/library/01escwtf.aspx (überprüfen Sie, ob dieser Code auch die Verwendung von Nicht-ASCII-Zeichen für Internetdomänennamen unterstützt. )

Es gibt 2 Implementierungen für .Net 2.0 / 3.0 und für .Net 3.5 und höher.
Die 2.0 / 3.0-Version ist:

bool IsValidEmail(string strIn)
{
    // Return true if strIn is in valid e-mail format.
    return Regex.IsMatch(strIn, @"^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$"); 
}

Meine Tests über diese Methode ergeben:

Invalid: @majjf.com
Invalid: A@b@c@example.com
Invalid: Abc.example.com
Valid: j..s@proseware.com
Valid: j.@server1.proseware.com
Invalid: js*@proseware.com
Invalid: js@proseware..com
Valid: ma...ma@jjf.co
Valid: ma.@jjf.com
Invalid: ma@@jjf.com
Invalid: ma@jjf.
Invalid: ma@jjf..com
Invalid: ma@jjf.c
Invalid: ma_@jjf
Invalid: ma_@jjf.
Valid: ma_@jjf.com
Invalid: -------
Valid: 12@hostname.com
Valid: d.j@server1.proseware.com
Valid: david.jones@proseware.com
Valid: j.s@server1.proseware.com
Invalid: j@proseware.com9
Valid: j_9@[129.126.118.1]
Valid: jones@ms1.proseware.com
Invalid: js#internal@proseware.com
Invalid: js@proseware.com9
Invalid: js@proseware.com9
Valid: m.a@hostname.co
Valid: m_a1a@hostname.com
Valid: ma.h.saraf.onemore@hostname.com.edu
Valid: ma@hostname.com
Invalid: ma@hostname.comcom
Invalid: MA@hostname.coMCom
Valid: ma12@hostname.com
Valid: ma-a.aa@hostname.com.edu
Valid: ma-a@hostname.com
Valid: ma-a@hostname.com.edu
Valid: ma-a@1hostname.com
Valid: ma.a@1hostname.com
Valid: ma@1hostname.com

1
Stimmt nicht überein[me]@whatever.museum
Toto

Ungültig: Abc.example.com JA, das funktioniert aber korrekt, diese "toms.email. @ Gmail.com"; funktioniert nicht
Tom Stickel

1
Musste ein Pluszeichen hinzufügen: `@" ^ ([\ w - \. +] +) @ (([[0-9] {1,3} \. [0-9] {1,3} \. [0-9] {1,3} \.) | (([\ W -] + \.) +)) ([A-zA-Z] {2,4} | [0-9] {1, 3}) (]?) $ "` 11 das auf] Google und Hotmail-Alias ​​verbleibende Zeichen ermöglicht die Plus-Anmeldung im ersten Abschnitt vor dem @ -Zeichen.
Henk J Meulekamp

Dies ist das gleiche wie oben. Zulassen von "somename@gmail.com.in.in.in" als gültige E-Mail-Adresse ... !!
Neugier

9
@ParthTrivedi Warum bestehen Sie darauf, dass dies somename@gmail.com.in.in.inkeine gültige E-Mail-Adresse ist?
Ivaylo Slavov

15

Der folgende Code basiert auf der Implementierung von Microsoft Data Annotations auf Github und ist meiner Meinung nach die vollständigste Validierung für E-Mails:

public static Regex EmailValidation()
{
    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])))\.?$";
    const RegexOptions options = RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture;

    // Set explicit regex match timeout, sufficient enough for email parsing
    // Unless the global REGEX_DEFAULT_MATCH_TIMEOUT is already set
    TimeSpan matchTimeout = TimeSpan.FromSeconds(2);

    try
    {
        if (AppDomain.CurrentDomain.GetData("REGEX_DEFAULT_MATCH_TIMEOUT") == null)
        {
            return new Regex(pattern, options, matchTimeout);
        }
    }
    catch
    {
        // Fallback on error
    }

    // Legacy fallback (without explicit match timeout)
    return new Regex(pattern, options);
}

1
Schön, dies von einer professionellen Quelle zu bekommen (natürlich nichts gegen die anderen); geschätzt.
Nicholas Petersen

1
Dies sollte der beste reguläre Ausdruck sein, da er die RFCs 5321 und 5322 zu validieren scheint. Einige Unit-Tests fehlen.
ToXinE

Erfasst keinen Punkt am Ende der E-Mail-Adresse.
Sellorio

12

Dies erfüllt nicht alle Anforderungen der RFCs 5321 und 5322, funktioniert jedoch mit den folgenden Definitionen.

@"^([0-9a-zA-Z]([\+\-_\.][0-9a-zA-Z]+)*)+"@(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]*\.)+[a-zA-Z0-9]{2,17})$";

Unten ist der Code

const String pattern =
   @"^([0-9a-zA-Z]" + //Start with a digit or alphabetical
   @"([\+\-_\.][0-9a-zA-Z]+)*" + // No continuous or ending +-_. chars in email
   @")+" +
   @"@(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]*\.)+[a-zA-Z0-9]{2,17})$";

var validEmails = new[] {
        "ma@hostname.com",
        "ma@hostname.comcom",
        "MA@hostname.coMCom",
        "m.a@hostname.co",
        "m_a1a@hostname.com",
        "ma-a@hostname.com",
        "ma-a@hostname.com.edu",
        "ma-a.aa@hostname.com.edu",
        "ma.h.saraf.onemore@hostname.com.edu",
        "ma12@hostname.com",
        "12@hostname.com",
};
var invalidEmails = new[] {
        "Abc.example.com",     // No `@`
        "A@b@c@example.com",   // multiple `@`
        "ma...ma@jjf.co",      // continuous multiple dots in name
        "ma@jjf.c",            // only 1 char in extension
        "ma@jjf..com",         // continuous multiple dots in domain
        "ma@@jjf.com",         // continuous multiple `@`
        "@majjf.com",          // nothing before `@`
        "ma.@jjf.com",         // nothing after `.`
        "ma_@jjf.com",         // nothing after `_`
        "ma_@jjf",             // no domain extension 
        "ma_@jjf.",            // nothing after `_` and .
        "ma@jjf.",             // nothing after `.`
    };

foreach (var str in validEmails)
{
    Console.WriteLine("{0} - {1} ", str, Regex.IsMatch(str, pattern));
}
foreach (var str in invalidEmails)
{
    Console.WriteLine("{0} - {1} ", str, Regex.IsMatch(str, pattern));
}

1
Dieser Ausdruck stimmt nicht mit gültigen Adressen überein !#$%&'*+-/=?^_. {|} ~ @ example.com` oder dieserDörte@Sörensen.example.com
TS

7

Bester regulärer Ausdruck für die E-Mail-Validierung

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?

Und es ist Verwendung: -

bool isEmail = Regex.IsMatch(emailString, @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z", RegexOptions.IgnoreCase);

6

Probieren Sie dies für die Größe an:

public static bool IsValidEmailAddress(this string s)
{
    var regex = new Regex(@"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?");
    return regex.IsMatch(s);
}

5

Versuchen Sie dies, es funktioniert für mich:

public bool IsValidEmailAddress(string s)
{
    if (string.IsNullOrEmpty(s))
        return false;
    else
    {
        var regex = new Regex(@"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");
        return regex.IsMatch(s) && !s.EndsWith(".");
    }
}

5

Dieser Regex funktioniert perfekt:

bool IsValidEmail(string email)
{
    return Regex.IsMatch(email, @"^[\w!#$%&'*+\-/=?\^_`{|}~]+(\.[\w!#$%&'*+\-/=?\^_`{|}~]+)*@((([\-\w]+\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\.){3}[0-9]{1,3}))\z");
}

4

Dieser verhindert ungültige E-Mails, die von anderen in den Kommentaren erwähnt werden:

Abc.@example.com
Abc..123@example.com
name@hotmail
toms.email.@gmail.com
test@-online.com

Es verhindert auch E-Mails mit doppelten Punkten:

hello..world@example..com

Testen Sie es mit so vielen ungültigen E-Mail-Adressen, wie Sie finden können.

using System.Text.RegularExpressions;

public static bool IsValidEmail(string email)
{
    return Regex.IsMatch(email, @"\A[a-z0-9]+([-._][a-z0-9]+)*@([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,4}\z")
        && Regex.IsMatch(email, @"^(?=.{1,64}@.{4,64}$)(?=.{6,100}$).*");
}

Siehe Überprüfen der E-Mail-Adresse mit regulären Ausdrücken in C # .


Dies gibt für alle meine ungültigen E-Mail-Adressen false zurück. Leider wird auch für viele gültige E-Mail-Adressen false zurückgegeben.
Mark

4

Warum nicht die EF6-Attribut-basierte E-Mail-Validierung verwenden?

Wie Sie oben sehen können, weist die Regex-Validierung für E-Mails immer eine Lücke auf. Wenn Sie EF6-Datenanmerkungen verwenden, können Sie mit dem dafür verfügbaren EmailAddress-Datenanmerkungsattribut problemlos eine zuverlässige und stärkere E-Mail-Validierung erzielen . Ich musste die Regex-Validierung entfernen, die ich zuvor für E-Mails verwendet hatte, als ich im E-Mail-Eingabefeld einen regexspezifischen Regex-Fehler für Mobilgeräte erhielt. Als das Datenanmerkungsattribut für die E-Mail-Validierung verwendet wurde, wurde das Problem auf Mobilgeräten behoben.

public class LoginViewModel
{
    [EmailAddress(ErrorMessage = "The email format is not valid")]
    public string Email{ get; set; }

3
new System.ComponentModel.DataAnnotations.EmailAddressAttribute().IsValid(input)

1
public static bool ValidateEmail(string str)
{                       
     return Regex.IsMatch(str, @"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");
}

Ich verwende den obigen Code, um die E-Mail-Adresse zu bestätigen.


1
   public bool VailidateEntriesForAccount()
    {
       if (!(txtMailId.Text.Trim() == string.Empty))
        {
            if (!IsEmail(txtMailId.Text))
            {
                Logger.Debug("Entered invalid Email ID's");
                MessageBox.Show("Please enter valid Email Id's" );
                txtMailId.Focus();
                return false;
            }
        }
     }
   private bool IsEmail(string strEmail)
    {
        Regex validateEmail = new Regex("^[\\W]*([\\w+\\-.%]+@[\\w\\-.]+\\.[A-Za-z] {2,4}[\\W]*,{1}[\\W]*)*([\\w+\\-.%]+@[\\w\\-.]+\\.[A-Za-z]{2,4})[\\W]*$");
        return validateEmail.IsMatch(strEmail);
    }

Während dieser Code die Frage beantworten kann, verbessert die Bereitstellung eines zusätzlichen Kontexts darüber, warum und / oder wie dieser Code die Frage beantwortet, seinen langfristigen Wert
AStopher

1
string patternEmail = @"(?<email>\w+@\w+\.[a-z]{0,3})";
Regex regexEmail = new Regex(patternEmail);

1

Es wurden viele Versuche unternommen, einen E-Mail-Validator zu erstellen, der nahezu alle weltweiten Anforderungen an E-Mails erfüllt.

Erweiterungsmethode, die Sie aufrufen können mit:

myEmailString.IsValidEmailAddress();

Regex-Musterzeichenfolge erhalten Sie, indem Sie Folgendes aufrufen:

var myPattern = Regex.EmailPattern;

Der Kodex (meistens Kommentare):

    /// <summary>
    /// Validates the string is an Email Address...
    /// </summary>
    /// <param name="emailAddress"></param>
    /// <returns>bool</returns>
    public static bool IsValidEmailAddress(this string emailAddress)
    {
        var valid = true;
        var isnotblank = false;

        var email = emailAddress.Trim();
        if (email.Length > 0)
        {
            // Email Address Cannot start with period.
            // Name portion must be at least one character
            // In the Name, valid characters are:  a-z 0-9 ! # _ % & ' " = ` { } ~ - + * ? ^ | / $
            // Cannot have period immediately before @ sign.
            // Cannot have two @ symbols
            // In the domain, valid characters are: a-z 0-9 - .
            // Domain cannot start with a period or dash
            // Domain name must be 2 characters.. not more than 256 characters
            // Domain cannot end with a period or dash.
            // Domain must contain a period
            isnotblank = true;
            valid = Regex.IsMatch(email, Regex.EmailPattern, RegexOptions.IgnoreCase) &&
                !email.StartsWith("-") &&
                !email.StartsWith(".") &&
                !email.EndsWith(".") && 
                !email.Contains("..") &&
                !email.Contains(".@") &&
                !email.Contains("@.");
        }

        return (valid && isnotblank);
    }

    /// <summary>
    /// Validates the string is an Email Address or a delimited string of email addresses...
    /// </summary>
    /// <param name="emailAddress"></param>
    /// <returns>bool</returns>
    public static bool IsValidEmailAddressDelimitedList(this string emailAddress, char delimiter = ';')
    {
        var valid = true;
        var isnotblank = false;

        string[] emails = emailAddress.Split(delimiter);

        foreach (string e in emails)
        {
            var email = e.Trim();
            if (email.Length > 0 && valid) // if valid == false, no reason to continue checking
            {
                isnotblank = true;
                if (!email.IsValidEmailAddress())
                {
                    valid = false;
                }
            }
        }
        return (valid && isnotblank);
    }

    public class Regex
    {
        /// <summary>
        /// Set of Unicode Characters currently supported in the application for email, etc.
        /// </summary>
        public static readonly string UnicodeCharacters = "À-ÿ\p{L}\p{M}ÀàÂâÆæÇçÈèÉéÊêËëÎîÏïÔôŒœÙùÛûÜü«»€₣äÄöÖüÜß"; // German and French

        /// <summary>
        /// Set of Symbol Characters currently supported in the application for email, etc.
        /// Needed if a client side validator is being used.
        /// Not needed if validation is done server side.
        /// The difference is due to subtle differences in Regex engines.
        /// </summary>
        public static readonly string SymbolCharacters = @"!#%&'""=`{}~\.\-\+\*\?\^\|\/\$";

        /// <summary>
        /// Regular Expression string pattern used to match an email address.
        /// The following characters will be supported anywhere in the email address:
        /// ÀàÂâÆæÇçÈèÉéÊêËëÎîÏïÔôŒœÙùÛûÜü«»€₣äÄöÖüÜß[a - z][A - Z][0 - 9] _
        /// The following symbols will be supported in the first part of the email address(before the @ symbol):
        /// !#%&'"=`{}~.-+*?^|\/$
        /// Emails cannot start or end with periods,dashes or @.
        /// Emails cannot have two @ symbols.
        /// Emails must have an @ symbol followed later by a period.
        /// Emails cannot have a period before or after the @ symbol.
        /// </summary>
        public static readonly string EmailPattern = String.Format(
            @"^([\w{0}{2}])+@{1}[\w{0}]+([-.][\w{0}]+)*\.[\w{0}]+([-.][\w{0}]+)*$",                     //  @"^[{0}\w]+([-+.'][{0}\w]+)*@[{0}\w]+([-.][{0}\w]+)*\.[{0}\w]+([-.][{0}\w]+)*$",
            UnicodeCharacters,
            "{1}",
            SymbolCharacters
        );
    }

1

Um Ihre E-Mail-ID zu validieren, können Sie einfach eine solche Methode erstellen und verwenden.

    public static bool IsValidEmail(string email)
    {
        var r = new Regex(@"^([0-9a-zA-Z]([-\.\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})$");
        return !String.IsNullOrEmpty(email) && r.IsMatch(email);
    }

Dies gibt True / False zurück. (Gültige / ungültige E-Mail-ID)


1

Dies ist mein bisheriger Lieblingsansatz:

public static class CommonExtensions
{
    public static bool IsValidEmail(this string thisEmail)
        => !string.IsNullOrWhiteSpace(thisEmail) &&
           new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$").IsMatch(thisEmail);
}

Verwenden Sie dann die erstellte Zeichenfolgenerweiterung wie folgt:

if (!emailAsString.IsValidEmail()) throw new Exception("Invalid Email");

1

Lass es mich wissen, WENN es nicht funktioniert :)

public static bool isValidEmail(this string email)
{

    string[] mail = email.Split(new string[] { "@" }, StringSplitOptions.None);

    if (mail.Length != 2)
        return false;

    //check part before ...@

    if (mail[0].Length < 1)
        return false;

    System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"^[a-zA-Z0-9_\-\.]+$");
    if (!regex.IsMatch(mail[0]))
        return false;

    //check part after @...

    string[] domain = mail[1].Split(new string[] { "." }, StringSplitOptions.None);

    if (domain.Length < 2)
        return false;

    regex = new System.Text.RegularExpressions.Regex(@"^[a-zA-Z0-9_\-]+$");

    foreach (string d in domain)
    {
        if (!regex.IsMatch(d))
            return false;
    }

    //get TLD
    if (domain[domain.Length - 1].Length < 2)
        return false;

    return true;

}

1

Hier ist unser Regex für diesen Fall:

@"^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}" +
                       @"\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\" +
                       @".)+))([a-zA-Z]{2,6}|[0-9]{1,3})(\]?)$",

Es gibt drei Teile, die überprüft werden. Der letzte ist wahrscheinlich der, den Sie brauchen. der spezifische Begriff {2,6} gibt Ihnen die minimale / maximale Länge der TLD am Ende an. HTH


0

Versuchen Sie den folgenden Code:

using System.Text.RegularExpressions;
if  (!Regex.IsMatch(txtEmail.Text, @"^[a-z,A-Z]{1,10}((-|.)\w+)*@\w+.\w{3}$"))
        MessageBox.Show("Not valid email.");

0

STRING-SUCHE UNTER VERWENDUNG DER REGEX-METHODE IN C #

Wie validiere ich eine E-Mail durch regulären Ausdruck?

string EmailPattern = @"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*";
if (Regex.IsMatch(Email, EmailPattern, RegexOptions.IgnoreCase))
{
    Console.WriteLine("Email: {0} is valid.", Email);
}
else
{
    Console.WriteLine("Email: {0} is not valid.", Email);
}

Verwenden Sie die Referenz- String.Regex () -Methode


0

1

^[\w!#$%&'*+\-/=?\^_`{|}~]+(\.[\w!#$%&'*+\-/=?\^_`{|}~]+)*@((([\-\w]+\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\.){3}[0-9]{1,3}))$

2

^(([^<>()[\]\\.,;:\s@\""]+(\.[^<>()[\]\\.,;:\s@\""]+)*)|(\"".+\""))@((\[[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

Ich denke, Ihr Caret und Ihr Dollarzeichen sind Teil des Problems. Sie sollten auch den regulären Ausdruck ein wenig ändern. Ich verwende das nächste @ "[:] + ([\ w .-] +) @ ([\ w -.]) + ((. (\ w) {2,3}) +) "


Wenn Sie das Ergebnis Trim (':')
ABMoharram

0

Regex-E-Mail-Muster:

^(?:[\\w\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`\\{\\|\\}\\~]+\\.)*[\\w\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`\\{\\|\\}\\~]+@(?:(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9\\-](?!\\.)){0,61}[a-zA-Z0-9]?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9\\-](?!$)){0,61}[a-zA-Z0-9]?)|(?:\\[(?:(?:[01]?\\d{1,2}|2[0-4]\\d|25[0-5])\\.){3}(?:[01]?\\d{1,2}|2[0-4]\\d|25[0-5])\\]))$

0

Ich habe Regex.IsMatch () verwendet.

Zunächst müssen Sie die nächste Anweisung hinzufügen:

using System.Text.RegularExpressions;

Dann sieht die Methode so aus:

private bool EmailValidation(string pEmail)
{
                 return Regex.IsMatch(pEmail,
                 @"^(?("")("".+?(?<!\\)""@)|(([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));
}

Aufgrund meiner Logik ist es eine private Methode, aber Sie können die Methode als statisch in eine andere Ebene wie "Dienstprogramme" einfügen und von dort aus aufrufen, wo Sie sie benötigen.


0

Es gibt keinen perfekten regulären Ausdruck, aber dieser ist ziemlich stark, denke ich, basierend auf dem Studium von RFC5322 . Und mit der C # -String-Interpolation ist es meiner Meinung nach auch ziemlich einfach zu folgen.

const string atext = @"a-zA-Z\d!#\$%&'\*\+-/=\?\^_`\{\|\}~";
var localPart = $"[{atext}]+(\\.[{atext}]+)*";
var domain = $"[{atext}]+(\\.[{atext}]+)*";
Assert.That(() => EmailRegex = new Regex($"^{localPart}@{domain}$", Compiled), 
Throws.Nothing);

Geprüft mit NUnit 2.x.


0

Ich habe eine FormValidationUtils-Klasse erstellt, um E-Mails zu validieren:

public static class FormValidationUtils
{
    const string ValidEmailAddressPattern = "^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$";

    public static bool IsEmailValid(string email)
    {
        var regex = new Regex(ValidEmailAddressPattern, RegexOptions.IgnoreCase);
        return regex.IsMatch(email);
    }
}

0

E-Mail-Validierung mit Regex

    string pattern = @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z";

    //check first string
   if (Regex.IsMatch(EmailId1 , pattern))
   {    
       //if email is valid
        Console.WriteLine(EmailId1+ " is a valid Email address ");
   }

Quelle: E-Mail-Validierung c #

Validierung ohne Regex mit MailAddress.MailAddress (String) Klassenkonstruktors

public bool IsEmailValid(string emailaddress)
{
 try
 {
    MailAddress m = new MailAddress(emailaddress);
    return true;
 }
 catch (FormatException)
 {
    return false;
 }
}

Dies wird nicht übereinstimmen me@localhost. Bitte schauen Sie sich diese Seiten an: TLD-Liste ; gültige / ungültige Adressen ; Regex für RFC822 E-Mail-Adresse
Toto
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.