Guide pratique pour vérifier que des chaînes sont dans un format d’adresse e-mail valide

  • Article

L’exemple fourni dans cet article utilise une expression régulière qui vérifie qu’une chaîne est dans un format d’e-mail valide.

Cette expression régulière est simple par rapport à ce qui peut réellement être utilisé comme e-mail. L’utilisation d’une expression régulière pour valider un e-mail permet de garantir que la structure d’un e-mail est correcte. Toutefois, cette méthode ne vérifie pas que l’e-mail existe bien.

✔️ UTILISEZ une expression régulière simple pour vérifier la validité de la structure d’un e-mail.

✔️ ENVOYEZ un e-mail de test à l’adresse fournie par un utilisateur de votre application.

❌ N’UTILISEZ PAS une expression régulière comme seul moyen de valider un e-mail.

Si vous essayez de créer l’expression régulière parfaite pour vérifier que la structure d’un e-mail est correcte, l’expression devient si complexe qu’elle s’avère extrêmement difficile à déboguer ou à améliorer. Les expressions régulières ne peuvent pas vérifier l’existence d’un e-mail, même si celui-ci a une structure correcte. Le meilleur moyen de valider un e-mail consiste à envoyer un e-mail de test à l’adresse.

Avertissement

Lorsque vous utilisez System.Text.RegularExpressions pour traiter une entrée non approuvée, passez un délai d’expiration. Un utilisateur malveillant peut fournir une entrée à RegularExpressions, provoquant une attaque par déni de service. Les API d’infrastructure ASP.NET Core qui utilisent RegularExpressions passent un délai d’expiration.

Exemple

L'exemple définit une méthode IsValidEmail qui retourne la valeur true si la chaîne contient une adresse e-mail valide, ou la valeur false dans le cas contraire. Il n’effectue aucune autre action.

Pour vérifier que l'adresse de messagerie est valide, la méthode IsValidEmail appelle la méthode Regex.Replace(String, String, MatchEvaluator) avec le modèle d'expression régulière (@)(.+)$ pour séparer le nom de domaine de l'adresse de messagerie. Le troisième paramètre est un délégué MatchEvaluator qui représente la méthode qui traite et remplace le texte correspondant. Le modèle d’expression régulière est interprété comme suit :

Modèle Description
(@) Correspond à l'arobase (@). Cette partie est le premier groupe de capture.
(.+) Correspond à une ou plusieurs occurrences d'un caractère quelconque. Cette partie est le deuxième groupe de capture.
$ Termine la correspondance à la fin de la chaîne.

Le nom de domaine, avec le caractère @, est passé à la méthode DomainMapper. La méthode utilise la classe IdnMapping pour convertir les caractères Unicode en dehors de la plage de caractères US-ASCII au format Punycode. La méthode affecte également à l'indicateur invalid la valeur True si la méthode IdnMapping.GetAscii détecte des caractères non valides dans le nom de domaine. La méthode retourne le nom de domaine Punycode précédé du symbole @ à la méthode IsValidEmail .

Conseil

Il est recommandé d’utiliser le modèle d’expression régulière simple (@)(.+)$ pour standardiser le domaine, puis de retourner une valeur indiquant la réussite ou l’échec. Toutefois, l’exemple de cet article décrit comment utiliser une expression régulière pour valider l’e-mail. Quelle que soit la méthode de validation d’e-mail choisie, vous devez toujours envoyer un e-mail de test à l’adresse pour vérifier que l’e-mail existe.

La méthode IsValidEmail appelle alors la méthode Regex.IsMatch(String, String) pour vérifier que l'adresse est conforme à un modèle d'expression régulière.

La méthode IsValidEmail détermine seulement si le format de l’e-mail est valide pour une adresse e-mail ; elle ne vérifie pas que l’e-mail existe. La méthode IsValidEmail ne vérifie pas non plus si le nom de domaine de premier niveau est un nom de domaine valide répertorié dans la base de données des zones racines de l’IANA. Cela nécessite une opération de recherche.

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

Dans cet exemple, le modèle d’expression régulière ^[^@\s]+@[^@\s]+\.[^@\s]+$ est interprété de la manière indiquée dans le tableau ci-dessous. L’expression régulière est compilée avec l’indicateur RegexOptions.IgnoreCase.

Modèle Description
^ Commence la recherche de correspondance au début de la chaîne.
[^@\s]+ Recherche une ou plusieurs occurrences d’un caractère autre que le caractère @ ou l’espace blanc.
@ Correspond à l'arobase (@).
[^@\s]+ Recherche une ou plusieurs occurrences d’un caractère autre que le caractère @ ou l’espace blanc.
\. Recherche un seul caractère point.
[^@\s]+ Recherche une ou plusieurs occurrences d’un caractère autre que le caractère @ ou l’espace blanc.
$ Termine la correspondance à la fin de la chaîne.

Important

Cette expression régulière n’est pas destinée à vérifier tous les aspects d’une adresse e-mail valide. Elle est fournie comme exemple à compléter selon les besoins.

Voir aussi