Jak sprawdzić poprawność formatowania adresu e-mail w środowisku .NET Framework?

Question

Chcę funkcja do sprawdzenia, że ​​ciąg jest sformatowany jak adres e-mail.

Co jest wbudowane w platformę .NET, aby to zrobić?

to działa:

Function IsValidEmailFormat(ByVal s As String) As Boolean 
    Try 
     Dim a As New System.Net.Mail.MailAddress(s) 
    Catch 
     Return False 
    End Try 
    Return True 
End Function 

Ale tam jest bardziej elegancki sposób?

Answer 1

Nie przejmuj się własną weryfikacją. .NET 4.0 znacznie poprawił sprawdzanie poprawności za pośrednictwem klasy MailAddress. Po prostu użyj MailAddress address = new MailAddress(input), a jeśli to wyrzuci, to nie jest prawidłowe. Jeśli istnieje jakakolwiek interpretacja danych wejściowych jako specyfikacja adresu e-mail zgodna z RFC 2822, zostanie ona przeanalizowana jako taka. Wyrażenia powyższe, nawet artykuł MSDN pierwszy, są błędne, ponieważ nie uwzględniają nazwy wyświetlanej, cytowanej części lokalnej, wartości literowej domeny, poprawnej specyfikacji dot-atom dla części lokalnej, możliwości, że adres e-mail może być w nawiasach ostrych, wielokrotnych cytowanych wartościach znaków dla nazwy wyświetlanej, znaków zbiegów, znaków Unicode w wyświetlanej nazwie, komentarzach i maksymalnej poprawnej długości adresu e-mail. Spędziłem trzy tygodnie na ponownym pisaniu parsera adresów pocztowych w .NET 4.0 dla System.Net.Mail i uwierzcie mi, było to o wiele trudniejsze niż zwykłe wymyślanie niektórych wyrażeń regularnych, ponieważ jest wiele skrzynek na krawędzi. Klasa MailAddress w .NET 4.0 beta 2 będzie miała tę ulepszoną funkcjonalność.

Jeszcze jedno, jedyną rzeczą, którą można sprawdzić, jest format adresu e-mail. Nie można nigdy potwierdzić, że adres e-mail jest rzeczywiście ważny do odbierania wiadomości e-mail bez wysyłania wiadomości e-mail na ten adres i sprawdzania, czy serwer akceptuje je do dostarczenia. Jest to niemożliwe i podczas gdy istnieją polecenia SMTP, które możesz dać serwerowi pocztowemu, aby spróbować go zweryfikować, wiele razy te będą wyłączone lub zwrócą nieprawidłowe wyniki, ponieważ jest to popularny sposób, w jaki spamerzy mogą znaleźć adresy e-mail.

Answer 2

Powinieneś użyć Regular Expressions, aby potwierdzić adresy e-mail.

Answer 3

Możesz użyć Regex, aby to zrobić.

Napisano wiele artykułów na ten temat; to pojawiło się, gdy szukałem w Google wyrażenia "regex do sprawdzania poprawności adresu e-mail": Find or Validate an Email Address.

Answer 4

MSDN Artykuł: How to: Verify That Strings are in Valid E-Mail Format

Ten przykład wywołuje metodę Regex.IsMatch (String, String), aby sprawdzić, czy ciąg jest zgodny z wzorcu wyrażenia regularnego.

Function IsValidEmailFormat(ByVal s As String) As Boolean 
    Return Regex.IsMatch(s, "^([0-9a-zA-Z]([-\.\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})$") 
End Function 

Answer 5

najpierw trzeba ograniczyć użytkownikowi wprowadzając niewłaściwych symboli, można to zrobić za pomocą zdarzenia tekstowe KeyPress

