ईमेल पते को मान्य करने के लिए सी # कोड

Question

यह मान्य करने के लिए सबसे सुरुचिपूर्ण कोड क्या है कि एक स्ट्रिंग एक मान्य ईमेल पता है?

Comments

नियमित-expressions.info/email.html

— दोपहर रेशम

फिल हैक के लेख पर एक नज़र डालें: " मुझे पता था कि एक ईमेल पते को कैसे मान्य किया जाए जब तक मैं आरएफसी नहीं

— पढ़ता

कई अन्य महत्वपूर्ण मान्यताएं हैं न केवल स्ट्रिंग, यह जांचना बेहतर है कि क्या ईमेल इस smtp सर्वर पर मौजूद है या उपयोगकर्ता किसी भी ईमेल में प्रवेश कर रहा है .. आदि या एपीआई का उपयोग करने के लिए जो आपको ईमेल को सुनिश्चित करने के लिए हैंडल करेगा। यह ver-email.com की

— अमृत ​​मैगी

Microsoft docs.microsoft.com/en-us/dotnet/standard/base-types/…

— किशोर

आप github.com/jstedfast/EmailValidation लाइब्रेरी का उपयोग कर सकते हैं ।

— मोहम्मद रज़ा सद्रेडिनी

Answer 1

इस बारे में क्या?

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

स्पष्ट करने के लिए, सवाल पूछ रहा है कि क्या एक विशेष स्ट्रिंग ई-मेल पते का एक वैध प्रतिनिधित्व है, न कि यह कि क्या ई-मेल पता एक संदेश भेजने के लिए एक वैध गंतव्य है। उसके लिए, एकमात्र वास्तविक तरीका यह है कि पुष्टि करने के लिए एक संदेश भेजें।

ध्यान दें कि ई-मेल पते पहले की तुलना में अधिक क्षमा करने वाले हैं। ये सभी पूरी तरह से मान्य रूप हैं:

• कॉग @ पहिया
• "नारंगी कोहरा" @ example.com
• 123@$.xyz

अधिकांश उपयोग के मामलों के लिए, एक गलत "अमान्य" आपके उपयोगकर्ताओं और भविष्य के झूठे "वैध" की तुलना में भविष्य के प्रमाण के लिए बहुत खराब है। यहाँ एक लेख है जो इस प्रश्न का स्वीकृत उत्तर हुआ करता था (यह उत्तर तब से हटा दिया गया है)। इसमें समस्या का समाधान करने के लिए बहुत अधिक विवरण और कुछ अन्य विचार हैं।

उपयोगकर्ता अनुभव के लिए अभी भी विवेक जांच प्रदान करना एक अच्छा विचार है। ई-मेल पते को मान्य मानते हुए, आप ज्ञात शीर्ष-स्तरीय डोमेन की तलाश कर सकते हैं, एमएक्स रिकॉर्ड के लिए डोमेन की जांच कर सकते हैं, सामान्य डोमेन नामों से वर्तनी त्रुटियों की जांच कर सकते हैं (gmail.cmo), आदि। फिर उपयोगकर्ता को देते हुए एक चेतावनी प्रस्तुत करें। कहने का मौका "हाँ, मेरा मेल सर्वर वास्तव में ईमेल पते के रूप में अनुमति देता है।"

---

व्यापार तर्क के लिए अपवाद हैंडलिंग का उपयोग करने के लिए, मैं सहमत हूं कि इससे बचने की चीज है। लेकिन यह उन मामलों में से एक है जहां सुविधा और स्पष्टता हठधर्मिता को पछाड़ सकती है।

इसके अलावा, यदि आप ई-मेल पते के साथ कुछ और करते हैं, तो संभवत: इसे एक MailAddress में शामिल करना है। यहां तक ​​कि अगर आप इस सटीक फ़ंक्शन का उपयोग नहीं करते हैं, तो आप संभवतः उसी पैटर्न का उपयोग करना चाहेंगे। आप अलग-अलग अपवादों को पकड़कर विशिष्ट प्रकार की विफलता की जांच कर सकते हैं : अशक्त, खाली, या अमान्य प्रारूप।

---

स्टुअर्ट की टिप्पणी के अनुसार, यह हमेशा सही वापसी के बजाय मूल स्ट्रिंग के साथ अंतिम पते की तुलना करता है। MailAddress "डिस्प्ले नेम" और "एड्रेस" भागों में रिक्त स्थान के साथ एक स्ट्रिंग पार्स करने की कोशिश करता है, इसलिए मूल संस्करण झूठी सूचनाओं को वापस कर रहा था।

---

--- आगे की पढाई ---

System.Net.Mail.MailAddress के लिए प्रलेखन

एक मान्य ईमेल पते के बारे में स्पष्टीकरण

Comments

