Regex ईमेल सत्यापन

Question

मैं इसका उपयोग करता हूं

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

ईमेल को मान्य करने के लिए regexp

([\w\.\-]+)- यह पहले स्तर के डोमेन के लिए है (कई अक्षर और संख्या, बिंदु और हाइफ़न भी)

([\w\-]+)- यह दूसरे स्तर के डोमेन के लिए है

((\.(\w){2,3})+) - और यह अन्य स्तर के डोमेन (3 से अनंत तक) के लिए है जिसमें एक बिंदु और 2 या 3 शामिल हैं शाब्दिक

इस रेक्सक्स में क्या गलत है?

संपादित करें: यह "[e-mail]" ईमेल से मेल नहीं खाता

Comments

RFCs 5321 और 5322 - आनंद द्वारा निर्दिष्ट के अलावा, आप मान्य वर्णों को शामिल नहीं कर रहे हैं ।

— ब्रैड क्रिस्टी

के संभावित डुप्लिकेट क्या ईमेल पते मान्य के लिए सबसे अच्छा नियमित अभिव्यक्ति है?

— आरबी।

मुझे लगता है कि आपको हमें बताना होगा कि क्या गलत है और फिर यहाँ अन्य लोग आपको गलत चीज़ को ठीक करने में मदद कर सकते हैं।

— उवे कीम

आपको एक समस्या है -> आपको लगता है कि 'रेगेक्स' -> अब आपको 2 समस्याएं हैं ;-)

— जैकब कोनकी

बस अपने regex के बारे में एक टिप्पणी। इन नए .am Amsterdam, .info और अन्य डोमेन के साथ regex होना चाहिए:@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,})+)$""

— Ton Snoei

Answer 1

TLD की तरह .Museum इस तरह से मेल नहीं खाते हैं, और कुछ अन्य लंबे TLD हैं। इसके अलावा, आप MailAddress वर्ग का उपयोग करके ईमेल पतों को मान्य कर सकते हैं क्योंकि Microsoft यहाँ नोट में बताता है :

ईमेल पते को मान्य करने के लिए एक नियमित अभिव्यक्ति का उपयोग करने के बजाय, आप System.Net.Mail.Mail.Address वर्ग का उपयोग कर सकते हैं। यह निर्धारित करने के लिए कि कोई ईमेल पता मान्य है, MailAddress.MailAddress (स्ट्रिंग) वर्ग निर्माता को ईमेल पता दें।

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

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

यह आपको बहुत अधिक सिरदर्द से बचाता है क्योंकि आपको लिखना नहीं है (या किसी और को समझने की कोशिश) regex।

Comments

यह दोहरे बिंदुओं को नहीं पकड़ सका ".." और न ही इनलाइन रिक्त स्थान ""। मैं

— रेगीज़ के साथ जाऊंगा

इसके बावजूद यह एक लोकप्रिय जवाब है। यह सही नहीं है, कम से कम दो अमान्य प्रारूपों को पकड़ने में असफल रहें: "एबीसी @ example.com", "Abc..123 @ example.com"

— sean717

@ sean717: RFC और / या लिंक देखें । मैं मानता हूं कि आपके उदाहरण शायद वास्तविक दुनिया में काम नहीं करेंगे, लेकिन यह उन्हें अमान्य नहीं बनाता है।

— डैन पिकेलमैन

यह इनपुट को मान्य करने के लिए कोशिश कर रहा है या नहीं का उपयोग कर रहा है अनुशंसित अभ्यास नहीं है। रेगेक्स निश्चित रूप से जाने का बेहतर तरीका है।

— mrt

-1 कोड का खराब टुकड़ा। अपवादों को पकड़ना खेतों को मान्य करने का तरीका नहीं है।

— ken2k

Answer 2

मुझे लगता है कि @"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$"काम करना चाहिए।
आपको इसे लिखने की आवश्यकता है

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

चेतावनी दी है कि अगर यह विफल हो जाएगा:

1. @प्रतीक के बाद एक उपडोमेन है ।

2. आप TLD का उपयोग 3 से अधिक की लंबाई के साथ करते हैं, जैसे कि .info

Comments

[e-mail] को वैध मानता है। अमान्य होना चाहिए।

— मथियस एफ

मुझे विश्वास है कि यह नए टीएलडी के जारी होने पर विफल हो जाएगा, क्योंकि आपके पास अब टीएलडी के 3 से अधिक अक्षर हो सकते हैं।

— एरोनल्स

यह रेगेक्स "[e-mail]" को वैध मानता है।

— जिज्ञासा

gmail.com.in.in.in.in एक पूरी तरह से मान्य डोमेन नाम है, इसलिए मैं यह नहीं देख सकता कि इसकी अनुमति क्यों नहीं दी जानी चाहिए?

— लार्वा

