Kod C# do weryfikacji adresu e-mail

To stare pytanie, ale wszystkie odpowiedzi, które znalazłem na SO, w tym nowsze, są podobne do tej. Jednak w. Net 4.5 / MVC 4 możesz dodać weryfikację adresu e-mail do formularza, dodając adnotację [EmailAddress] z systemu.ComponentModel.DataAnnotations, więc zastanawiałem się, dlaczego nie mogę po prostu użyć wbudowanej funkcjonalności z. Net w ogóle.

To chyba działa i wydaje mi się być dość eleganckie:

using System.ComponentModel.DataAnnotations;

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

. NET 4.5 dodany System.ComponentModel.DataAnnotations.EmailAddressAttribute

Możesz przeglądać źródło EmailAddressAttribute , jest to Regex, którego używa wewnętrznie:

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

Wziąłem odpowiedź Phila z # 1 i stworzyłem tę klasę. Nazwij to tak: bool isValid = Validator.EmailIsValid(emailString);

Oto klasa:

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

Używam tej metody jednowarstwowej, która działa za mnie -

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

Osobiście powiedziałbym, że powinieneś się upewnić, że jest tam symbol@, z ewentualnie . charakter. Istnieje wiele wyrażeń regularnych, których możesz użyć o różnej poprawności, ale myślę, że większość z nich pomija prawidłowe adresy e-mail lub przepuszcza nieprawidłowe. Jeśli ludzie chcą wprowadzić fałszywy adres e-mail, wprowadzą fałszywy. Jeśli chcesz zweryfikować, że adres e-mail jest legalny i że dana osoba ma kontrolę nad tym adresem e-mail, musisz wysłać im wiadomość e-mail. e-mail ze specjalnym zakodowanym linkiem, aby mogli zweryfikować, że rzeczywiście jest to prawdziwy adres.

Myślę, że najlepszy sposób jest następujący:

    public static bool emailIsValid(string email)
    {
        string expresion;
        expresion = "\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
        if (Regex.IsMatch(email, expresion))
        {
            if (Regex.Replace(email, expresion, string.Empty).Length == 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }

Możesz mieć tę statyczną funkcję w klasie ogólnej.

Najbardziej eleganckim sposobem jest użycie wbudowanych metod. Net.

Te metody:

• Są wypróbowane i przetestowane. Metody te są wykorzystywane w moich własnych profesjonalnych projektach.

• Używaj wewnętrznie wyrażeń regularnych, które są niezawodne i szybkie.

• Stworzony przez Microsoft dla C#. Nie ma potrzeby odkrywania koła na nowo.

• Zwraca wynik bool. True oznacza, że wiadomość e-mail jest prawidłowa.

Dla użytkowników. Net 4.5 i greater

Dodaj to odniesienie do swojego projektu:

System.ComponentModel.DataAnnotations

Teraz możesz użyć następującego kodu:

(new EmailAddressAttribute().IsValid("[email protected]"));

Przykład użycia

Oto kilka metod deklarowania:

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;

}

...i Kod demonstrujący je w działaniu:

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

}

Dodatkowo przykład:

• wykracza poza specyfikację, ponieważ pojedynczy ciąg znaków zawiera 0, jeden lub wiele adresów e-mail sphered by a półkolonie ;.
• jasno pokazuje, jak używać metody IsValid obiektu EmailAddressAttribute.

Alternatywa dla użytkowników wersji. Net mniejszej niż 4.5

W sytuacjach, w których. Net 4.5 nie jest dostępny, używam następującego rozwiązania:

Konkretnie używam:

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;

}

Uważam ten regex za dobry kompromis między sprawdzaniem czegoś więcej niż tylko znaku@, a akceptowaniem dziwnych przypadków krawędzi:

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

To przynajmniej sprawi, że umieścisz coś wokół znaku @ i umieścisz przynajmniej normalnie wyglądającą domenę.

Krótki i dokładny kod

public static bool IsValidEmail(this string email)
        {
            const 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);
        }