दरअसल, यह गलत नहीं है। एक @ एक मान्य ई-मेल पता है। देखें haacked.com/archive/2007/08/21/… वास्तव में, यह विधि गलत परिणाम देती है यदि आप उद्धरणों के साथ एक पते का उपयोग करते हैं।

— Cogwheel

+1: यह सबसे अच्छा जवाब है यदि आप System.Net.Mailमेल भेजने के लिए कक्षाओं का उपयोग कर रहे हैं , जो कि आप शायद हैं। यदि आप .NET का उपयोग कर रहे हैं। हमने इस प्रकार के सत्यापन का उपयोग करने का निर्णय केवल इसलिए लिया क्योंकि ईमेल पते को स्वीकार करने का कोई मतलब नहीं है - यहां तक ​​कि वैध - जो हम मेल नहीं भेज सकते हैं।

— ग्रेग बीच

मैं अनुशंसा नहीं करता। यह सच है:IsValidEmail("this is not valid@email$com");

— काकाशी

बहुत सारी समस्याएँ प्रतीत होती हैं क्योंकि MailAddress DisplayName को भी पार्स करने की कोशिश करता है, इसलिए "single [e-mail]" पार्सन्स to DisplayName "single" और एड्रेस "[e-mail]"। इसके लिए एक फिक्स है: रिटर्न (Addr.Address == ईमेल);

— स्टुअर्ट

यह मुझे पंसद है; मुझे वास्तविक कल्पना से अधिक प्रतिबंधक होने की मजबूरी नहीं है। झूठी नकारात्मकता से झूठी नकारात्मक तरीके खराब होते हैं ("आपका क्या मतलब है कि मेरा ई-मेल अमान्य है? ")

— केसी

Answer 2

यह एक पुराना प्रश्न है, लेकिन मैंने SO पर पाए गए सभी उत्तर, जिनमें अधिक हाल के हैं, इस एक के समान उत्तर दिए हैं। हालाँकि, .net 4.5 / MVC 4 में आप एक ईमेल एड्रेस वेलिडेशन को System.ComponentModel.DataAnnotations से [EmailAddress] एनोटेशन जोड़कर जोड़ सकते हैं, इसलिए मैं सोच रहा था कि मैं सिर्फ अंतर्निहित कार्यक्षमता का उपयोग क्यों नहीं कर सका। सामान्य तौर पर नेट।

यह काम करने लगता है, और मुझे लगता है कि यह काफी सुरुचिपूर्ण है:

using System.ComponentModel.DataAnnotations;

class ValidateSomeEmails
{
    static void Main(string[] args)
    {
        var foo = new EmailAddressAttribute();
        bool bar;
        bar = foo.IsValid("[e-mail]");         //true
        bar = foo.IsValid("[e-mail]");       //true
        bar = foo.IsValid("[e-mail]");     //true
        bar = foo.IsValid("[e-mail]");      //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("[e-mail]"))
            bar = true;    
    }
}

Comments

कूल, हालांकि यह निराशाजनक है कि एमएस इसे अपने स्वयं के प्रलेखन से सहमत नहीं कर सकता है । यह [e-mail]9

— Casey

ध्यान दें कि उदाहरण के लिए, EmailAddressAttributeकम से कम अनुमेय है System.Net.Mail.MailAddress, MailAddressएक TLD के लिए एक पते को स्वीकार करता है। बस कुछ ध्यान में रखना है अगर आपको यथासंभव अनुमति देने की आवश्यकता है।

— एरोनिनस

@Cogwheel: यदि उत्तर टिप्पणियों में कहीं निहित है, तो संभवतः इसे उत्तर के मुख्य निकाय में जोड़ा जाना चाहिए।

— होफनरविले

@होफर्नविल: यह मुख्य निकाय में है, लेकिन टिप्पणियां विस्तृत हैं। यदि आपका लक्ष्य अपने उपयोगकर्ताओं को क्रोधित नहीं करना है तो आपकी मान्यता युक्ति से अधिक प्रतिबंधात्मक नहीं होनी चाहिए। सही मायने में यह सत्यापित करने का एकमात्र तरीका है कि एक ई-मेल वैध है या नहीं, एक परीक्षण संदेश भेजना है।

— कोगव्हील

कृपया ध्यान दें कि foo.IsValid(null);रिटर्न true।

— मूत्र त्याग

Answer 3

मैं इस एकल लाइनर विधि का उपयोग करता हूं जो मेरे लिए काम करता है-

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

टिप्पणियों के अनुसार, यह "विफल" होगा यदि source(ईमेल पता) शून्य है।

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

Comments

यह मेरे लिए काम नहीं करता है; मुझे लगता है, "'डेटा एनोटेशन' मौजूद नहीं है ... क्या आप असेंबली का संदर्भ याद कर रहे हैं?" मुझे कौन सा संदर्भ जोड़ने की आवश्यकता है?

— बी क्ले शैनन

