Share via

Controleren of tekenreeksen een geldige e-mailindeling hebben

  • Artikel

In het voorbeeld in dit artikel wordt een reguliere expressie gebruikt om te controleren of een tekenreeks een geldige e-mailindeling heeft.

Deze reguliere expressie is relatief eenvoudig te gebruiken als e-mail. Het gebruik van een reguliere expressie om een e-mailbericht te valideren is handig om ervoor te zorgen dat de structuur van een e-mailbericht juist is. Het is echter geen vervanging voor het verifiëren van het e-mailbericht.

✔️ Gebruik een kleine reguliere expressie om te controleren op de geldige structuur van een e-mailbericht.

✔️ Stuur een test-e-mail naar het adres dat is opgegeven door een gebruiker van uw app.

❌ Gebruik geen reguliere expressie als enige manier om een e-mailbericht te valideren.

Als u de perfecte reguliere expressie probeert te maken om te controleren of de structuur van een e-mailbericht juist is, wordt de expressie zo complex dat het ongelooflijk moeilijk is om fouten op te sporen of te verbeteren. Reguliere expressies kunnen niet valideren dat er een e-mailbericht bestaat, zelfs niet als deze correct is gestructureerd. De beste manier om een e-mailbericht te valideren, is door een test-e-mailbericht naar het adres te verzenden.

Waarschuwing

Wanneer u System.Text.RegularExpressions niet-vertrouwde invoer gebruikt, geeft u een time-out door. Een kwaadwillende gebruiker kan invoer opgeven voor RegularExpressionseen Denial-of-Service-aanval. ASP.NET Core Framework-API's die gebruikmaken van RegularExpressions een time-out.

Opmerking

In het voorbeeld wordt een IsValidEmail methode gedefinieerd, die retourneert true als de tekenreeks een geldig e-mailadres bevat en false of de tekenreeks geen andere actie onderneemt.

Om te controleren of het e-mailadres geldig is, roept de IsValidEmail methode de Regex.Replace(String, String, MatchEvaluator) methode aan met het (@)(.+)$ reguliere expressiepatroon om de domeinnaam van het e-mailadres te scheiden. De derde parameter is een MatchEvaluator gemachtigde die de methode vertegenwoordigt die de overeenkomende tekst verwerkt en vervangt. Het patroon van de reguliere expressie wordt als volgt geïnterpreteerd:

Patroon Beschrijving
(@) Komt overeen met het @-teken. Dit deel is de eerste opnamegroep.
(.+) Komt overeen met een of meer exemplaren van een willekeurig teken. Dit deel is de tweede vastleggende groep.
$ Beëindig de overeenkomst aan het einde van de tekenreeks.

De domeinnaam, samen met het @-teken, wordt doorgegeven aan de DomainMapper methode. De methode gebruikt de IdnMapping klasse om Unicode-tekens te vertalen die zich buiten het AMERIKAANSE ASCII-tekenbereik bevinden naar Punycode. Met de methode wordt ook de invalid vlag True ingesteld op als de IdnMapping.GetAscii methode ongeldige tekens in de domeinnaam detecteert. De methode retourneert de Punycode-domeinnaam die voorafgaat door het @-symbool aan de IsValidEmail methode.

Tip

Het is raadzaam om het eenvoudige (@)(.+)$ reguliere expressiepatroon te gebruiken om het domein te normaliseren en vervolgens een waarde te retourneren die aangeeft dat het is doorgegeven of mislukt. In het voorbeeld in dit artikel wordt echter beschreven hoe u een reguliere expressie verder kunt gebruiken om het e-mailbericht te valideren. Ongeacht hoe u een e-mailbericht valideert, moet u altijd een testmail verzenden naar het adres om er zeker van te zijn dat deze bestaat.

De IsValidEmail methode roept vervolgens de Regex.IsMatch(String, String) methode aan om te controleren of het adres voldoet aan een normaal expressiepatroon.

De IsValidEmail methode bepaalt alleen of de e-mailindeling geldig is voor een e-mailadres. De methode valideert niet of het e-mailbericht bestaat. IsValidEmail De methode controleert ook niet of de domeinnaam op het hoogste niveau een geldige domeinnaam is die wordt vermeld in de IANA-hoofdzonedatabase. Hiervoor is een opzoekbewerking vereist.

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 dit voorbeeld wordt het patroon reguliere expressie ^[^@\s]+@[^@\s]+\.[^@\s]+$ geïnterpreteerd zoals wordt weergegeven in de volgende tabel. De reguliere expressie wordt gecompileerd met behulp van de RegexOptions.IgnoreCase vlag.

Patroon Beschrijving
^ Begin de overeenkomst aan het begin van de tekenreeks.
[^@\s]+ Komt overeen met een of meer exemplaren van een ander teken dan het @-teken of de spatie.
@ Komt overeen met het @-teken.
[^@\s]+ Komt overeen met een of meer exemplaren van een ander teken dan het @-teken of de spatie.
\. Komt overeen met één puntteken.
[^@\s]+ Komt overeen met een of meer exemplaren van een ander teken dan het @-teken of de spatie.
$ Beëindig de overeenkomst aan het einde van de tekenreeks.

Belangrijk

Deze reguliere expressie is niet bedoeld om elk aspect van een geldig e-mailadres te behandelen. Het is een voorbeeld dat u zo nodig kunt uitbreiden.

Zie ook