Gewusst wie: Überprüfen, ob Zeichenfolgen ein gültiges E-Mail-Format aufweisen

  • Artikel

Im Beispiel in diesem Artikel wird ein regulärer Ausdruck zur Überprüfung verwendet, ob eine Zeichenfolge ein gültiges E-Mail-Format aufweist.

Im Vergleich dazu, was tatsächlich als E-Mail-Adresse verwendet werden kann, ist dieser reguläre Ausdruck einfach. Die Verwendung eines regulären Ausdrucks zum Überprüfen einer E-Mail ist nützlich, um sicherzustellen, dass die Struktur einer E-Mail-Adresse korrekt ist. Das ist jedoch kein Ersatz für die Überprüfung, ob die E-Mail-Adresse tatsächlich vorhanden ist.

✔️ VERWENDEN SIE einen einfachen regulären Ausdruck, um die Struktur einer E-Mail-Adresse zu überprüfen.

✔️ SENDEN SIE eine Test-E-Mail an die von einem Benutzer Ihrer App angegebene Adresse.

❌ Verwenden Sie einen regulären Ausdruck NICHT als einzige Methode zum Überprüfen einer E-Mail-Adresse.

Wenn Sie versuchen, den perfekten regulären Ausdruck zum Überprüfen der korrekten Struktur einer E-Mail-Adresse zu erstellen, wird dieser Ausdruck so komplex, dass es äußerst schwierig wird, ihn zu debuggen oder zu verbessern. Reguläre Ausdrücke können nicht überprüfen, ob eine E-Mail-Adresse existiert, auch wenn sie richtig strukturiert ist. Die beste Möglichkeit, eine E-Mail-Adresse zu überprüfen, ist das Senden einer Test-E-Mail an diese Adresse.

Warnung

Übergeben Sie ein Timeout, wenn Sie System.Text.RegularExpressions zum Verarbeiten nicht vertrauenswürdiger Eingaben verwenden. Böswillige Benutzer können Eingaben für RegularExpressions bereitstellen, um einen Denial-of-Service-Angriff durchzuführen. ASP.NET Core-Framework-APIs, die RegularExpressions verwenden, übergeben ein Timeout.

Beispiel

Im Beispiel wird eine Methode IsValidEmail definiert, die true zurückgibt, wenn die Zeichenfolge eine gültige E-Mail-Adresse enthält, und false, wenn nicht. Sie führt jedoch keine weitere Aktion aus.

Um die Gültigkeit der E-Mail-Adresse zu überprüfen ruft die IsValidEmail -Methode die Regex.Replace(String, String, MatchEvaluator) -Methode mit dem regulären Ausdruck (@)(.+)$ auf, um den Domänennamen von der E-Mail-Adresse zu trennen. Der dritte Parameter ist ein MatchEvaluator -Delegat, der die Methode darstellt, die den gefundenen Text verarbeitet und ersetzt. Das Muster des regulären Ausdrucks wird wie folgt interpretiert:

Muster Beschreibung
(@) Das @ Zeichen wird als Übereinstimmung verwendet. Dieser Teil stellt die erste Erfassungsgruppe dar.
(.+) Ein- oder mehrmalige Übereinstimmung mit beliebigem Zeichen. Dieser Teil stellt die zweite Erfassungsgruppe dar.
$ Beendet die Suche am Ende der Zeichenfolge.

Der Domänenname wird zusammen mit dem @-Zeichen an die DomainMapper-Methode übergeben. Die Methode verwendet die IdnMapping-Klasse, um Unicode-Zeichen in ihre Punycode-Entsprechungen zu übersetzen, die außerhalb des 7-Bit-ASCII-Zeichenbereichs liegen. Darüber hinaus wird die Methode auch das invalid -Flag auf True fest, wenn die IdnMapping.GetAscii -Methode ein unzulässiges Zeichen im Domänennamen erkennt. Diese Methode gibt den Punycode-Domänennamen, der dem @ Zeichen vorangestellt ist, an die IsValidEmail -Methode zurück.

Tipp

Es wird empfohlen, dass Sie einen einfachen regulären Ausdruck mit dem Muster (@)(.+)$ verwenden, um die Domäne zu normalisieren und dann einen Wert zurückzugeben, der angibt, ob die Adresse die Überprüfung bestanden hat oder nicht. Im Beispiel in diesem Artikel werden jedoch Möglichkeiten beschrieben, wie Sie einen regulären Ausdruck zur weiteren Überprüfung der E-Mail-Adresse verwenden können. Unabhängig davon, wie Sie eine E-Mail-Adresse überprüfen, sollten Sie immer eine Test-E-Mail an die Adresse senden, um sicherzustellen, dass diese existiert.

Die IsValidEmail-Methode ruft dann die Regex.IsMatch(String, String)-Methode auf, um zu überprüfen, ob die Adresse dem Muster eines regulären Ausdrucks entspricht.

Die Methode IsValidEmail überprüft lediglich, ob das Format der E-Mail-Adresse gültig ist. Sie überprüft nicht, ob die E-Mail-Adresse existiert. Außerdem überprüft die Methode IsValidEmail nicht, ob es sich bei dem Domänennamen der obersten Ebene um einen gültigen Domänennamen handelt, der in der IANA Root Zone Database aufgeführt ist, was einen Suchvorgang erfordern würde.

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 diesem Beispiel kann das Muster des regulären Ausdrucks ^[^@\s]+@[^@\s]+\.[^@\s]+$ wie in der folgenden Tabelle dargestellt interpretiert werden. Der reguläre Ausdruck wird mit dem Flag RegexOptions.IgnoreCase kompiliert.

Muster BESCHREIBUNG
^ Starten Sie den Vergleich am Beginn der Zeichenfolge.
[^@\s]+ Überprüfung der einmaligen oder mehrmaligen Verwendung eines beliebigen Zeichens bis auf das @-Zeichen und das Leerzeichen
@ Das @ Zeichen wird als Übereinstimmung verwendet.
[^@\s]+ Überprüfung der einmaligen oder mehrmaligen Verwendung eines beliebigen Zeichens bis auf das @-Zeichen und das Leerzeichen
\. Überprüfung der Verwendung eines einzelnen Punkts
[^@\s]+ Überprüfung der einmaligen oder mehrmaligen Verwendung eines beliebigen Zeichens bis auf das @-Zeichen und das Leerzeichen
$ Beendet die Suche am Ende der Zeichenfolge.

Wichtig

Dieser reguläre Ausdruck soll nicht jeden Aspekt einer gültigen E-Mail-Adresse abdecken. Er wird vielmehr als Beispiel bereitgestellt, das Sie nach Bedarf erweitern können.

Siehe auch