यदि स्रोत अशक्त है तो यह सही होगा। देखें msdn.microsoft.com/en-us/library/hh192424 "सही है अगर निर्दिष्ट मान या शून्य है; अन्यथा, गलत है।"

— जौ

एक बेहतर संस्करण:public static Boolean IsValidMailAddress(this String pThis) => pThis == null ? false : new EmailAddressAttribute().IsValid(pThis);

— सेबस्टियन हॉफमैन

या इससे भी बेहतर:public static bool IsValidEmailAddress(this string address) => address != null && new EmailAddressAttribute().IsValid(address);

— पेट्रीक मालालैंडर

मुझे नहीं लगता कि इस विस्तार पद्धति को चुपचाप falseअशक्त तारों के लिए वापस जाना चाहिए । इसलिए मैं (और भी बेहतर) ++ संस्करण का प्रस्ताव करता हूं public static bool IsValidEmailAddress(this string address) => new EmailAddressAttribute().IsValid(address ?? throw new ArgumentNullException());:। अब मैं जाऊंगा और बेहतर बेहतर संस्करण के सुधारित चर्च को ढूंढूंगा।

— मार्क.2377

Answer 4

.net 4.5 ने System.ComponentModel.DataAnnotations.EmailAddressAttribute को जोड़ा

आप EmailAddressAttribute के स्रोत को ब्राउज़ कर सकते हैं , यह रेगेक्स है जो इसे आंतरिक रूप से उपयोग करता है:

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

Comments

दुर्भाग्य से EmaillAddressAttribute अनुमति देता है B जो ईमेल के लिए एक वैध चरित्र नहीं है

— BZ

@BZ हाँ यह है। आपको क्यों लगता है कि यह नहीं है?

— केसी

@Chad अनुदान: यह एक C # संस्करण है। क्या आप कृपया VB.Net एक प्रदान कर सकते हैं। क्योंकि वह \\ जैसे \ _ \ _ या एक स्ट्रिंग वर्बेटिम प्रदान कर सकता है।

— निखिल अग्रवाल

यह काम करता है, लेकिन यह मत भूलो RegexOptions.IgnoreCaseक्योंकि यह पैटर्न स्पष्ट रूप से बड़े अक्षरों की अनुमति नहीं देता है!

— क्रिस 12

ध्यान दें कि रेगेक्स बहुत जानबूझकर है: "यह विशेषता सर्वर साइड ईमेल सत्यापन को jquery सत्यापन के बराबर प्रदान करता है, और इसलिए समान नियमित अभिव्यक्ति साझा करता है"।

— ओहद श्नाइडर

Answer 5

मैंने # 1 से फिल का जवाब लिया और इस क्लास को बनाया। इसे इस तरह से कॉल करें:bool isValid = Validator.EmailIsValid(emailString);

यहाँ वर्ग है:

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

Comments

बस एक छोटा सा, लेकिन मैं उपयोग करूंगा: वापसी ((string .sNullOrEmpty (emailAddress)) && ValidEmailRegex.IsMatch (emailAddress);

— मार्क

यह सिर्फ हॉरर है :)

— अलेक्जेंड्रू डिकु

Answer 6

व्यक्तिगत रूप से, मैं कहूंगा कि आपको यह सुनिश्चित करना चाहिए कि वहाँ एक @ प्रतीक है, संभवतः ए के साथ। चरित्र। ऐसे कई रीजैक्स हैं जिनका आप अलग-अलग शुद्धता का उपयोग कर सकते हैं, लेकिन मुझे लगता है कि इनमें से अधिकांश वैध ईमेल पते छोड़ देते हैं, या जिनके माध्यम से अमान्य हैं। यदि लोग एक नकली ईमेल पते पर रखना चाहते हैं, तो वे एक नकली में डाल देंगे। यदि आपको यह सत्यापित करने की आवश्यकता है कि ईमेल पता वैध है, और वह व्यक्ति उस ईमेल पते के नियंत्रण में है, तो आपको उन्हें एक विशेष कोडित लिंक के साथ एक ईमेल भेजने की आवश्यकता होगी ताकि वे यह सत्यापित कर सकें कि यह वास्तव में एक वास्तविक पता है।

Comments

मुझे व्यक्तिगत रूप से लगता है कि आपको इससे थोड़ा अधिक सत्यापन करना चाहिए। किसी की बॉबी टेबल का ईमेल पता या इससे भी बदतर कोशिश करने के लिए बाध्य है।

— ल्यूक क्विनाने

यदि आप तैयार कथनों का उपयोग कर रहे हैं तो बॉबी टेबल के ईमेल पते में क्या गलत है। हम वैध ईमेल पतों के बारे में बात कर रहे हैं, अन्य चीजों के बारे में नहीं जिनका किसी मान्य ईमेल पते से कोई लेना-देना नहीं है, जैसे कि SQL क्वेरी को ठीक से कैसे करें ताकि आपको SQL इंजेक्शन की समस्या न हो।