@Larsw के साथ सहमत रेगेक्स का उपयोग नहीं किया जाना चाहिए

— बोरिस सोकोलोव

Answer 3

मेरे पास उपयोग किए जाने वाले ईमेल पतों की जाँच के लिए एक अभिव्यक्ति है।

चूंकि उपरोक्त में से कोई भी मेरी तरह छोटा या सटीक नहीं था, मैंने सोचा कि मैं इसे यहां पोस्ट करूंगा।

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

अधिक जानकारी के लिए इसके बारे में यहाँ पढ़ें: C # - ईमेल नियमित अभिव्यक्ति

इसके अलावा, यह ईमेल सिंटैक्स पर आधारित RFC वैधता के लिए जाँच करता है, न कि यह कि क्या ईमेल वास्तव में मौजूद है। यह परीक्षण करने का एकमात्र तरीका है कि एक ईमेल वास्तव में मौजूद है, ईमेल भेजने और ईमेल करने के लिए उपयोगकर्ता को सत्यापित करना होगा कि उन्होंने लिंक पर क्लिक करके या टोकन दर्ज करके ईमेल प्राप्त किया है।

फिर फेंकने वाले डोमेन होते हैं, जैसे Mailinator.com, और ऐसे। यह इस बात को सत्यापित करने के लिए कुछ भी नहीं करता है कि ईमेल फेंकने वाले डोमेन से है या नहीं।

Comments

Thats एक मैं देख रहा था - thanx! दोनों डबल डॉट्स ".." और व्हाइट स्पेस "लेता है।"

— बेनी स्कोबर्ग

मैंने इकाई परीक्षणों के लिए अपनी नियमित अभिव्यक्ति की परियोजना को अद्यतन किया और मैंने एक-दो बग भी तय किए: C # - ईमेल नियमित अभिव्यक्ति rhyous.com/2010/06/15/csharp-email- अनियमित-expression

— Rhyous

नई TLDs के साथ, हमें शायद तीसरी पंक्ति में [a-zA-Z] {2,4} को {0} के साथ बदलना होगा और फिर एक string.format (पैटर्न, pipSeparatedAllowedTlds) करना होगा, जहां pipepeparatedAllowedTlds को बनाना होगा। इस फाइल के माध्यम से पुनरावृति: data.iana.org/TLD/tlds-alpha-by-domain.txt

— Rhyous

पार्थ। क्या आप मुझे बता सकते हैं कि आपके ईमेल से RFC नियम क्या है? क्योंकि क्या लगता है। RFC के अनुसार, यह वैध है !!!! यदि आप URL in.in को खरीदते हैं, तो आप यह ईमेल पता बना सकते हैं। समझना?

— रिहायस

वास्तव में, ऐसा लगता है कि मैंने पहले से ही अपने github पर यहां अपडेट किया है: github.com/rhyous/EmailRegEx । हालाँकि, \ w में अंडरस्कोर शामिल हो सकता है, इसलिए मुझे इसे सटीकता के लिए संपादित करना पड़ सकता है।

— Rhyous

Answer 4

मुझे इसके लिए MSDN पर अच्छा दस्तावेज़ मिला।

कैसे करें: सत्यापित करें कि स्ट्रिंग मान्य ईमेल प्रारूप में हैं http://msdn.microsoft.com/en-us/library/01escwtf.aspx (देखें कि यह कोड इंटरनेट डोमेन नामों के लिए गैर- ASCII वर्णों के उपयोग का भी समर्थन करता है। )

.Net 2.0 / 3.0 के लिए और .Net 3.5 और उच्चतर के लिए 2 कार्यान्वयन हैं।
2.0 / 3.0 संस्करण है:

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

इस पद्धति पर मेरे परीक्षण देते हैं:

Invalid: @majjf.com
Invalid: A@b@[e-mail]
Invalid: Abc.example.com
Valid: [e-mail]
Valid: [e-mail]
Invalid: js*@proseware.com
Invalid: js@proseware..com
Valid: [e-mail]
Valid: [e-mail]
Invalid: ma@@jjf.com
Invalid: ma@jjf.
Invalid: ma@jjf..com
Invalid: ma@jjf.c
Invalid: ma_@jjf
Invalid: ma_@jjf.
Valid: [e-mail]
Invalid: -------
Valid: [e-mail]
Valid: [e-mail]
Valid: [e-mail]
Valid: [e-mail]
Invalid: [e-mail]9
Valid: j_9@[129.126.118.1]
Valid: [e-mail]
Invalid: js#[e-mail]
Invalid: [e-mail]9
Invalid: [e-mail]9
Valid: [e-mail]
Valid: [e-mail]
Valid: [e-mail]
Valid: [e-mail]
Invalid: [e-mail]
Invalid: [e-mail]
Valid: [e-mail]
Valid: [e-mail]
Valid: [e-mail]
Valid: [e-mail]
Valid: [e-mail]
Valid: [e-mail]
Valid: [e-mail]

