Код C# для проверки адреса электронной почты

Это старый вопрос, но все ответы, которые я нашел на SO, включая более поздние, отвечают аналогично этому. Однако в .Net 4.5 / MVC 4 Вы можете добавить проверку адреса электронной почты в форму, добавив аннотацию [EmailAddress] из системы.ComponentModel.DataAnnotations, поэтому мне было интересно, почему я не мог просто использовать встроенные функции из .Net в целом.

это, кажется, работает, и мне кажется, что это довольно элегантно:

using System.ComponentModel.DataAnnotations;

class ValidateSomeEmails
{
    static void Main(string[] args)
    {
        var foo = new EmailAddressAttribute();
        bool bar;
        bar = foo.IsValid("someone@somewhere.com");         //true
        bar = foo.IsValid("someone@somewhere.co.uk");       //true
        bar = foo.IsValid("someone+tag@somewhere.net");     //true
        bar = foo.IsValid("futureTLD@somewhere.fooo");      //true

        bar = foo.IsValid("fdsa");                          //false
        bar = foo.IsValid("fdsa@");                         //false
        bar = foo.IsValid("fdsa@fdsa");                     //false
        bar = foo.IsValid("fdsa@fdsa.");                    //false

        //one-liner
        if (new EmailAddressAttribute().IsValid("someone@somewhere.com"))
            bar = true;    
    }
}

.нетто 4.5 добавил

Я взял ответ Фила из #1 и создал этот класс. Назовем это так: bool isValid = Validator.EmailIsValid(emailString);

вот это класс:

using System.Text.RegularExpressions;

public static class Validator
{

    static Regex ValidEmailRegex = CreateValidEmailRegex();

    /// <summary>
    /// Taken from http://haacked.com/archive/2007/08/21/i-knew-how-to-validate-an-email-address-until-i.aspx
    /// </summary>
    /// <returns></returns>
    private static Regex CreateValidEmailRegex()
    {
        string validEmailPattern = @"^(?!\.)(""([^""\r\]|\[""\r\])*""|"
            + @"([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)"
            + @"@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$";

        return new Regex(validEmailPattern, RegexOptions.IgnoreCase);
    }

    internal static bool EmailIsValid(string emailAddress)
    {
        bool isValid = ValidEmailRegex.IsMatch(emailAddress);

        return isValid;
    }
}

Я использую этот метод одного лайнера, который делает работу за меня -

using System.ComponentModel.DataAnnotations;
public bool IsValidEmail(string source)
{
    return new EmailAddressAttribute().IsValid(source);
}

лично я бы сказал, что вы должны просто убедиться, что там есть символ@, возможно, с a . характер. Есть много регулярных выражений, которые вы могли бы использовать с различной корректностью, но я думаю, что большинство из них оставляют действительные адреса электронной почты или пропускают недействительные. Если люди хотят ввести поддельный адрес электронной почты, они будут вводить поддельный. Если вам нужно проверить, что адрес электронной почты является законным, и что человек контролирует этот адрес электронной почты, то вам нужно будет отправить им электронная почта со специальной кодированной ссылкой, чтобы они могли проверить, что это действительно реальный адрес.