— किबी

मुझे लगता है कि आप नहीं जानते कि कोई व्यक्ति वहां क्या डालेगा, लेकिन एक दुर्भावनापूर्ण व्यक्ति जानता है कि मूल्य अंततः आपके मेल सिस्टम में खिलाया जा सकता है। मैं सिर्फ गहराई में रक्षा करना पसंद करूंगा और थोड़ा सख्त हो जाऊंगा।

— ल्यूक क्विनाने

यह मेल सिस्टम के लिए चिंता का विषय है। मैं पूरी तरह से मान्य ईमेल पतों को खारिज करने के आसपास नहीं जाऊंगा क्योंकि यह किसी अन्य प्रणाली के साथ सुरक्षा मुद्दा हो सकता है। यदि आपके सभी ईमेल सर्वर को सुरक्षा समस्याओं के कारण विकृत ईमेल पता है, तो आपको संभवतः किसी अन्य सर्वर पर स्विच करना चाहिए।

— किबीए

गहराई में रक्षा केवल तभी काम करती है जब आपके सुरक्षा प्याज का प्रत्येक स्तर सड़ा हुआ न हो। एक सड़ी हुई परत का मतलब है कि आप पूरे प्याज को खराब कर रहे हैं। "[e-mail]" को अस्वीकार करना क्योंकि आप सूर्य के µ-कानून एन्कोडिंग में कमजोरियों से बचाव करना चाहते हैं, इससे कोई मतलब नहीं है, क्या यह होता है? हंसो मत, यह मेरे साथ हुआ है। मैं यहां टिप्पणी कर रहा हूं कि मेडिकेयर ऑस्ट्रेलिया ".au" पते, केवल ".com" की अनुमति नहीं देता है। मार्क स्वानसन को भी पढ़ें, "ईमेल को कैसे मान्य न करें", mdswanson.com/blog/2013/10/14/…-

— मैनीकडी

Answer 7

मुझे लगता है कि सबसे अच्छा तरीका इस प्रकार है:

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

आप एक सामान्य वर्ग में इस स्थिर कार्य कर सकते हैं।

Comments

यह उत्तर डोमेन भाग में TLD वाले पते को स्वीकार नहीं करता है।

— सिमोन

Answer 8

संक्षिप्त और सटीक कोड

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

Comments

समाधान के लिए धन्यवाद

— जैक गजानन

: मैं सार्वजनिक स्थिर करने के लिए IsValidEmail (इस स्ट्रिंग ईमेल) bool सार्वजनिक स्थिर बदलने के लिए bool IsValidEmail (स्ट्रिंग ईमेल) इससे बचने के लिए किया था stackoverflow.com/questions/10412233/...

— प्रबंधक डौग

@Goner डौग, यह फ़ंक्शन इस तरह काम करेगा। (बूल झंडा = EmailAddress.IsValidEmail ())

— नवीन

जब मेरे प्रपत्र में संकलक समस्याएँ पैदा करने से बचने के लिए "THIS" को हटाने की आवश्यकता होती है।

— गोनेर डग

@ गोनेर डग, इसकी कार्यशीलता इस तरह काम करेगी। स्ट्रिंग ईमेल = "[e-mail]"; if (email.IsValidEmail ()) {झूठी; } और {वापसी सच;}

— नवीन

Answer 9

.Net के बिल्ट इन मेथड्स का उपयोग करना सबसे सुरुचिपूर्ण तरीका है।

ये तरीके:

• आजमाए और परखे गए। इन विधियों का उपयोग मेरी अपनी व्यावसायिक परियोजनाओं में किया जाता है।

• आंतरिक अभिव्यक्तियों का नियमित रूप से उपयोग करें, जो विश्वसनीय और तेज़ हैं।

• Microsoft द्वारा C # के लिए बनाया गया। पहिया को सुदृढ़ करने की कोई आवश्यकता नहीं है।

• एक बूल परिणाम लौटें। सही का अर्थ है कि ईमेल वैध है।

.Net 4.5 और अधिक के उपयोगकर्ताओं के लिए

इस संदर्भ को अपनी परियोजना में जोड़ें:

System.ComponentModel.DataAnnotations

अब आप निम्नलिखित कोड का उपयोग कर सकते हैं:

(new EmailAddressAttribute().IsValid("[e-mail]"));

उपयोग का उदाहरण

यहाँ घोषित करने के कुछ तरीके हैं:

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;

}

... और कोड उन्हें कार्रवाई में प्रदर्शित कर रहा है:

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

}

इसके अलावा, यह उदाहरण:

• किसी एकल स्ट्रिंग को 0, एक या कई ईमेल पतों को अर्ध-बृहदान्त्र द्वारा फैलाया जाने के बाद से कल्पना से परे विस्तारित किया जाता है ;।
• स्पष्ट रूप से दर्शाता है कि EmailAddressAttribute ऑब्जेक्ट के IsValid विधि का उपयोग कैसे करें।

