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]$";

для людей, предлагающих использовать систему.сеть.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 5321 и RFC 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=против 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);
}

Я succinctified ответ Poyson 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. Поэтому нам нужно использовать regex в режиме US для проверки электронной почты. Если вы не используете режим 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

тест@[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. раздел "входные столбцы" выберите поле, содержащее адреса на "чтение и запись" (в 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

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 " отправьте письмо с подтверждением.
2. заставьте пользователя открыть письмо и нажмите ссылку, подтверждающую, что письмо реально.

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

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

local-part@domain

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

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

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

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

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

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

• foo.bar@bazbat.com

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

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

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