Я думаю, что лучший способ осуществляется следующим образом:

    public static bool emailIsValid(string email)
    {
        string expresion;
        expresion = "\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*";
        if (Regex.IsMatch(email, expresion))
        {
            if (Regex.Replace(email, expresion, string.Empty).Length == 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }

вы можете иметь эту статическую функцию в общий класс.

самый элегантный способ-использовать встроенные методы .Net.

эти методы:

• испытаны и проверены. Эти методы используются в моих собственных профессиональных проектов.

• используйте регулярные выражения внутренне, которые надежны и быстры.

• сделано Microsoft для C#. Нет необходимости изобретать велосипед.

• возвращает результат bool. True означает, что электронная почта действительный.

для пользователей .Net 4.5 и выше

добавьте эту ссылку в свой проект:

Я считаю, что это регулярное выражение является хорошим компромиссом между проверкой чего-то большего, чем просто @ mark, и принятием странных крайних случаев:

^[^@\s]+@[^@\s]+(\.[^@\s]+)+$

Это, по крайней мере, заставит вас поставить что-то вокруг @ mark и поставить хотя бы нормальный домен.

короткий и точный код

public static bool IsValidEmail(this string email)
        {
            const string pattern = @"^(?!\.)(""([^""\r\]|\[""\r\])*""|" + @"([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)" + @"@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$";

            var regex = new Regex(pattern, RegexOptions.IgnoreCase);

            return regex.IsMatch(email);
        }

проверка адреса электронной почты не так просто, как может показаться. Это на самом деле теоретически невозможно полностью проверить адрес электронной почты, используя только регулярные выражения.

проверьте мои блоге об этом для обсуждения по этому вопросу и реализации F# с использованием FParsec. [/shameless_plug]

честно говоря, в производственном коде, лучшее, что я сделать, это проверить @ символ.

Я никогда не нахожусь в месте, чтобы полностью проверить электронную почту. Знаешь, как я вижу, действительно ли это было так? Если его отправят. Если это не так, это плохо, если это так, жизнь хороша. Это все, что мне нужно знать.

вот мой ответ - Решение Фила терпит неудачу для однобуквенных доменов, таких как "someone@q.com Верьте или нет, это используется =) (идет в centurylink, например).

ответ фила также будет работать только со стандартом PCRE... так что C# возьмет его, но javascript будет бомбить. Это слишком сложно для javascript. Таким образом, вы не можете использовать решение Фила для атрибутов проверки mvc.

вот мое регулярное выражение. Он будет хорошо работать с атрибутами проверки MVC.
- Все перед @ упрощается, так что хотя бы javascript будет работать. Я в порядке, расслабляя проверку здесь, пока exchange server не дает мне 5.1.3. - Все, что после @ - это решение Фила, измененное для однобуквенных доменов.

public const string EmailPattern =
        @"^\s*[\w\-\+_']+(\.[\w\-\+_']+)*\@[A-Za-z0-9]([\w\.-]*[A-Za-z0-9])?\.[A-Za-z][A-Za-z\.]*[A-Za-z]$";

для людей, предлагающих использовать system.net.mail MailMessage(), эта вещь является гибким способом. Конечно, C# примет электронное письмо, но тогда exchange server будет бомбить с ошибкой времени выполнения 5.1.3, как только вы попытаетесь отправить электронная почта.

Если вы действительно и я имею в виду действительно хочу знать, если адрес электронной почты действителен...попросите почтовый обменник доказать это, никаких регулярных выражений не требуется. Я могу предоставить код, если требуется.

выполнить следующие шаги: 1. имеет ли адрес электронной почты часть доменного имени? (индекс @ > 0) 2. использование DNS-запроса спросите, есть ли в домене почтовый обменник 3. открыть tcp соединение с почтовым обменником 4. используя протокол smtp, откройте сообщение на сервер, используя адрес электронной почты в качестве получателя 5. разбираем ответ сервера. 6. закройте сообщение, если вы сделали это так далеко, все хорошо.

Это, как вы можете себе представить, очень дорогое время мудрый и полагается на smtp, но он работает.

вообще говоря, регулярное выражение для проверки адресов электронной почты-это не простая вещь; на момент написания этой статьи синтаксис адреса электронной почты должен соответствовать относительно большому количеству стандартов, и реализация всех из них в регулярном выражении практически невозможна!

Я настоятельно рекомендую вам попробовать наш EmailVerify.NET, зрелая библиотека .NET, которая может проверять адреса электронной почты после все текущего Стандарты IETF (RFC 1123, который, согласно RFC 2821, по RFC 2822, в RFC 3696, в RFC 4291, в RFC и RFC 5321 5322), анализы соответствующие DNS-записи, проверяет, является ли целевой почтовые ящики могут принимать сообщения и могу даже сказать, если данный адрес является устранимым или нет.

отказ от ответственности: я ведущий разработчик для этого компонента.

For the simple email like goerge@xxx.com, below code is sufficient. 

 public static bool ValidateEmail(string email)
        {
            System.Text.RegularExpressions.Regex emailRegex = new System.Text.RegularExpressions.Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
            System.Text.RegularExpressions.Match emailMatch = emailRegex.Match(email);
            return emailMatch.Success;
        }

Проверьте строку электронной почты правильный формат или неправильный формат по System.Text.RegularExpressions:

    public static bool IsValidEmailId(string InputEmail)
    {
        Regex regex = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
        Match match = regex.Match(InputEmail);
        if (match.Success)
            return true;
        else
            return false;
    }

    protected void Email_TextChanged(object sender, EventArgs e)
    {
        String UserEmail = Email.Text;
        if (IsValidEmailId(UserEmail))
        {
            Label4.Text = "This email is correct formate";
        }
        else
        {
            Label4.Text = "This email isn't correct formate";
        }
    }

/с использованием внутренней регулярных выражений, используемых в создании "нового EmailAddressAttribute();" компонент .Серии net4.5 >>> Использование системы.ComponentModel.DataAnnotations; //Для проверки адреса электронной почты......Проверено и работает.

public bool IsEmail(string email)
{
    if (String.IsNullOrEmpty(email))
    {   return false;  }
    try
    {
        Regex _regex = new Regex("^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])" +
                "+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)" +
                "((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|" +
                "[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\u" +
                "FDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|" +
                "(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|" +
                "[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900" +
                "-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFF" +
                "EF])))\.?$", RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture | RegexOptions.Compiled);
        return _regex.IsMatch(email);
    }
    catch (RegexMatchTimeoutException)
    {
        return false;
    }
}

кроме того, вы можете использовать это:

http://msdn.microsoft.com/en-us/library/01escwtf (v=vs. 110). aspx

вот ответ на ваш вопрос для вас, чтобы проверить.

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

public class RegexUtilities
{    
   public bool IsValidEmail(string strIn)
   {
       if (String.IsNullOrEmpty(strIn))
       {
          return false;

       }

       // Use IdnMapping class to convert Unicode domain names.

       try 
       {
          strIn = Regex.Replace(strIn, @"(@)(.+)$", this.DomainMapper, RegexOptions.None, TimeSpan.FromMilliseconds(200));

       }
       catch (RegexMatchTimeoutException) 
       {
           return false;

       }

       if (invalid)
       {
           return false;

       }

       // Return true if strIn is in valid e-mail format.    

       try 
       {
          return Regex.IsMatch(strIn, @"^(?("")("".+?(?<!\)""@)|(([0-9a-z]((\.(?!\.))|       [-!#$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-\w]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9]))$", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250));

       }
       catch (RegexMatchTimeoutException) 
       {
          return false;

       }

   }


   private string DomainMapper(Match match)
   {
      // IdnMapping class with default property values.

      IdnMapping idn = new IdnMapping();

      string domainName = match.Groups[2].Value;

      try 
      {
         domainName = idn.GetAscii(domainName);

      }
      catch (ArgumentException) 
      {
         invalid = true;

      }

      return match.Groups[1].Value + domainName;

   }

}

private static bool IsValidEmail(string emailAddress)
{
    const string validEmailPattern = @"^(?!\.)(""([^""\r\]|\[""\r\])*""|"
                                     + @"([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)"
                                     + @"@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$";

    return new Regex(validEmailPattern, RegexOptions.IgnoreCase).IsMatch(emailAddress);
}

Я сжал ответ Пойсона 1 так:

public static bool IsValidEmailAddress(string candidateEmailAddr)
{
    string regexExpresion = "\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*";
    return (Regex.IsMatch(candidateEmailAddr, regexExpresion)) && 
           (Regex.Replace(candidateEmailAddr, regexExpresion, string.Empty).Length == 0);
}

Я написал функцию, чтобы проверить, если письмо действительно или нет. Кажется, это хорошо работает для меня в большинстве случаев.

результаты:

dasddas-@.com => FALSE
-asd@das.com => FALSE
as3d@dac.coas- => FALSE
dsq!a?@das.com => FALSE
_dasd@sd.com => FALSE
dad@sds => FALSE
asd-@asd.com => FALSE
dasd_-@jdas.com => FALSE
asd@dasd@asd.cm => FALSE
da23@das..com => FALSE
_dasd_das_@9.com => FALSE

d23d@da9.co9 => TRUE
dasd.dadas@dasd.com => TRUE
dda_das@das-dasd.com => TRUE
dasd-dasd@das.com.das => TRUE

код:

    private bool IsValidEmail(string email)
    {
        bool valid = false;
        try
        {
            var addr = new System.Net.Mail.MailAddress(email);
            valid = true;
        }
        catch
        {
            valid = false;
            goto End_Func;
        }

        valid = false;
        int pos_at = email.IndexOf('@');
        char checker = Convert.ToChar(email.Substring(pos_at + 1, 1));
        var chars = "qwertyuiopasdfghjklzxcvbnm0123456789";
        foreach (char chr in chars)
        {
            if (checker == chr)
            {
                valid = true;
                break;
            }
        }
        if (valid == false)
        {
            goto End_Func;
        } 

        int pos_dot = email.IndexOf('.', pos_at + 1);
        if(pos_dot == -1)
        {
            valid = false;
            goto End_Func;
        }

        valid = false;
        try
        {
            checker = Convert.ToChar(email.Substring(pos_dot + 1, 1));
            foreach (char chr in chars)
            {
                if (checker == chr)
                {
                    valid = true;
                    break;
                }
            }
        }
        catch
        {
            valid = false;
            goto End_Func;
        }

        Regex valid_checker = new Regex(@"^[a-zA-Z0-9_@.-]*$");
        valid = valid_checker.IsMatch(email);
        if (valid == false)
        {
            goto End_Func;
        }

        List<int> pos_list = new List<int> { };
        int pos = 0;
        while (email.IndexOf('_', pos) != -1)
        {
            pos_list.Add(email.IndexOf('_', pos));
            pos = email.IndexOf('_', pos) + 1;
        }

        pos = 0;
        while (email.IndexOf('.', pos) != -1)
        {
            pos_list.Add(email.IndexOf('.', pos));
            pos = email.IndexOf('.', pos) + 1;
        }

        pos = 0;
        while (email.IndexOf('-', pos) != -1)
        {
            pos_list.Add(email.IndexOf('-', pos));
            pos = email.IndexOf('-', pos) + 1;
        }

        int sp_cnt = pos_list.Count();
        pos_list.Sort();
        for (int i = 0; i < sp_cnt - 1; i++)
        {
            if (pos_list[i] + 1 == pos_list[i + 1])
            {
                valid = false;
                break;
            }

            if (pos_list[i]+1 == pos_at || pos_list[i]+1 == pos_dot)
            {
                valid = false;
                break;
            }
        }

        if(valid == false)
        {
            goto End_Func;
        }

        if (pos_list[sp_cnt - 1] == email.Length - 1 || pos_list[0] == 0)
        {
            valid = false;
        }

    End_Func:;
        return valid;
    }

простой способ идентификации emailid является допустимым или нет.

public static bool EmailIsValid(string email)
{
        return Regex.IsMatch(email, @"^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$");
}

существует проблема культуры в регулярном выражении в C#, а не js. Поэтому нам нужно использовать регулярное выражение в режиме США для проверки электронной почты. Если вы не используете режим ECMAScript, ваши специальные символы языка подразумеваются в A-Z с регулярным выражением.

Regex.IsMatch(email, @"^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9_\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$", RegexOptions.ECMAScript)

я использовал это регулярное выражение, так как оно успешно проверяет запятые, комментарии, символы Юникода и IP(v4) доменные адреса.

допустимые адреса будут:

" "@example.org

(комментарий)test@example.org

тест@example.org

ტესტი@example.org

test@[192.168.1.1]

 public const string REGEX_EMAIL = @"^(((\([\w!#$%&'*+\/=?^_`{|}~-]*\))?[^<>()[\]\.,;:\s@\""]+(\.[^<>()[\]\.,;:\s@\""]+)*)|(\"".+\""))(\([\w!#$%&'*+\/=?^_`{|}~-]*\))?@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$";

в случае, если вы используете FluentValidation вы могли бы написать что-то простое, как это:

public cass User
{
    public string Email { get; set; }
}

public class UserValidator : AbstractValidator<User>
{
    public UserValidator()
    {
        RuleFor(x => x.Email).EmailAddress().WithMessage("The text entered is not a valid email address.");
    }
}

// Validates an user. 
var validationResult = new UserValidator().Validate(new User { Email = "açflkdj" });

// This will return false, since the user email is not valid.
bool userIsValid = validationResult.IsValid;

на основе ответа @Cogwheel я хочу поделиться модифицированным решением, которое работает для SSIS и "компонента скрипта":

1. поместите "компонент сценария" в свой поток данных connect, а затем откройте его.
2. в разделе "входные столбцы" установите для поля, содержащего адреса электронной почты, значение "ReadWrite" (в Примере 'fieldName').
3. вернитесь в раздел " скрипт "и нажмите на кнопку"Редактировать скрипт". Тогда вам нужно подождать после кода открытие.

4. поместите этот код в метод правильный:

   public override void Input0_ProcessInputRow(Input0Buffer Row)
   {
       string email = Row.fieldName;
   
       try
       {
           System.Net.Mail.MailAddress addr = new System.Net.Mail.MailAddress(email);
           Row.fieldName= addr.Address.ToString();
       }
       catch
       {
           Row.fieldName = "WRONGADDRESS";
       }
   }
   

затем вы можете использовать условное разделение, чтобы отфильтровать все недопустимые записи или все, что вы хотите сделать.

небольшая модификация @Cogwheel answer

public static bool IsValidEmail(this string email)
{
  // skip the exception & return early if possible
  if (email.IndexOf("@") <= 0) return false;

  try
  {
    var address = new MailAddress(email);
    return address.Address == email;
  }
  catch
  {
    return false;
  }
}

1. в" try block " отправить письмо с подтверждением.
2. заставьте пользователя открыть письмо и нажмите ссылку, подтверждающую, что письмо реально.

пока этот процесс не завершится успешно, электронная почта считается недействительной.

некоторое время назад, я написал EmailAddressValidationAttribute, что следует правильно проверить почти любой относительно нормальный адрес электронной почты вида

local-part@domain

это System.ComponentModel.DataAnnotations.ValidationAttribute, Так что использование очень просто.

и, так как копать через все RFC и ошибки и собирать все биты, необходимые для правильного перечисления всех правил...скучно - в лучшем случае! - Я разместил исходный код валидатора в мой ответ: на вопрос Адрес Электронной Почты C# проверка в исходном коде.

мой валидатор не идеален с любой точки зрения, хотя для начала у него нет встроенной поддержки для проверки javascript на стороне клиента, хотя это было бы не слишком сложно добавить. Из моего ответа выше:

вот атрибут проверки, который я написал. Он проверяет почти каждый "сырой" адрес электронной почты адрес, то есть те формы local-part@domain. Оно не поддерживает другой-больше...творческие конструкции, которые разрешают RFC (этот список не является всеобъемлющий любыми средствами):

• комментарии (например, jsmith@whizbang.com (work))
• строки в кавычках (экранированный текст, чтобы разрешить символы, не разрешенные в атоме)
• домен литералы (например,foo@[123.45.67.012])
• bang-paths (aka source routing)
• угол адресов (например,John Smith <jsmith@whizbang.com>)
• складной пробел
• двухбайтовые символы В либо local-part или домен (только 7-битный ASCII).
• etc.

он должен принимать почти любой адрес электронной почты, который может быть выражен таким образом

• foo.bar@bazbat.com

не требуя использования кавычек ("), угловые скобки ('') или квадратные скобки ([]).

не предпринимается никаких попыток проверить, что самый правый dns метка в домен является допустимым TLD (домен верхнего уровня). Это связано с тем, что список дву сейчас намного больше, чем "Биг-6" (.ком, .Эду .гов, .мил .Нэт .орг) плюс 2-буквенных кодов стран ISO. ICANN фактически обновляет список дву ежедневно, хотя я подозреваю, что список на самом деле не меняется ежедневно. Кроме того, [ICANN только что одобрила большое расширение общее пространство имен TLD][2]). И некоторые адреса электронной почты не имеют того, что вы бы узнали как TLD (сделал ты же знаешь, что postmaster@. является ли теоретически допустимым и почтовым? Почта по этому адресу должен быть доставлен почтмейстер корневой зоны DNS.)

расширение регулярного выражения для поддержки литералов домена не должно быть слишком сложным.