वैकल्पिक, .net के एक संस्करण के उपयोगकर्ताओं के लिए 4.5 से कम है

उन स्थितियों के लिए जहां .net 4.5 उपलब्ध नहीं है, मैं निम्नलिखित समाधान का उपयोग करता हूं:

विशेष रूप से, मैं उपयोग करता हूं:

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;

}

Comments

@ThomasAyoub मैंने एक EmailAddressAttribute उत्तर नहीं देखा है, और कोई जवाब नहीं जो इनपुट पर एक चेक के साथ नए MailAddress () का उपयोग करता है टिप्पणियों को पढ़े बिना स्वीकृत उत्तर बहुत गलत है। नई MailAddress ("Foobar [e-mail]") यह साबित करती है।

— Jan

@ जान fwiw, माणिक ने EmailAddressAttributeसिर्फ चार महीनों के भीतर ही नाइकरलेस को हरा दिया , हालांकि यह इस nullमुद्दे को पकड़ता है ।

— रफिन

Answer 10

ईमानदार होने के लिए, उत्पादन कोड में, सबसे अच्छा मैं एक @प्रतीक के लिए जांच करता हूं ।

मैं पूरी तरह से ईमेल को मान्य करने की जगह पर नहीं हूं। आप जानते हैं कि मैं कैसे देखता हूं कि क्या यह वास्तव में वैध था? अगर यह भेजा गया। अगर यह नहीं हुआ, यह बुरा है, अगर यह किया, जीवन अच्छा है। मुझे बस इतना ही पता होना चाहिए।

Answer 11

मैं इस regex को केवल @ चिह्न से अधिक कुछ के लिए जाँच करने और अजीब बढ़त के मामलों को स्वीकार करने के बीच एक अच्छा व्यापार मानता हूं:

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

यह कम से कम आपको @ चिह्न के आसपास कुछ डाल देगा, और कम से कम सामान्य दिखने वाला डोमेन डाल देगा।

Comments

मैं उसी रेगेक्स के साथ आया था;) यह हालांकि अवैध चरचरों की अनुमति देता है

— स्टीफन

यह उत्तर डोमेन भाग में TLD स्वीकार नहीं करता है।

— सिमोन

@ सीमोन के पास संभवतः किसी के भी डोमेन पते में TLD के साथ ईमेल पते नहीं हैं, हालांकि प्रैक्टिस में: serverfault.com/a/721929/167961 इन टिप्पणियों पर ध्यान दें, जो इन दिनों प्रतिबंधित हो सकते हैं

— मैथ्यू लॉक

@MatthewLock यह एक इंट्रानेट पता हो सकता है? पसंद है bob@companyinternal?

— सिमोन

@ वास्तविक जीवन में कोई भी वास्तव में उस योजना का उपयोग नहीं करता है?

— मैथ्यू लॉक

Answer 12

ईमेल पता सत्यापन उतना आसान नहीं है जितना यह लग सकता है। यह वास्तव में सिर्फ एक नियमित अभिव्यक्ति का उपयोग कर एक ईमेल पते को पूरी तरह से प्रमाणित करने के लिए सैद्धांतिक रूप से असंभव है।

इस विषय पर चर्चा और FParsec का उपयोग करके एफ # कार्यान्वयन के लिए मेरे ब्लॉग पोस्ट को देखें। [/ shameless_plug]

Comments

मैंने आपको वैकल्पिक दृष्टिकोणों की सूची पसंद की; बहुत ही रोचक।

— ल्यूक क्विनाने

दिलचस्प आलेख। लेकिन गंभीरता से जो टिप्पणी डाल रहा है, और उस पर नेस्टेड, ईमेल पते में?

— मैथ्यू लॉक

@ मैथ्यू मुझे नहीं पता कि IETF ने इसकी अनुमति क्यों दी है, लेकिन यह संभव है , इसलिए पूरी तरह से सत्यापन को ध्यान में रखना होगा।

— मौरिसियो शेफ़र

Answer 13

यहाँ मेरा जवाब है - फिल का समाधान एकल अक्षर डोमेन के लिए विफल रहता है जैसे "कोई @q.com"। मानो या न मानो, कि प्रयोग किया जाता है =) (उदाहरण के लिए, सेंचुरीलिंक जाता है)।

फिल का जवाब भी केवल पीसीआरई मानक के साथ काम करने वाला है ... इसलिए सी # इसे ले जाएगा, लेकिन जावास्क्रिप्ट बम होने वाला है। यह जावास्क्रिप्ट के लिए बहुत जटिल है। तो आप mvc सत्यापन विशेषताओं के लिए फिल के समाधान का उपयोग नहीं कर सकते।