Comments

मैच नहीं करता[me]@whatever.museum

— पूर्ण

अमान्य: Abc.example.com हाँ, यह सही ढंग से काम करता है, हालाँकि, यह "toms.email। @ Gmail.com" है; काम नहीं करता है

— टॉम स्टिकेल

एक प्लस चिह्न जोड़ना था: `@" ^ ([\ w - \ _ +] +) @ (([[0-9] {1,3} \ _। [0-9] {1,3} \ _। [0-9] {1,3} \) |। (। ([\ w -] \) +)) ([a-zA-जेड] {2,4} | [0-9] {1, 3}) ()?) $ "` 11 चार पर छोड़ दिया] Google और हॉटमेल उपनाम इस संकेत से पहले पहले खंड में प्लस साइन के लिए अनुमति देते हैं।

— हेंक जे म्यूलकैंप

यह ऊपर के समान ही है। मान्य ईमेल पते के रूप में "[e-mail]" की अनुमति ... !!

— जिज्ञासा

@ParthTrivedi आप क्यों जोर देते हैं कि [e-mail]वैध ईमेल पता नहीं है?

— Ivaylo Slavov

Answer 5

निम्न कोड जीथब पर Microsoft के डेटा एनोटेशन कार्यान्वयन पर आधारित है और मुझे लगता है कि यह ईमेल के लिए सबसे पूर्ण सत्यापन है:

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

Comments

एक पेशेवर स्रोत (दूसरों के खिलाफ कुछ भी नहीं) से इसे प्राप्त करके अच्छा लगा; की सराहना की।

— निकोलस पीटरसन

यह सबसे अच्छा रेगेक्स होना चाहिए क्योंकि यह आरएफसी 5321 और 5322 को मान्य करता है। यह कुछ यूनिट परीक्षण को याद करता है।

— टॉक्सीन

ईमेल पते के अंत में डॉट कैप्चर नहीं करता है।

— सेलोरियो

Answer 6

यह RFC 5321 और 5322 की सभी आवश्यकताओं को पूरा नहीं करता है, लेकिन यह निम्नलिखित परिभाषाओं के साथ काम करता है।

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

नीचे कोड है

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[] {
        "[e-mail]",
        "[e-mail]",
        "[e-mail]",
        "[e-mail]",
        "[e-mail]",
        "[e-mail]",
        "[e-mail]",
        "[e-mail]",
        "[e-mail]",
        "[e-mail]",
        "[e-mail]",
};
var invalidEmails = new[] {
        "Abc.example.com",     // No `@`
        "A@b@[e-mail]",   // multiple `@`
        "[e-mail]",      // 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 `@`
        "[e-mail]",         // nothing after `.`
        "[e-mail]",         // 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));
}

Comments

यह अभिव्यक्ति वैध पते से मेल नहीं खाती है !#$%&'*+-/=?^_। {|} ~ @ example.com` या यह एकDörte@Sörensen.example.com

— TS

Answer 7

सर्वश्रेष्ठ ईमेल सत्यापन 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])?

और यह उपयोग है: -

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

Answer 8

आकार के लिए इसे पहनकर देखें:

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

Answer 9

यह कोशिश करो, यह मेरे लिए काम कर रहा है:

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(".");
    }
}

Answer 10

यह रेगेक्स पूरी तरह से काम करता है:

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

Answer 11

यह टिप्पणी में दूसरों द्वारा उल्लिखित अमान्य ईमेल को रोकता है:

[e-mail]
[e-mail]
name@hotmail
[e-mail]
[e-mail]

यह डबल डॉट्स वाले ईमेल को भी रोकता है:

hello..world@example..com

कई अमान्य ईमेल पतों के साथ इसका परीक्षण करने का प्रयास करें जैसा कि आप पा सकते हैं।

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}$).*");
}

C # में नियमित अभिव्यक्ति का उपयोग करके मान्य ईमेल पता देखें ।

Comments

यह मेरे सभी अमान्य ईमेल पतों के लिए गलत है। दुर्भाग्य से, कई वैध ईमेल पतों के लिए भी गलत रिटर्न देता है।

— मार्क

Answer 12

ईएफ 6 विशेषता आधारित ई-मेल सत्यापन का उपयोग क्यों नहीं किया जाता है?

जैसा कि आप ऊपर देख सकते हैं, ई-मेल के लिए रेगेक्स सत्यापन में हमेशा कुछ छेद होता है। यदि आप EF6 डेटा एनोटेशन का उपयोग कर रहे हैं, तो आप आसानी से विश्वसनीय और मजबूत ई-मेल सत्यापन प्राप्त कर सकते हैं EmailAddress डेटा एनोटेशन विशेषता के । मुझे ई-मेल के लिए पहले इस्तेमाल किए गए रेगेक्स सत्यापन को हटाना पड़ा जब मुझे मोबाइल डिवाइस विशिष्ट ई-मेल ई-मेल फ़ील्ड पर विफलता मिली। जब ई-मेल सत्यापन के लिए उपयोग किए जाने वाले डेटा एनोटेशन विशेषता, मोबाइल पर समस्या हल हो गई थी।

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

