Come verificare che le stringhe siano in formato di posta elettronica valido

Nell'esempio riportato in questo articolo viene usata un'espressione regolare per verificare che una stringa sia in formato di posta elettronica valido.

Questa espressione regolare è relativamente semplice rispetto a ciò che può essere effettivamente usato come messaggio di posta elettronica. L'uso di un'espressione regolare per convalidare un messaggio di posta elettronica è utile per garantire che la struttura di un messaggio di posta elettronica sia corretta. Tuttavia, non è una sostituzione per verificare che il messaggio di posta elettronica esista effettivamente.

✔️ USARE un'espressione regolare di piccole dimensioni per verificare la struttura valida di un messaggio di posta elettronica.

✔️ INVIARE un messaggio di posta elettronica di test all'indirizzo fornito da un utente dell'app.

❌ NON usare un'espressione regolare come unico modo per convalidare un messaggio di posta elettronica.

Se si tenta di creare l'espressione regolare perfetta per verificare che la struttura di un messaggio di posta elettronica sia corretta, l'espressione diventa così complessa che è incredibilmente difficile eseguire il debug o migliorare. Le espressioni regolari non possono convalidare l'esistenza di un messaggio di posta elettronica, anche se è strutturato correttamente. Il modo migliore per convalidare un messaggio di posta elettronica consiste nell'inviare un messaggio di posta elettronica di prova all'indirizzo.

Avviso

Quando si usa System.Text.RegularExpressions per elaborare l'input non attendibile, passare un timeout. Un utente malintenzionato può fornire input a RegularExpressions, causando un attacco Denial of Service. ASP.NET Core API del framework che usano RegularExpressions il superamento di un timeout.

Esempio

Nell'esempio viene definito un IsValidEmail metodo , che restituisce true se la stringa contiene un indirizzo di posta elettronica valido e false , in caso contrario, non esegue altre azioni.

Per verificare che l'indirizzo di posta elettronica sia valido, il metodo IsValidEmail chiama il metodo Regex.Replace(String, String, MatchEvaluator) con il criterio di espressione regolare (@)(.+)$ per separare il nome di dominio dall'indirizzo di posta elettronica. Il terzo parametro è un delegato MatchEvaluator che rappresenta il metodo che elabora e sostituisce il testo corrispondente. Il criterio di espressione regolare viene interpretato come segue:

Modello Descrizione
(@) Trova la corrispondenza con il carattere @. Questa parte è il primo gruppo di acquisizione.
(.+) Trova la corrispondenza con una o più occorrenze di qualsiasi carattere. Questa parte è il secondo gruppo di acquisizione.
$ Terminare la corrispondenza alla fine della stringa.

Il nome di dominio, insieme al carattere @, viene passato al DomainMapper metodo . Il metodo usa la IdnMapping classe per convertire caratteri Unicode esterni all'intervallo di caratteri US-ASCII in Punycode. Il metodo imposta inoltre il flag invalid su True se il metodo IdnMapping.GetAscii rileva caratteri non validi nel nome di dominio. Il metodo restituisce il nome di dominio Punycode preceduto dal simbolo @ al metodo IsValidEmail .

Suggerimento

È consigliabile usare il modello di espressione regolare semplice (@)(.+)$ per normalizzare il dominio e quindi restituire un valore che indica che è stato passato o non riuscito. Tuttavia, l'esempio in questo articolo descrive come usare ulteriormente un'espressione regolare per convalidare il messaggio di posta elettronica. Indipendentemente dalla modalità di convalida di un messaggio di posta elettronica, è consigliabile inviare sempre un messaggio di posta elettronica di prova all'indirizzo per assicurarsi che esista.

Il metodo IsValidEmail chiama quindi il metodo Regex.IsMatch(String, String) per verificare che l'indirizzo sia conforme a un criterio di espressione regolare.