यहाँ मेरा regex है। यह MVC सत्यापन विशेषताओं के साथ अच्छी तरह से काम करेगा।
- @ से पहले सब कुछ सरलीकृत है, ताकि कम से कम जावास्क्रिप्ट काम करेगा। जब तक एक्सचेंज सर्वर मुझे ५.१.३ नहीं देता है तब तक मैं यहाँ आराम से सत्यापन को आराम कर रहा हूँ। - @ के बाद सब कुछ फिल के एकल डोमेन डोमेन के लिए संशोधित है।

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

System.net.mail MailMessage () का उपयोग करने का सुझाव देने वाले लोगों के लिए, वह चीज़ लचीली है। ज़रूर, C # ईमेल को स्वीकार करेगा, लेकिन फिर जैसे ही आप ईमेल भेजने की कोशिश करेंगे, एक्सचेंज सर्वर 5.1.3 रनटाइम त्रुटि के साथ बम होगा।

Comments

लगता है कि सबसे अच्छा विचारशील / उचित / realworld जवाब, धन्यवाद राल्फ!

— फेटी

यह अब तक का सबसे अच्छा जवाब है! मैं एक बुरे समाधान पर विश्वास नहीं कर सकता जो basket@ballएक मान्य ईमेल पते के रूप में स्वीकार करता है और साथ ही उन सभी उत्थानों के लिए सही उत्तर प्राप्त किया है। फिर भी धन्यवाद!

— डिजास्टरकिड

धन्यवाद यह सबसे अच्छा समाधान है और इसे स्वीकार किया जाना चाहिए।

— बैट_प्रोग्रामर

Answer 14

यदि आप वास्तव में हैं और मेरा मतलब है कि वास्तव में जानना चाहते हैं कि क्या कोई ईमेल पता मान्य है ... तो इसे साबित करने के लिए मेल एक्सचेंजर से पूछें, कोई regex की आवश्यकता नहीं है। अनुरोध करने पर मैं कोड प्रदान कर सकता हूं।

सामान्य चरण इस प्रकार हैं: 1. क्या ईमेल पते में डोमेन नाम भाग है? (@ @ 0 का सूचकांक) 2. DNS क्वेरी का उपयोग करके पूछें कि क्या डोमेन में एक मेल एक्सचेंजर है 3. मेल एक्सचेंजर के लिए tcp कनेक्शन खोलें। smtp प्रोटोकॉल का उपयोग करते हुए, सर्वर को एक संदेश खोलें, जो कि ईमेल पता का उपयोग करते हुए 5 के रूप में होता है। सर्वर की प्रतिक्रिया को पार्स करें। 6. संदेश छोड़ दें यदि आपने इसे दूर किया है, तो सब कुछ अच्छा है।

यह वैसा ही है जैसा आप सोच सकते हैं, बहुत महंगा समय है और यह smtp पर निर्भर करता है, लेकिन यह काम करता है।

Comments

क्या आपने उन इंटरफेस के लिए फेक, स्टब्स और / या मोक्स बनाए?

— मार्क ए

यह काम नहीं करेगा। एक ईमेल पते को सत्यापित करने के लिए smtp प्रोटोकॉल का उपयोग नहीं किया गया है। यह मेल सर्वर पर सक्षम करने के लिए बुरा व्यवहार माना जाता है क्योंकि स्पैमर्स उस कार्यक्षमता का उपयोग करते हैं।

— चाड ग्रांट

मैं आपके सुझाव को बिंदु 2 तक रखूंगा। ज्ञात डोमेन नाम पैटर्न के लिए जाँच करने की तुलना में अधिक भविष्य के प्रमाण।

— सिमोन

नाइटपैकिंग, लेकिन परिभाषित करें "एक मेल एक्सचेंजर है" ? यदि कोई MX रिकॉर्ड मौजूद नहीं है, तो SMTP को RFC2821 / 5321 के अनुसार A / AAAA रिकॉर्ड में वापस आना चाहिए। यदि कोई MX रिकॉर्ड मौजूद है, तो यह अभी भी संकेत नहीं दे सकता है कि एक मेल एक्सचेंजर मौजूद है (RFC7505)। वास्तव में, एकमात्र तरीका उन्हें कॉल-टू-एक्शन लिंक के साथ एक मेल भेजना है, और उनके जवाब के लिए प्रतीक्षा करें ...

— jimbobmcgee

Answer 15

सामान्यतया, ईमेल पतों को मान्य करने के लिए एक नियमित अभिव्यक्ति एक आसान बात नहीं है; इस लेखन के समय, एक ईमेल पते के वाक्यविन्यास को अपेक्षाकृत अधिक संख्या में मानकों का पालन करना चाहिए और उन सभी को एक नियमित अभिव्यक्ति के भीतर लागू करना व्यावहारिक रूप से अक्षम्य है!

