it-swarm.com.de

Regex Email Validierung

Ich benutze das

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

regexp um die E-Mail zu validieren

([\w\.\-]+) - Dies ist für die First-Level-Domain (viele Buchstaben und Zahlen, auch Punkt und Bindestrich)

([\w\-]+) - Dies ist eine Domain der zweiten Ebene

((\.(\w){2,3})+) - und dies gilt für Domänen anderer Ebenen (von 3 bis unendlich), die einen Punkt und 2 oder 3 Literale enthalten

was ist los mit diesem Regex?

BEARBEITEN: Es stimmt nicht mit der E-Mail "[email protected]" überein

196
Sergey

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

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 nicht den regulären Ausdruck eines anderen Benutzers schreiben (oder versuchen, ihn zu verstehen) müssen.

332
Alex

Ich denke @"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$" sollte funktionieren.
Du musst es so 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 fehlschlägt, wenn:

  1. Es gibt eine Subdomain nach dem @ Symbol.

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

92
Avinash

Ich habe einen Ausdruck zum Überprüfen von E-Mail-Adressen, die ich verwende.

Da keines der oben genannten Elemente so kurz oder so 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 # - E-Mail-regulärer Ausdruck

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

Dann gibt es wegwerfbare Domains wie Mailinator.com und so weiter. Auf diese Weise wird nicht überprüft, ob eine E-Mail von einer Einwegdomäne stammt oder nicht.

64
Rhyous

Ich fand Nizza Dokument auf MSDN dafür.

Gewusst wie: Überprüfen, ob die Zeichenfolgen ein gültiges E-Mail-Format aufweisen 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.)

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: [email protected]@[email protected]
Invalid: Abc.example.com
Valid: [email protected]
Valid: [email protected]
Invalid: js*@proseware.com
Invalid: [email protected]
Valid: [email protected]
Valid: [email protected]
Invalid: [email protected]@jjf.com
Invalid: [email protected]
Invalid: [email protected]
Invalid: [email protected]
Invalid: [email protected]
Invalid: [email protected]
Valid: [email protected]
Invalid: -------
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Invalid: [email protected]
Valid: [email protected][129.126.118.1]
Valid: [email protected]
Invalid: js#[email protected]
Invalid: [email protected]
Invalid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Invalid: [email protected]
Invalid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
35
mr.baby123

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[] {
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
};
var invalidEmails = new[] {
        "Abc.example.com",     // No `@`
        "[email protected]@[email protected]",   // multiple `@`
        "[email protected]",      // continuous multiple dots in name
        "[email protected]",            // only 1 char in extension
        "[email protected]",         // continuous multiple dots in domain
        "[email protected]@jjf.com",         // continuous multiple `@`
        "@majjf.com",          // nothing before `@`
        "[email protected]",         // nothing after `.`
        "[email protected]",         // nothing after `_`
        "[email protected]",             // no domain extension 
        "[email protected]",            // nothing after `_` and .
        "[email protected]",             // 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));
}
10
Maheep

Der folgende Code basiert auf Microsoft Data Annotations-Implementierung auf github und ich denke, es ist 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);
}
8
CodeArtist

Bester E-Mail-Validierungs-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])?

Und es ist die 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);
7
Tejas Bagade

Versuchen Sie dies für 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);
}
6
camainc

Probieren Sie es aus, 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
Tarek El-Mallah

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

[email protected]
[email protected]
[email protected]
[email protected]
[email protected]

Es werden auch E-Mails mit doppelten Punkten verhindert:

[email protected]

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 E-Mail-Adresse mit regulärem Ausdruck in C # validieren .

4
Geek

Dieser reguläre Ausdruck 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
Luca Ziegler

Warum nicht die E-Mail-Validierung mit EF6-Attributen 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 Attribut EmailAddress Datenanmerkungen auf einfache Weise eine zuverlässige und stärkere E-Mail-Validierung erzielen. Ich musste die zuvor für E-Mails verwendete Regex-Überprüfung entfernen, wenn im E-Mail-Eingabefeld ein spezifischer Regex-Fehler aufgetreten war. Als das Datenanmerkungsattribut für die E-Mail-Überprüfung 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; }
new System.ComponentModel.DataAnnotations.EmailAddressAttribute().IsValid(input)
2
Clement

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, die Sie erhalten, indem Sie Folgendes aufrufen:

var myPattern = Regex.EmailPattern;

Der Code (meist 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 protected]") &&
                !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}])[email protected]{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
Jason Williams
public static bool ValidateEmail(string str)
{                       
     return Regex.IsMatch(str, @"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");
}

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

1
Ramesh

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 String-Erweiterung wie folgt:

if (!emailAsString.IsValidEmail()) throw new Exception("Invalid Email");
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);
    }

Das wird True/False zurückgeben. (Gültige/ungültige E-Mail-ID)

1
Palak Patel
string patternEmail = @"(?<email>\[email protected]\w+\.[a-z]{0,3})";
Regex regexEmail = new Regex(patternEmail);
1
StefanL19
   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+\\-.%][email protected][\\w\\-.]+\\.[A-Za-z] {2,4}[\\W]*,{1}[\\W]*)*([\\w+\\-.%][email protected][\\w\\-.]+\\.[A-Za-z]{2,4})[\\W]*$");
        return validateEmail.IsMatch(strEmail);
    }
1
sindhu jampani

Lass es mich wissen WENN es funktioniert nicht :)

public static bool isValidEmail(this string email)
{

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

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

    //check part before [email protected]

    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
Roni Tovi

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}) +) "

0
ABMoharram

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
Leelu Halwan

STRINGSUCHE MIT REGEX-METHODE IN C #

Wie validiere ich eine E-Mail mit einem 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
Manish

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

public static class FormValidationUtils
{
    const string ValidEmailAddressPattern = "^[A-Z0-9._%+-][email protected][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
Waqar UlHaq

1

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

2

^(([^<>()[\]\\.,;:\[email protected]\""]+(\.[^<>()[\]\\.,;:\[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
Rae Lee

Regex-E-Mail-Muster:

^(?:[\\w\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`\\{\\|\\}\\~]+\\.)*[\\w\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`\\{\\|\\}\\~][email protected](?:(?:(?:[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])\\]))$

Ich habe das 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 in einer anderen Ebene wie "Dienstprogramme" als statisch ablegen und von dort aufrufen, wo Sie sie benötigen.

0
GreatNews

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, denke ich, auch ziemlich einfach zu befolgen.

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
mwpowellhtx