Private Sub txtemailid_KeyPress(ByVal sender As System.Object, 
           ByVal e As System.Windows.FormsKeyPressEventArgs) Handles txtemailid.KeyPress 

    Dim ac As String = "@" 
    If e.KeyChar <> ChrW(Keys.Back) Then 
     If Asc(e.KeyChar) < 97 Or Asc(e.KeyChar) > 122 Then 
      If Asc(e.KeyChar) <> 46 And Asc(e.KeyChar) <> 95 Then 
       If Asc(e.KeyChar) < 48 Or Asc(e.KeyChar) > 57 Then 
        If ac.IndexOf(e.KeyChar) = -1 Then 
         e.Handled = True 

        Else 

         If txtemailid.Text.Contains("@") And e.KeyChar = "@" Then 
          e.Handled = True 
         End If 

        End If 


       End If 
      End If 
     End If 

    End If 

End Sub 

powyższy kod tylko pozwoli użytkownikowi AZ wejściowego (małe), od 0 do 9 (cyfry), @ ,., _

i po użyciu stwierdzenia prawidłowości zdarzenie kontroli tekstowego do sprawdzania poprawności identyfikatora e-mail za pomocą wyrażenia regularnego

Private Sub txtemailid_Validating(ByVal sender As System.Object, 
            ByVal e As System.ComponentModel.CancelEventArgs) 
    Handles txtemailid.Validating 

    Dim pattern As String = "^[a-z][a-z|0-9|]*([_][a-z|0-9]+)*([.][a-z|0-9]+([_][a-z|0-9]+)*)?@[a-z][a-z|0-9|]*\.([a-z][a-z|0-9]*(\.[a-z][a-z|0-9]*)?)$" 


    Dim match As System.Text.RegularExpressions.Match = Regex.Match(txtemailid.Text.Trim(), pattern, RegexOptions.IgnoreCase) 
    If (match.Success) Then 
     MessageBox.Show("Success", "Checking") 
    Else 
     MessageBox.Show("Please enter a valid email id", "Checking") 
     txtemailid.Clear() 
    End If 
End Sub 

Answer 6

'----------------------------------------------------------------------- 

'Creater : Rachitha Madusanka 

'http://www.megazoon.com 

'jewandara@gmail.com 

'jewandara@hotmail.com 

'Web Designer and Software Developer 

'@ http://www.zionx.net16.net 

'----------------------------------------------------------------------- 




Function ValidEmail(ByVal strCheck As String) As Boolean 
    Try 
     Dim bCK As Boolean 
     Dim strDomainType As String 


     Const sInvalidChars As String = "!#$%^&*()=+{}[]|\;:'/?>,< " 
     Dim i As Integer 

     'Check to see if there is a double quote 
     bCK = Not InStr(1, strCheck, Chr(34)) > 0 
     If Not bCK Then GoTo ExitFunction 

     'Check to see if there are consecutive dots 
     bCK = Not InStr(1, strCheck, "..") > 0 
     If Not bCK Then GoTo ExitFunction 

     ' Check for invalid characters. 
     If Len(strCheck) > Len(sInvalidChars) Then 
      For i = 1 To Len(sInvalidChars) 
       If InStr(strCheck, Mid(sInvalidChars, i, 1)) > 0 Then 
        bCK = False 
        GoTo ExitFunction 
       End If 
      Next 
     Else 
      For i = 1 To Len(strCheck) 
       If InStr(sInvalidChars, Mid(strCheck, i, 1)) > 0 Then 
        bCK = False 
        GoTo ExitFunction 
       End If 
      Next 
     End If 

     If InStr(1, strCheck, "@") > 1 Then 'Check for an @ symbol 
      bCK = Len(Left(strCheck, InStr(1, strCheck, "@") - 1)) > 0 
     Else 
      bCK = False 
     End If 
     If Not bCK Then GoTo ExitFunction 

     strCheck = Right(strCheck, Len(strCheck) - InStr(1, strCheck, "@")) 
     bCK = Not InStr(1, strCheck, "@") > 0 'Check to see if there are too many @'s 
     If Not bCK Then GoTo ExitFunction 

     strDomainType = Right(strCheck, Len(strCheck) - InStr(1, strCheck, ".")) 
     bCK = Len(strDomainType) > 0 And InStr(1, strCheck, ".") < Len(strCheck) 
     If Not bCK Then GoTo ExitFunction 

     strCheck = Left(strCheck, Len(strCheck) - Len(strDomainType) - 1) 
     Do Until InStr(1, strCheck, ".") <= 1 
      If Len(strCheck) >= InStr(1, strCheck, ".") Then 
       strCheck = Left(strCheck, Len(strCheck) - (InStr(1, strCheck, ".") - 1)) 
      Else 
       bCK = False 
       GoTo ExitFunction 
      End If 
     Loop 
     If strCheck = "." Or Len(strCheck) = 0 Then bCK = False 