Weryfikacja adresu e-mail nie jest tak łatwa, jak mogłoby się wydawać. Teoretycznie niemożliwe jest pełne zweryfikowanie adresu e-mail przy użyciu tylko wyrażenia regularnego.

Zajrzyj do mojego posta na blogu na temat dyskusji na ten temat i implementacji F# przy użyciu FParsec. [/shameless_plug]

Szczerze mówiąc, w kodzie produkcyjnym najlepiej sprawdzam symbol @.

Oto moja odpowiedź -- rozwiązanie Phila zawodzi dla domen jednoliterowych, takich jak "[email protected]". Wierzcie lub nie, to jest używane =) (idzie do centurylink, na przykład).

ODPOWIEDŹ Phila będzie działać tylko ze standardem PCRE... więc C# weźmie to, ale javascript będzie bomba. To zbyt skomplikowane dla javascript. Więc nie można użyć rozwiązania Phila dla atrybutów walidacji mvc.

Oto mój regex. To będzie działać dobrze z atrybutami walidacji MVC.
- Wszystko przed @ jest uproszczony, więc przynajmniej javascript będzie działał. Nie mam nic przeciwko sprawdzaniu poprawności pod warunkiem, że exchange server nie da mi 5.1.3. - Wszystko po @ jest rozwiązaniem Phila zmodyfikowanym dla domen jednoliterowych.

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

Dla osób sugerujących użycie system.net.mail MailMessage (), to jest sposób na elastyczność. Oczywiście, C# zaakceptuje e-mail, ale wtedy exchange server będzie bomb z 5.1.3 runtime error jak tylko spróbujesz wysłać e-mail.

Jeśli naprawdę i mam na myśli naprawdę chcesz wiedzieć, czy adres e-mail jest poprawny...poproś punkt wymiany poczty, aby to udowodnić, nie jest wymagane Wyrażenie regularne. Mogę podać kod na życzenie.

Ogólne kroki są następujące: 1. czy adres e-mail zawiera nazwę domeny? (indeks @ > 0) 2. korzystanie z zapytania DNS zapytaj, czy domena ma wymiennik poczty 3. otwarcie połączenia tcp z wymiennikiem poczty 4. korzystając z protokołu smtp, otwórz wiadomość do serwera, używając adresu e-mail jako odbiorcy 5. parse the server ' s odpowiedź. 6. Zamknij wiadomość, jeśli dotarłeś tak daleko, wszystko jest dobrze.

To jest jak można sobie wyobrazić, bardzo drogi czas mądry i opiera się na smtp, ale to działa.

Ogólnie rzecz biorąc, Wyrażenie regularne do walidacji adresów e-mail nie jest łatwą rzeczą do wymyślenia; w momencie pisania tego tekstu składnia adresu e-mail musi spełniać stosunkowo dużą liczbę standardów, a implementacja wszystkich z nich w wyrażeniu regularnym jest praktycznie niewykonalna!

Gorąco polecam wypróbować naszą EmailVerify.NET, Dojrzała biblioteka. NET, która może walidować adresy e-mail zgodnie z wszystkimi obecnych standardów IETF (RFC 1123, RFC 2821, RFC 2822, RFC 3696, RFC 4291, RFC 5321 i RFC 5322), testuje powiązane rekordy DNS, sprawdza, czy docelowe skrzynki pocztowe mogą przyjmować wiadomości, a nawet może stwierdzić, czy dany adres jest jednorazowy, czy nie.

Zastrzeżenie: jestem głównym programistą tego komponentu.

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

Sprawdź, czy łańcuch wiadomości e-mail ma właściwy format lub zły format przez 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";
        }
    }

/Użycie wewnętrznego wyrażenia regularnego używanego przy tworzeniu komponentu" new EmailAddressAttribute (); " w .Net4.5 > > > używanie systemu.ComponentModel.DataAnnotations; // Aby zweryfikować adres e-mail......Sprawdzony i działa.

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