मैं अत्यधिक आप हमारी कोशिश करने के लिए सुझाव EmailVerify.NET , एक परिपक्व नेट पुस्तकालय जो निम्नलिखित ईमेल पते को मान्य कर सकते सभी वर्तमान IETF मानक की (RFC 1123, RFC 2821, RFC 2822, आरएफसी 3696, आरएफसी 4291, आरएफसी 5321 और RFC 5322) , संबंधित डीएनएस रिकॉर्ड का परीक्षण करता है, जांचता है कि क्या लक्ष्य मेलबॉक्स संदेश स्वीकार कर सकते हैं और यह भी बता सकते हैं कि दिया गया पता डिस्पोजेबल है या नहीं।

अस्वीकरण: मैं इस घटक के लिए मुख्य डेवलपर हूं।

Comments

प्रभावशाली! "अगला, यह दिए गए ईमेल पते के लिए जिम्मेदार मेल एक्सचेंजर से संपर्क करने की कोशिश करता है और एक असली एसएम सर्वर का अनुकरण करते हुए, उस सर्वर के साथ एक नकली एसएमटीपी संवाद शुरू करता है। इस तरह यह सुनिश्चित करता है कि सर्वर पते के लिए ईमेल को संभाल सकता है। कई एसएमटीपी सर्वर वास्तव में। स्पैमर्स के खिलाफ सुरक्षा के रूप में झूठे सकारात्मक जवाब दें: इस मुद्दे को दूर करने के लिए, .NET के लिए EmailVerify आखिरकार अलग-अलग मनगढ़ंत पतों के साथ कई बार लक्ष्य मेल एक्सचेंजर को क्वेरी करने का प्रयास करता है। "

— मैथ्यू लॉक

धन्यवाद,

— @MatthewLock

अच्छा है, लेकिन मैं केवल भुगतान किए गए संस्करण देखता हूं। समुदाय / OpenSource संस्करण के लिए कोई योजना?

— ओहद श्नाइडर

@OhadSchneider हाँ: हम अपनी SaaS ईमेल सत्यापन सेवा , वैरिफ़लिया के माध्यम से हमारी ईमेल सत्यापन तकनीक का एक निःशुल्क संस्करण दे रहे हैं । वेरीफालिया .NET सहित प्रमुख सॉफ्टवेयर विकास प्लेटफार्मों के लिए मुफ्त और ओपन-सोर्स SDKs के साथ आता है ।

— एफ्रन कोबिसी

Answer 16

For the simple email like [e-mail], 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;
        }

Comments

यह एक मान्य ईमेल पते के रूप में [e-mail] को मान्य करने में विफल रहेगा।

— रे चेंग

Answer 17

यदि आप फ़्लुएंविलेडेशन का उपयोग कर रहे हैं तो आप इस रूप में कुछ सरल लिख सकते हैं:

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;

Answer 18

@Cogwheel उत्तर के लिए थोड़ा संशोधन

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

Comments

यह मदद करने के लिए प्रतीत नहीं होता है ... Console.WriteLine(MailAddress("asdf@asdf.").Address);"asdf @ asdf" आउटपुट, जो मान्य नहीं है।

— लैंगडन

.net के पास वैध की अपनी परिभाषा है। संबंधित चर्चा

— प्रतीक्षा

Answer 19

यहां बहुत सारे मजबूत जवाब हैं। हालांकि, मेरा सुझाव है कि हम एक कदम पीछे ले जाएँ। @Cogwheel ने उत्तर दिया https://stackoverflow.com/a/1374644/388267 । फिर भी, यह एक थोक सत्यापन परिदृश्य में महंगा हो सकता है, अगर ईमेल पते के कई सत्यापन अमान्य हैं। मेरा सुझाव है कि हम उसके तर्क-पकड़ने वाले ब्लॉक में प्रवेश करने से पहले थोड़ा सा तर्क देते हैं। मुझे पता है कि RegEx का उपयोग करके निम्नलिखित कोड लिखा जा सकता है लेकिन नए डेवलपर्स के लिए इसे समझना महंगा हो सकता है। यह मेरा ट्वोपेंस मूल्य है:

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

Answer 20

@Cogwheel से सबसे अधिक मतदान का जवाब सबसे अच्छा जवाब है, लेकिन मैंने trim()स्ट्रिंग विधि को लागू करने की कोशिश की है, ताकि यह सभी उपयोगकर्ता के सफेद स्थान को स्ट्रिंग प्रारंभ से अंत तक ट्रिम कर देगा। पूर्ण उदाहरण के लिए कोड bellow की जाँच करें-

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

Comments

इसका जोखिम यह है कि आप स्रोत की तुलना में एक अलग ई-मेलड्रेस को मान्य कर रहे हैं, जिससे आपको लगता है कि आप इस (इस मामले में) निर्दिष्ट ई-मेलड्रेस के अनमैरिड संस्करण को मेल कर सकते हैं। एक बेहतर तरीका यह होगा कि एक अलग विधि बनाई जाए SanitizeEmail(string email), जिससे उस विधि के परिणाम को मान्य किया जा सके और ईमेल को भेजा जा सके।