Answer 13

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

Answer 14

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

मैं ईमेल पते को मान्य करने के लिए उपरोक्त कोड का उपयोग करता हूं।

Answer 15

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

Comments

हालांकि यह कोड प्रश्न का उत्तर दे सकता है, लेकिन यह कोड क्यों और / या इस बारे में अतिरिक्त संदर्भ प्रदान करता है कि यह प्रश्न इसके दीर्घकालिक मूल्य में सुधार करता है

— AStopher

Answer 16

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

Answer 17

यह एक ईमेल सत्यापनकर्ता बनाने के लिए कई प्रयास कर चुका है जो ईमेल के लिए दुनिया भर की आवश्यकताओं को पकड़ता है।

एक्सटेंशन विधि जिसे आप कॉल कर सकते हैं:

myEmailString.IsValidEmailAddress();

Regex पैटर्न स्ट्रिंग आप कॉल करके प्राप्त कर सकते हैं:

var myPattern = Regex.EmailPattern;

कोड (ज्यादातर टिप्पणियां):

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

Answer 18

अपनी ईमेल आईडी को मान्य करने के लिए, आप बस ऐसी विधि बना सकते हैं और उसका उपयोग कर सकते हैं।

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

यह True / False लौटाएगा। (मान्य / अमान्य ईमेल आईडी)

Answer 19

यह मेरा अब तक का सबसे पसंदीदा तरीका है:

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

फिर बनाए गए स्ट्रिंग एक्सटेंशन का उपयोग करें जैसे:

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

Answer 20

बस मुझे पता है अगर यह काम नहीं करता है :)

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;

}

Answer 21

यहाँ इस मामले के लिए हमारे Regex है:

@"^([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})(\]?)$",

इसके तीन भाग हैं, जो चीकू हैं। पिछले एक को आप की जरूरत है। विशिष्ट शब्द {2,6} आपको अंत में TLD की न्यूनतम / अधिकतम लंबाई दर्शाता है। HTH

Answer 22

निम्नलिखित कोड का प्रयास करें:

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

Answer 23

C # में STRING खोज का उपयोग करें

नियमित अभिव्यक्ति द्वारा ईमेल को कैसे मान्य किया जाए?

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

संदर्भ String.Regex () विधि का उपयोग करें

Answer 24

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

Answer 25

मुझे लगता है कि आपका कैरेट और डॉलर संकेत समस्या का हिस्सा है। आपको रेगेक्स को थोड़ा संशोधित करना चाहिए, मैं अगले @ "[:] + ([\ w-।] +) @) ([\ w -।] + का उपयोग करता हूं। ((। (\ w) {2,3}) +) "

Comments

जब आप परिणाम ट्रिम (':') का उपयोग करते हैं

— एबीमोहरम

Answer 26

Regex ईमेल पैटर्न:

^(?:[\\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])\\]))$

Answer 27

मैं Regex.IsMatch () का उपयोग कर रहा हूं।

सबसे पहले आपको अगला कथन जोड़ने की आवश्यकता है:

using System.Text.RegularExpressions;

तब विधि इस प्रकार दिखती है:

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

यह मेरे तर्क के कारण एक निजी तरीका है लेकिन आप इस विधि को किसी अन्य लेयर जैसे "यूटिलिटीज" में स्थिर रख सकते हैं और जहां जरूरत हो वहां से कॉल कर सकते हैं।

Answer 28

कोई सही नियमित अभिव्यक्ति नहीं है, लेकिन यह एक बहुत मजबूत है, मुझे लगता है, RFC5322 के अध्ययन पर आधारित है । और सी # स्ट्रिंग प्रक्षेप के साथ, पालन करने के लिए बहुत आसान है, मुझे लगता है, साथ ही साथ।

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

के साथ वेट किया NUnit 2.x।

Answer 29

मैंने ईमेल सत्यापित करने के लिए एक FormValidationUtils वर्ग बनाया है:

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

Answer 30

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

स्रोत: ईमेल सत्यापन c #

MailAddress.MailAddress (स्ट्रिंग) क्लास कंस्ट्रक्टर का उपयोग करके रेगेक्स के बिना सत्यापन

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

Comments

यह मेल नहीं खाएगा me@localhost। कृपया, इन साइटों पर एक नज़र डालें: TLD सूची ; वैध / अमान्य पते ; RFC822 ईमेल पते के लिए regex

— पूर्ण