Il IsValidEmail metodo determina semplicemente se il formato di posta elettronica è valido per un indirizzo di posta elettronica; non convalida che il messaggio di posta elettronica esista. Inoltre, il IsValidEmail metodo non verifica che il nome di dominio di primo livello sia un nome di dominio valido elencato nel database della zona radice IANA, che richiederebbe un'operazione di ricerca.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

namespace RegexExamples
{
    class RegexUtilities
    {
        public static bool IsValidEmail(string email)
        {
            if (string.IsNullOrWhiteSpace(email))
                return false;

            try
            {
                // Normalize the domain
                email = Regex.Replace(email, @"(@)(.+)$", DomainMapper,
                                      RegexOptions.None, TimeSpan.FromMilliseconds(200));

                // Examines the domain part of the email and normalizes it.
                string DomainMapper(Match match)
                {
                    // Use IdnMapping class to convert Unicode domain names.
                    var idn = new IdnMapping();

                    // Pull out and process domain name (throws ArgumentException on invalid)
                    string domainName = idn.GetAscii(match.Groups[2].Value);

                    return match.Groups[1].Value + domainName;
                }
            }
            catch (RegexMatchTimeoutException e)
            {
                return false;
            }
            catch (ArgumentException e)
            {
                return false;
            }

            try
            {
                return Regex.IsMatch(email,
                    @"^[^@\s]+@[^@\s]+\.[^@\s]+$",
                    RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250));
            }
            catch (RegexMatchTimeoutException)
            {
                return false;
            }
        }
    }
}
Imports System.Globalization
Imports System.Text.RegularExpressions

Public Class RegexUtilities
    Public Shared Function IsValidEmail(email As String) As Boolean

        If String.IsNullOrWhiteSpace(email) Then Return False

        ' Use IdnMapping class to convert Unicode domain names.
        Try
            'Examines the domain part of the email and normalizes it.
            Dim DomainMapper =
                Function(match As Match) As String

                    'Use IdnMapping class to convert Unicode domain names.
                    Dim idn = New IdnMapping

                    'Pull out and process domain name (throws ArgumentException on invalid)
                    Dim domainName As String = idn.GetAscii(match.Groups(2).Value)

                    Return match.Groups(1).Value & domainName

                End Function

            'Normalize the domain
            email = Regex.Replace(email, "(@)(.+)$", DomainMapper,
                                  RegexOptions.None, TimeSpan.FromMilliseconds(200))

        Catch e As RegexMatchTimeoutException
            Return False

        Catch e As ArgumentException
            Return False

        End Try

        Try
            Return Regex.IsMatch(email,
                                 "^[^@\s]+@[^@\s]+\.[^@\s]+$",
                                 RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250))

        Catch e As RegexMatchTimeoutException
            Return False

        End Try

    End Function
End Class

In questo esempio il modello di espressione regolare ^[^@\s]+@[^@\s]+\.[^@\s]+$ viene interpretato come illustrato nella tabella seguente. L'espressione regolare viene compilata usando il RegexOptions.IgnoreCase flag .

Modello Descrizione
^ Iniziare la ricerca della corrispondenza all'inizio della stringa.
[^@\s]+ Trova la corrispondenza con una o più occorrenze di qualsiasi carattere diverso dal carattere @ o dallo spazio vuoto.
@ Trova la corrispondenza con il carattere @.
[^@\s]+ Trova la corrispondenza con una o più occorrenze di qualsiasi carattere diverso dal carattere @ o dallo spazio vuoto.
\. Trova la corrispondenza con un singolo carattere punto.
[^@\s]+ Trova la corrispondenza con una o più occorrenze di qualsiasi carattere diverso dal carattere @ o dallo spazio vuoto.
$ Terminare la corrispondenza alla fine della stringa.

Importante

Questa espressione regolare non è progettata per coprire ogni aspetto di un indirizzo di posta elettronica valido. Viene fornito come esempio per estendere in base alle esigenze.

Vedi anche