Share via

Como: Verifique se as seqüências estão em formato de email válido

  • Artigo

O exemplo a seguir verifica que uma seqüência de caracteres está no formato de e-mail válido.

Exemplo

O exemplo define uma IsValidEmail método, que retorna true se a seqüência contém um endereço de email válido e false se ele não foi, mas leva a nenhuma outra ação. Para verificar se o endereço de email é válido, o método chama o Regex.IsMatch(String, String) método para verificar se o endereço está de acordo com a um padrão de expressão regular. Você pode usar IsValidEmail para filtrar os endereços de email que contêm caracteres inválidos antes que o aplicativo armazena os endereços em um banco de dados ou exibe-os em um aplicativo ASP.NET page.

Observe que o IsValidEmail método não executa a autenticação para validar o endereço de email. Ele simplesmente determina se o seu formato é válido para um endereço de email.

Imports System.Text.RegularExpressions

Module RegexUtilities
   Function IsValidEmail(strIn As String) As Boolean
       ' Return true if strIn is in valid e-mail format.
       Return Regex.IsMatch(strIn, _
              "^(?("")("".+?""@)|(([0-9a-zA-Z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-zA-Z])@))" + _
              "(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,6}))$")
   End Function
End Module

using System;
using System.Text.RegularExpressions;

public class RegexUtilities
{
   public static bool IsValidEmail(string strIn)
   {
       // Return true if strIn is in valid e-mail format.
       return Regex.IsMatch(strIn, 
              @"^(?("")("".+?""@)|(([0-9a-zA-Z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-zA-Z])@))" + 
              @"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,6}))$"); 
   }
}

Neste exemplo, o padrão de expressão regular ^(?("")("".+?""@)|(([0-9a-zA-Z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-zA-Z])@))(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,6}))$ podem ser interpretados como mostrado na tabela a seguir.

Padrão

Descrição

^

Começa a correspondência no início da seqüência de caracteres.

(?("")

Determine se o primeiro caractere é uma aspa. (?("")é o início de uma construção de alternância.

((?("")("".+?""@)

Se o primeiro caractere de aspas, corresponde ao início aspas seguido pelo menos uma ocorrência de qualquer caractere, seguido por uma aspa final. A seqüência de caracteres deve concluirá com uma arroba (@).

|(([0-9a-zA-Z]

Se o primeiro caractere não é uma aspa, corresponde a qualquer caractere alfabético de um a z ou a qualquer caractere numérico de 0 a 9.

(\.(?! \.))

Se o próximo caractere é um período, corresponde a ele. Se não for um período, olhar à frente para o próximo caractere e continuar a correspondência. (?!\.)é uma afirmação lookahead negativo de largura zero que impede que dois pontos consecutivos que aparecem na parte local de um endereço de email.

|[-!#\$%&'\*\+/=\? \^`\{\}\|~\w]

Se o próximo caractere não é um período, corresponde a qualquer caractere de palavra ou um dos seguintes caracteres: -!#$%'*+=?^`{}|~.

((\.(?! \.))|[-!#\$%'\*\+/=\? \^`\{\}\|~\w])*

Coincide com o padrão de alternação (um ponto seguido de um não-ponto ou de um número de caracteres), zero ou mais vezes.

@

Coincidir o caractere @.

(?<=[0-9a-zA-Z])

Continuar a correspondência se o caractere que precede o caractere @ for À Z, de a z ou 0 a 9. O (?<=[0-9a-zA-Z]) define a construção de uma declaração lookbehind positiva de largura igual a zero.

(?(\[)

Verifique se o caractere que segue a @ é um colchete de abertura.

(\[(\d{1,3}\.){3}\d{1,3}\])

Se for um colchete de abertura, coincidir o colchete de abertura, seguido de um endereço IP (conjuntos de quatro dígitos de um a três, com cada conjunto separado por um ponto) e um colchete de fechamento.

|(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,6})

Se o caractere que segue a @ não é um colchete de abertura, um caractere alfanumérico correspondência com um valor de A-Z, a-z ou 0-9, seguido de zero ou mais ocorrências de um caractere de palavra ou um hífen, seguido por um caractere alfanumérico com um valor de A-Z, a-z ou 0-9, seguido por um ponto. Esse padrão pode ser repetido uma ou mais vezes e devem ser seguido por caracteres alfabéticos dois a seis (a-z, A-Z). Esta parte da expressão regular é projetado para capturar o nome de domínio.

Compilando o código

O IsValidEmail método pode ser incluído em uma biblioteca de métodos de utilitário de expressão regular, ou pode ser incluído como um privado estático ou um método de instância em que a classe do aplicativo. Se ele é usado como um método estático em uma biblioteca de expressão regular, ele pode ser chamado usando código como o seguinte:

Public Class Application
   Public Shared Sub Main()
      Dim emailAddresses() As String = { "david.jones@proseware.com", "d.j@server1.proseware.com", _
                                         "jones@ms1.proseware.com", "j.@server1.proseware.com", _
                                         "j@proseware.com9", "js#internal@proseware.com", _
                                         "j_9@[129.126.118.1]", "j..s@proseware.com", _
                                         "js*@proseware.com", "js@proseware..com", _
                                         "js@proseware.com9", "j.s@server1.proseware.com" }

      For Each emailAddress As String In emailAddresses
         If RegexUtilities.IsValidEmail(emailAddress) Then
            Console.WriteLine("Valid: {0}", emailAddress)
         Else
            Console.WriteLine("Invalid: {0}", emailAddress)
         End If      
      Next                                            
   End Sub
End Class
' The example displays the following output:
'       Valid: david.jones@proseware.com
'       Valid: d.j@server1.proseware.com
'       Valid: jones@ms1.proseware.com
'       Invalid: j.@server1.proseware.com
'       Invalid: j@proseware.com9
'       Valid: js#internal@proseware.com
'       Valid: j_9@[129.126.118.1]
'       Invalid: j..s@proseware.com
'       Invalid: js*@proseware.com
'       Invalid: js@proseware..com
'       Invalid: js@proseware.com9
'       Valid: j.s@server1.proseware.com

public class Application
{
   public static void Main()
   {
      string[] emailAddresses = { "david.jones@proseware.com", "d.j@server1.proseware.com", 
                                  "jones@ms1.proseware.com", "j.@server1.proseware.com", 
                                  "j@proseware.com9", "js#internal@proseware.com", 
                                  "j_9@[129.126.118.1]", "j..s@proseware.com", 
                                  "js*@proseware.com", "js@proseware..com", 
                                  "js@proseware.com9", "j.s@server1.proseware.com" };
      foreach (string emailAddress in emailAddresses)
      {
         if (RegexUtilities.IsValidEmail(emailAddress))
            Console.WriteLine("Valid: {0}", emailAddress);
         else
            Console.WriteLine("Invalid: {0}", emailAddress);
      }                                            
   }
}
// The example displays the following output:
//       Valid: david.jones@proseware.com
//       Valid: d.j@server1.proseware.com
//       Valid: jones@ms1.proseware.com
//       Invalid: j.@server1.proseware.com
//       Invalid: j@proseware.com9
//       Valid: js#internal@proseware.com
//       Valid: j_9@[129.126.118.1]
//       Invalid: j..s@proseware.com
//       Invalid: js*@proseware.com
//       Invalid: js@proseware..com
//       Invalid: js@proseware.com9
//       Valid: j.s@server1.proseware.com

Consulte também

Conceitos

Expressões Regulares do .NET Framework