Share via

Så här kontrollerar du att strängarna är i giltigt e-postformat

  • Artikel

Exemplet i den här artikeln använder ett reguljärt uttryck för att verifiera att en sträng är i giltigt e-postformat.

Det här reguljära uttrycket är jämförelsevis enkelt för vad som faktiskt kan användas som e-post. Att använda ett reguljärt uttryck för att verifiera ett e-postmeddelande är användbart för att säkerställa att strukturen för ett e-postmeddelande är korrekt. Det är dock inte en ersättning för att verifiera att e-postmeddelandet faktiskt finns.

✔️ Använd ett litet reguljärt uttryck för att söka efter den giltiga strukturen för ett e-postmeddelande.

✔️ Skicka ett testmeddelande till den adress som tillhandahålls av en användare av din app.

❌ Använd inte ett reguljärt uttryck som det enda sättet att verifiera ett e-postmeddelande.

Om du försöker skapa det perfekta reguljära uttrycket för att verifiera att strukturen för ett e-postmeddelande är korrekt blir uttrycket så komplext att det är otroligt svårt att felsöka eller förbättra. Reguljära uttryck kan inte verifiera att ett e-postmeddelande finns, även om det är korrekt strukturerat. Det bästa sättet att verifiera ett e-postmeddelande är att skicka ett testmeddelande till adressen.

Varning

När du använder System.Text.RegularExpressions för att bearbeta ej betrodda indata skickar du en timeout. En obehörig användare kan ange indata till RegularExpressions, vilket orsakar en Denial-of-Service-attack. ASP.NET Core Framework-API:er som använder RegularExpressions passera en timeout.

Exempel

Exemplet definierar en IsValidEmail metod som returnerar true om strängen innehåller en giltig e-postadress och false om den inte gör det men inte vidtar någon annan åtgärd.

För att verifiera att e-postadressen är giltig IsValidEmail anropar Regex.Replace(String, String, MatchEvaluator) metoden metoden med (@)(.+)$ reguljärt uttrycksmönster för att skilja domännamnet från e-postadressen. Den tredje parametern är ett MatchEvaluator ombud som representerar metoden som bearbetar och ersätter den matchade texten. Mönster för reguljära uttryck tolkas på följande sätt:

Mönster beskrivning
(@) Matcha @-tecknet. Den här delen är den första insamlingsgruppen.
(.+) Matcha en eller flera förekomster av ett tecken. Den här delen är den andra insamlingsgruppen.
$ Avsluta matchningen i slutet av strängen.

Domännamnet, tillsammans med @-tecknet, skickas till DomainMapper metoden. Metoden använder IdnMapping klassen för att översätta Unicode-tecken som ligger utanför teckenintervallet US-ASCII till Punycode. Metoden anger invalid också flaggan till True om IdnMapping.GetAscii metoden identifierar ogiltiga tecken i domännamnet. Metoden returnerar punycode-domännamnet som föregås av @-symbolen IsValidEmail till metoden.

Dricks

Vi rekommenderar att du använder det enkla (@)(.+)$ reguljära uttrycksmönstret för att normalisera domänen och sedan returnerar ett värde som anger att den har skickats eller misslyckats. Exemplet i den här artikeln beskriver dock hur du använder ett reguljärt uttryck ytterligare för att verifiera e-postmeddelandet. Oavsett hur du validerar ett e-postmeddelande bör du alltid skicka ett testmeddelande till adressen för att säkerställa att det finns.

Metoden IsValidEmail anropar Regex.IsMatch(String, String) sedan metoden för att verifiera att adressen överensstämmer med ett mönster för reguljära uttryck.

Metoden avgör bara om e-postformatet är giltigt för en e-postadress. Det IsValidEmail verifierar inte att e-postmeddelandet finns. IsValidEmail Metoden verifierar inte heller att domännamnet på den översta nivån är ett giltigt domännamn som anges i IANA Root Zone Database, vilket skulle kräva en uppslagsåtgärd.

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

I det här exemplet tolkas mönster för ^[^@\s]+@[^@\s]+\.[^@\s]+$ reguljära uttryck enligt följande tabell. Det reguljära uttrycket kompileras med hjälp av RegexOptions.IgnoreCase flaggan.

Mönster beskrivning
^ Börja matchningen i början av strängen.
[^@\s]+ Matcha en eller flera förekomster av något annat tecken än @-tecknet eller blanksteget.
@ Matcha @-tecknet.
[^@\s]+ Matcha en eller flera förekomster av något annat tecken än @-tecknet eller blanksteget.
\. Matcha ett tecken med en punkt.
[^@\s]+ Matcha en eller flera förekomster av något annat tecken än @-tecknet eller blanksteget.
$ Avsluta matchningen i slutet av strängen.

Viktigt!

Det här reguljära uttrycket är inte avsett att täcka alla aspekter av en giltig e-postadress. Det tillhandahålls som ett exempel för att du ska kunna utöka efter behov.

Se även