.net - net - validate email c#

¿Cómo valido el formato de la dirección de correo electrónico con.NET Framework?

Question

Quiero una función para probar que una cadena tiene el formato de una dirección de correo electrónico.

¿Qué viene incorporado con .NET Framework para hacer esto?

Esto funciona:

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

Pero, ¿hay una manera más elegante?

Answer 1

Artículo de MSDN: Cómo: Verificar que las cadenas estén en formato de correo electrónico válido

Este método de ejemplo llama al método Regex.IsMatch (String, String) para verificar que la cadena se ajusta a un patrón de expresión regular.

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 2

Debe usar expresiones regulares para validar direcciones de correo electrónico.

Answer 3

He probado la ''respuesta'' aprobada en este caso y no parece cumplir con las especificaciones de lo que realmente es una dirección de correo electrónico válida. Después de muchos dolores de cabeza encontré esta expresión regular que hace un trabajo mucho mejor que el de 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*)"

Ya lo he formateado como una cadena vb usando una aplicación simple. El desbordamiento de pila demasiado malo está más interesado en ser un ''repositorio de codificación'' que en tener la respuesta completa para el problema.

Answer 4

Los correos electrónicos como "dirección @ localhost" y "[email protected]" son en realidad direcciones válidas y puede probarlos ejecutando su propio servidor de correo electrónico (generalmente también se realiza modificando el archivo de host). Para una solución completa, sin embargo:

'''''' <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 [[email protected]]. " &
                           "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 [[email protected]]. " &
                           "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 [[email protected]]. " &
                           "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 [[email protected]]. " &
                           "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''

Answer 5

No te molestes con tu propia validación. .NET 4.0 ha mejorado significativamente la validación a través de la clase MailAddress . Solo use MailAddress address = new MailAddress(input) y si arroja, no es válido. Si hay alguna interpretación posible de su entrada como una especificación de dirección de correo electrónico compatible con RFC 2822, la analizará como tal. Las expresiones regemáticas anteriores, incluso el artículo uno de MSDN, son incorrectas porque no tienen en cuenta un nombre para mostrar, una parte local citada, un valor literal de dominio para el dominio, especificaciones correctas de átomo de punto para la parte local, la posibilidad de que la dirección de correo podría estar en corchetes angulares, valores múltiples de cadenas entrecomilladas para el nombre para mostrar, caracteres escapados, unicode en el nombre para mostrar, comentarios y longitud máxima válida de dirección de correo. Pasé tres semanas reescribiendo el analizador de direcciones de correo en .NET 4.0 para System.Net.Mail y confía en mí, fue mucho más difícil que encontrar una expresión regular, ya que hay muchos casos extremos. La clase MailAddress en .NET 4.0 beta 2 tendrá esta funcionalidad mejorada.

Una cosa más, lo único que puede validar es el formato de la dirección de correo. Nunca se puede validar que una dirección de correo electrónico sea válida para recibir un correo electrónico sin enviar un correo electrónico a esa dirección y ver si el servidor lo acepta para la entrega. Es imposible y si bien hay comandos SMTP que puede entregar al servidor de correo para intentar validarlo, muchas veces estos se desactivarán o devolverán resultados incorrectos ya que esta es una forma común para que los spammers encuentren direcciones de correo electrónico.

Answer 6

Podría usar una Regex para hacer esto.

Se han escrito muchos artículos al respecto; esto surgió cuando busqué en google ''regex para validar la dirección de correo electrónico'': encontrar o validar una dirección de correo electrónico .

Answer 7

primero tiene que restringir al usuario ingresando los símbolos incorrectos, puede hacerlo mediante el uso del evento KeyPress de la caja de texto

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

el código anterior solo permitirá al usuario ingresar az (pequeño), 0 a 9 (dígitos), @,., _

y después de usar el evento de validación del control del cuadro de texto para validar el ID del correo electrónico utilizando la expresión regular

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 8

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

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

''Creater : Rachitha Madusanka

''http://www.megazoon.com

''[email protected]

''[email protected]

''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