— मार्को डे ज़ीउव

Answer 21

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

Answer 22

ईमेल स्ट्रिंग की जाँच करें सही प्रारूप या गलत प्रारूप है 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";
        }
    }

Answer 23

/ "नई EmailAddressAttribute ();" बनाने में उपयोग किए गए आंतरिक रेगेक्स का उपयोग करना; घटक .Net4.5 >>> System.ComponentModel.DataAnnotations का उपयोग करके; // एक ईमेल पते को सत्यापित करने के लिए ...... परीक्षण और कार्य करना।

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

इसके अलावा, आप इसका उपयोग कर सकते हैं:

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

Comments

यह इस ईमेल के लिए सही कहता है: "[e-mail]ö" और यह मैन्डरिल एपीआई में त्रुटि फेंकता है

— मॉन्स्टरमोरपीजी

सबसे पहले, ईमेल मान्य wrt [e-mail] या [e-mail] है .... ईमेल में अंतिम वर्ण "ö" को छोड़कर सभी वैध स्ट्रिंग और मानदंड हैं और आप आसानी से इस तरह के चरित्र को मान्य करने के लिए एक सरल शर्त जोड़ सकते हैं । दूसरा, उस mandrill एपीआई त्रुटि के बारे में निश्चित नहीं है, आप अपने उपयोग की विधि को सत्यापित कर सकते हैं bcos मैंने कुछ अन्य पर्यावरण / एपीआई के इस सत्यापन का उपयोग किया है और यह मेरे लिए अच्छा रहा है।

— आइना एडेमोला सी

Answer 24

मैंने Poyson 1 के जवाब को इस तरह से स्वीकार किया:

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

Answer 25

ईमेलड की पहचान करने का सरल तरीका वैध है या नहीं।

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

Answer 26

C # में regex में संस्कृति समस्या है, बल्कि js। इसलिए हमें ईमेल जांच के लिए यूएस मोड में रेगेक्स का उपयोग करने की आवश्यकता है। यदि आप ECMAScript मोड का उपयोग नहीं करते हैं, तो आपकी भाषा विशेष वर्ण AZ में regex के साथ है।

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)

Answer 27

मैंने इस regex का उपयोग करना समाप्त कर दिया, क्योंकि यह सफलतापूर्वक कॉमा, कमेंट, यूनिकोड वर्ण और IP (v4) डोमेन पतों को मान्य करता है।

मान्य पते होंगे:

"" @ example.org

(comment)[e-mail]

тест@example.org

ტესტი @ example.org

परीक्षण @ [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,}))$";

Answer 28

रेगेक्स का उपयोग किए बिना एक सरल (जो मुझे इसकी खराब पठनीयता के लिए पसंद नहीं है):

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

उदाहरण:

• IsValidEmail("@b.com") // false
• IsValidEmail("a@.com") // false
• IsValidEmail("a@bcom") // false
• IsValidEmail("a.b@com") // false
• IsValidEmail("a@b.") // false
• IsValidEmail("a [e-mail]") // false
• IsValidEmail("a@b c.com") // false
• IsValidEmail("[e-mail]") // true
• IsValidEmail("[e-mail]") // true
• IsValidEmail("[e-mail]") // true
• IsValidEmail("a@123.45.67.89") // true

यह सरल होना है और इसलिए यह दुर्लभ मामलों से संबंधित नहीं है जैसे कि ब्रैकेटेड डोमेन वाले ईमेल जिनमें रिक्त स्थान होते हैं (आमतौर पर अनुमति दी जाती है), IPv6 पते वाले ईमेल आदि।

Answer 29

यहाँ आपके प्रश्न का उत्तर है कि आप जाँच करें।

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;

   }

}

Answer 30

@Cogwheel के उत्तर के आधार पर मैं एक संशोधित समाधान साझा करना चाहता हूं जो SSIS और "स्क्रिप्ट घटक" के लिए काम करता है:

1. "स्क्रिप्ट कंपोनेंट" को अपने डेटा फ्लो कनेक्ट में रखें और फिर खोलें।
2. "इनपुट कॉलम" अनुभाग में उस फ़ील्ड को सेट करें जिसमें "ReadWrite" (उदाहरण के लिए 'fieldName') में ई-मेल पते शामिल हैं।
3. "स्क्रिप्ट" अनुभाग पर वापस जाएँ और "स्क्रिप्ट संपादित करें" पर क्लिक करें। फिर कोड खुलने के बाद आपको इंतजार करना होगा।

4. इस कोड को सही विधि में रखें:

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

फिर आप सभी अमान्य रिकॉर्ड या जो भी आप करना चाहते हैं उसे फ़िल्टर करने के लिए एक सशर्त विभाजन का उपयोग कर सकते हैं।