Możesz również użyć tego:

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

Oto odpowiedź na twoje pytanie do sprawdzenia.

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;

   }

}

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

I succintified Poyson 1 ' s answer like so:

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

Napisałem funkcję, aby sprawdzić, czy e-mail jest poprawny, czy nie. Wydaje się, że działa dobrze dla mnie w większości przypadków.

Wyniki:

[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
dad@sds => FALSE
[email protected] => FALSE
[email protected] => FALSE
asd@[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE

[email protected] => TRUE
[email protected] => TRUE
[email protected] => TRUE
[email protected] => TRUE

Kod:

    private bool IsValidEmail(string email)
    {
        bool valid = false;
        try
        {
            var addr = new System.Net.Mail.MailAddress(email);
            valid = true;
        }
        catch
        {
            valid = false;
            goto End_Func;
        }

        valid = false;
        int pos_at = email.IndexOf('@');
        char checker = Convert.ToChar(email.Substring(pos_at + 1, 1));
        var chars = "qwertyuiopasdfghjklzxcvbnm0123456789";
        foreach (char chr in chars)
        {
            if (checker == chr)
            {
                valid = true;
                break;
            }
        }
        if (valid == false)
        {
            goto End_Func;
        } 

        int pos_dot = email.IndexOf('.', pos_at + 1);
        if(pos_dot == -1)
        {
            valid = false;
            goto End_Func;
        }

        valid = false;
        try
        {
            checker = Convert.ToChar(email.Substring(pos_dot + 1, 1));
            foreach (char chr in chars)
            {
                if (checker == chr)
                {
                    valid = true;
                    break;
                }
            }
        }
        catch
        {
            valid = false;
            goto End_Func;
        }

        Regex valid_checker = new Regex(@"^[[email protected]]*$");
        valid = valid_checker.IsMatch(email);
        if (valid == false)
        {
            goto End_Func;
        }

        List<int> pos_list = new List<int> { };
        int pos = 0;
        while (email.IndexOf('_', pos) != -1)
        {
            pos_list.Add(email.IndexOf('_', pos));
            pos = email.IndexOf('_', pos) + 1;
        }

        pos = 0;
        while (email.IndexOf('.', pos) != -1)
        {
            pos_list.Add(email.IndexOf('.', pos));
            pos = email.IndexOf('.', pos) + 1;
        }

        pos = 0;
        while (email.IndexOf('-', pos) != -1)
        {
            pos_list.Add(email.IndexOf('-', pos));
            pos = email.IndexOf('-', pos) + 1;
        }

        int sp_cnt = pos_list.Count();
        pos_list.Sort();
        for (int i = 0; i < sp_cnt - 1; i++)
        {
            if (pos_list[i] + 1 == pos_list[i + 1])
            {
                valid = false;
                break;
            }

            if (pos_list[i]+1 == pos_at || pos_list[i]+1 == pos_dot)
            {
                valid = false;
                break;
            }
        }

        if(valid == false)
        {
            goto End_Func;
        }

        if (pos_list[sp_cnt - 1] == email.Length - 1 || pos_list[0] == 0)
        {
            valid = false;
        }

    End_Func:;
        return valid;
    }

Prosty sposób identyfikacji emailid jest poprawny lub nie.

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

Jest problem Kultury w regex w C# a nie js. Więc musimy użyć regex w trybie US do sprawdzania poczty e-mail. Jeśli nie używasz trybu ECMAScript, znaki specjalne języka są implikowane W A - Z z wyrażeniem 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)

Skończyło się na użyciu tego wyrażenia regularnego, ponieważ pomyślnie sprawdza przecinki, komentarze, znaki Unicode i adresy domen IP (v4).

Poprawne adresy będą:

"" @example.org

(skomentuj)[email protected]

Тест@example.org

ტესტი@example.org

Test@[192.168.1.1]

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

Jeśli używasz FluentValidation możesz napisać coś tak prostego jak to:

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;

Na podstawie odpowiedzi @Cogwheel chcę podzielić się zmodyfikowanym rozwiązaniem, które działa na SSIS i "Script Component":

1. Umieść komponent "script" w przepływie danych connect, a następnie otwórz go.
2. w sekcji "Input Columns" ustaw pole zawierające adresy E-Mail na "ReadWrite" (w przykładzie 'fieldName').
3. wróć do sekcji "skrypt" i kliknij "Edytuj skrypt". Następnie musisz poczekać po otwarciu kodu.

4. Umieść to kod w prawidłowej metodzie:

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

Następnie możesz użyć warunkowego podziału, aby odfiltrować wszystkie nieprawidłowe rekordy lub cokolwiek chcesz zrobić.

Mała modyfikacja do @Cogwheel odpowiedz

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

1. W "try block" wyślij weryfikacyjną wiadomość e-mail.
2. aby użytkownik otworzył wiadomość e-mail i kliknął link weryfikujący, że wiadomość e-mail jest prawdziwa.

Dopóki ten proces nie zakończy się pomyślnie, przyjmuje się, że wiadomość e-mail jest nieprawidłowa.

Jakiś czas temu napisałem EmailAddressValidationAttribute, który powinien poprawnie walidować praktycznie każdy stosunkowo normalny adres e-mail formularza

local-part@domain

Jest to System.ComponentModel.DataAnnotations.ValidationAttribute, więc użycie jest naprawdę proste.

A od przekopania się przez wszystkie RFC i erraty i złożenia wszystkich bitów wymaganych do poprawnego wyliczenia wszystkich reguł jest...żmudne - w najlepszym wypadku! - Umieściłem kod źródłowy walidatora w moja odpowiedź na pytanie C# email address validation dla źródła kod.

Mój walidator nie jest idealny przez żaden odcinek wyobraźni, choć na początek, nie ma wbudowanego wsparcia dla wysyłania walidacji javascript po stronie klienta, choć nie byłoby to zbyt trudne, aby dodać to do. Z mojej odpowiedzi powyżej:

Oto atrybut walidacji, który napisałem. Sprawdza prawie każdy "surowy" e-mail adres, czyli ten o postaci local-part@domain . Nie obsługuje żadnego z drugi, więcej...creative konstruktów, na które pozwalają RFC (lista ta nie jest wyczerpujące za pomocą dowolnych środków):

• komentarze (np., [email protected] (work))
• cytowane ciągi znaków (tekst ucieczki, aby umożliwić znaki niedozwolone w atomie)
• literały domeny (np. foo@[123.45.67.012])
• bang-paths (aka source routing)
• adresy kątowe (np. John Smith <[email protected]>)
• folding whitespace
• znaki dwubajtowe w local-part lub domain (tylko 7-bitowe ASCII).
• itd.

Powinien akceptować prawie każdy adres e-mail, który można wyrazić w ten sposób

• [email protected]

Bez konieczności stosowania cudzysłowów ("), nawiasów kątowych ("") lub w nawiasach kwadratowych ([]).

Nie podejmuje się próby sprawdzenia, czy etykieta dns po prawej stronie w domenie jest prawidłowa TLD (domena najwyższego poziomu). Wynika to z faktu, że lista TLD jest teraz znacznie większa niż "big 6" (. com, .edu, .gov,. mil,. net,. org) plus 2-literowe kody krajów ISO. ICANN faktycznie aktualizuje listę TLD codziennie , choć podejrzewam, że lista nie zmienia się codziennie. Co więcej, [ICANN właśnie zatwierdził duże rozszerzenie ogólna przestrzeń nazw TLD] [2]). A niektóre adresy e-mail nie mają tego, co byś rozpoznał jako TLD (Czy wiesz, że postmaster@. jest teoretycznie poprawny i możliwy do wysłania? Poczta na ten adres powinien zostać dostarczony do postmastera strefy root DNS.)

Rozszerzenie regularnego wyrażenie wspierające literały domen nie powinno być zbyt trudne.