ExitFunction: 
     ValidEmail = bCK 
    Catch ex As ArgumentException 
     Return False 
    End Try 
    Return ValidEmail 
End Function 

Answer 7

Public Function ValidateEmail(ByVal strCheck As String) As Boolean 
     Try 
      Dim vEmailAddress As New System.Net.Mail.MailAddress(strCheck) 
     Catch ex As Exception 
      Return False 
     End Try 
     Return True 
    End Function 

Answer 8

ja testowałem zatwierdzone „odpowiedź” w tym przypadku i tak nie jest wydaje się przestrzegać specyfikacji tego, co faktycznie jest prawidłowym adresem e-mail. Po wielu bólach głowy znalazłem to wyrażenie, które ma o wiele lepszą pracę niż Microsoft.

"(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]" + 
")+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:" + 
"\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(" + 
"?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ " + 
"\t]))*""(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\0" + 
"31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\" + 
"](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+" + 
"(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:" + 
"(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z" + 
"|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)" + 
"?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\" + 
"r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[" + 
" \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)" + 
"?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]" + 
")*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[" + 
" \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*" + 
")(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]" + 
")+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)" + 
"*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+" + 
"|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r" + 
"\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:" + 
"\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t" + 
"]))*""(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031" + 
"]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](" + 
"?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?" + 
":(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?" + 
":\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?" + 
":(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?" + 
"[ \t]))*""(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\"".\[\] " + 
"\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|" + 
"\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>" + 
"@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""" + 
"(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]" + 
")*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\" + 
""".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?" + 
":[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[" + 
"\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\"".\[\] \000-" + 
"\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(" + 
"?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;" + 
":\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([" + 
"^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\""" + 
".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\" + 
"]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\" + 
"[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\" + 
"r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] " + 
"\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]" + 
"|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\"".\[\] \0" + 
"00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\" + 
".|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@," + 
";:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?" + 
":[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*" + 
"(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\""." + 
"\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[" + 
"^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]" + 
"]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(" + 
"?:(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\" + 
""".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*)(?:\.(?:(" + 
"?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[" + 
"\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t" + 
"])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t" + 
"])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?" + 
":\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|" + 
"\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:" + 
"[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\" + 
"]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)" + 
"?[ \t])*(?:@(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""" + 
"()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)" + 
"?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>" + 
"@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[" + 
" \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@," + 
";:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]" + 
")*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\" + 
""".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?" + 
"(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\""." + 
"\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:" + 
"\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[" + 
"""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])" + 
"*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])" + 
"+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\" + 
".(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z" + 
"|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(" + 
"?:\r\n)?[ \t])*))*)?;\s*)" 

Mam już sformatowany jako ciąg vb za pomocą prostej aplikacji. Szkoda, że ​​przepełnienie stosu jest bardziej zainteresowane byciem "repozytorium kodującym" niż posiadanie kompletnej odpowiedzi na problem.

Answer 9

Public Shared Function ValidEmailAddress(ByVal emailAddress As String, ByRef errorMessage As String) As Boolean 
     If emailAddress.Length = 0 Then 
      errorMessage = "E-mail address is required." 
      Return False 
     End If 
     If emailAddress.IndexOf("@") > -1 Then 
      If (emailAddress.IndexOf(".", emailAddress.IndexOf("@")) > emailAddress.IndexOf("@")) AndAlso emailAddress.Split(".").Length > 0 AndAlso emailAddress.Split(".")(1) <> "" Then 
       errorMessage = "" 
       Return True 
      End If 
     End If 
     errorMessage = "E-mail address must be valid e-mail address format." 
     Return False 
    End Function 

Answer 10

e-maile typu „adres @ localhost” i „user@192.168.1.2” są rzeczywiście ważne adresy i można przetestować te poprzez uruchomienie własnego serwera e-mail (zwykle odbywa się poprzez modyfikację pliku hosta, jak również). Dla kompletnego rozwiązania, jednakże:

''' <summary> 
''' METHODS FOR SENDING AND VALIDATING EMAIL 
''' </summary> 
''' <remarks></remarks> 
Public Class email 

    ''' <summary> 
    ''' check if email format is valid 
    ''' </summary> 
    ''' <param name="emailAddress">[required] Email address.</param> 
    ''' <param name="disallowLocalDomain">[optional] Allow headers like "@localhost"?</param> 
    ''' <param name="allowAlerts">[optional] Enable error messages?</param> 
    ''' <returns>Returns true if email is valid and false otherwise.</returns> 
    ''' <remarks></remarks> 
    Public Shared Function isValid(ByVal emailAddress As String, 
            Optional ByVal disallowLocalDomain As Boolean = True, 
            Optional ByVal allowAlerts As Boolean = True 
            ) As Boolean 
     Try 
      Dim mailParts() As String = emailAddress.Split("@") 
      If mailParts.Length <> 2 Then 
       If allowAlerts Then 
        MsgBox("Valid email addresses are formatted [sample@domain.tld]. " & 
          "Your address is missing a header [i.e. ""@domain.tld""].", 
          MsgBoxStyle.Exclamation, "No Header Specified") 
       End If 
       Return False 
      End If 
      If mailParts(mailParts.GetLowerBound(0)) = "" Then 
       If allowAlerts Then 
        MsgBox("Valid email addresses are formatted [sample@domain.tld]. " & 
          "The username portion of the e-mail address you provided (before the @ symbol) is empty.", 
          MsgBoxStyle.Exclamation, "Invalid Email User") 
       End If 
       Return False 
      End If 
      Dim headerParts() As String = mailParts(mailParts.GetUpperBound(0)).Split(".") 
      If disallowLocalDomain AndAlso headerParts.Length < 2 Then 
       If allowAlerts Then 
        MsgBox("Valid email addresses are formatted [sample@domain.tld]. " & 
          "Although addresses formatted like [sample@domain] are valid, " & 
          "only addresses with headers like ""sample.org"", ""sample.com"", and etc. " & 
          "[i.e. @domain.org] are accepted.", 
          MsgBoxStyle.Exclamation, "Invalid Header") 
       End If 
       Return False 
      ElseIf headerParts(headerParts.GetLowerBound(0)) = "" Or 
        headerParts(headerParts.GetUpperBound(0)) = "" Then 
       If allowAlerts Then 
        MsgBox("Valid email addresses are formatted [sample@domain.tld]. " & 
          "Your header """ & mailParts(mailParts.GetUpperBound(0)) & """ is invalid.", 
          MsgBoxStyle.Exclamation, "Invalid Header") 
       End If 
       Return False 
      End If 
      Dim address As MailAddress = New MailAddress(emailAddress) 
     Catch ex As Exception 
      If allowAlerts Then 
       MsgBox(ex.Message, MsgBoxStyle.Exclamation, "Invalid Email Address") 
      End If 
      Return False 
     End Try 
     Return True 
    End Function 

End Class 'email'