Каков самый элегантный код для проверки правильности того, что строка является допустимым адресом электронной почты?
Код С# для проверки адреса электронной почты
Ответ 1
Как насчет этого?
bool IsValidEmail(string email)
{
try {
var addr = new System.Net.Mail.MailAddress(email);
return addr.Address == email;
}
catch {
return false;
}
}
Чтобы уточнить, возникает вопрос, является ли конкретная строка действительным представлением адреса электронной почты, а не является ли адрес электронной почты допустимым местом назначения для отправки сообщения. Для этого единственный реальный способ - это отправить сообщение для подтверждения.
Обратите внимание, что адреса электронной почты более простительны, чем вы можете себе представить. Это все совершенно правильные формы:
- зубчатое колесо
- "зубчатое колесо апельсина" @example.com
- [email protected]$.xyz
В большинстве случаев ложное "недействительное" гораздо хуже для ваших пользователей и проверки в будущем, чем ложное "действительное". Вот статья, которая раньше была принятым ответом на этот вопрос (этот ответ с тех пор был удален). В нем есть гораздо больше деталей и некоторые другие идеи о том, как решить проблему.
Обеспечение проверок работоспособности - все еще хорошая идея для пользовательского опыта. Предполагая, что адрес электронной почты действителен, вы можете искать известные домены верхнего уровня, проверять домен на наличие записи MX, проверять орфографические ошибки из общих доменных имен (gmail.cmo) и т.д. Затем выдает предупреждение, дающее пользователю возможность сказать "да, мой почтовый сервер действительно позволяет 🌮🍳🎁 в качестве адреса электронной почты".
Что касается использования обработки исключений для бизнес-логики, я согласен, что этого следует избегать. Но это один из тех случаев, когда удобство и ясность могут перевесить догму.
Кроме того, если вы делаете что-либо еще с адресом электронной почты, это, вероятно, будет связано с превращением его в почтовый адрес. Даже если вы не используете эту точную функцию, вы, вероятно, захотите использовать тот же шаблон. Вы также можете проверить наличие определенных типов сбоев, перехватывая различные исключения: пустой, пустой или неверный формат.
Согласно комментарию Стюарта, это сравнивает окончательный адрес с исходной строкой, а не всегда возвращает true. MailAddress пытается разобрать строку с пробелами в части "Отображаемое имя" и "Адрес", поэтому исходная версия возвращала ложные срабатывания.
--- Дальнейшее чтение ---
Документация для System.Net.Mail.MailAddress
Объяснение того, что составляет действительный адрес электронной почты
Ответ 2
Это старый вопрос, но все ответы, которые я нашел на SO, включая более поздние, отвечают аналогично этому. Однако в .Net 4.5/MVC 4 вы можете добавить проверку адреса электронной почты в форму, добавив аннотацию [EmailAddress] из System.ComponentModel.DataAnnotations, поэтому мне было интересно, почему я не мог просто использовать встроенную функциональность. Сеть в целом.
Кажется, это работает, и мне кажется довольно элегантным:
using System.ComponentModel.DataAnnotations;
class ValidateSomeEmails
{
static void Main(string[] args)
{
var foo = new EmailAddressAttribute();
bool bar;
bar = foo.IsValid("[email protected]"); //true
bar = foo.IsValid("[email protected]"); //true
bar = foo.IsValid("[email protected]"); //true
bar = foo.IsValid("[email protected]"); //true
bar = foo.IsValid("fdsa"); //false
bar = foo.IsValid("[email protected]"); //false
bar = foo.IsValid("[email protected]"); //false
bar = foo.IsValid("[email protected]"); //false
//one-liner
if (new EmailAddressAttribute().IsValid("[email protected]"))
bar = true;
}
}
Ответ 3
Я использую этот метод с одним вкладышем, который выполняет работу для me-
using System.ComponentModel.DataAnnotations;
public bool IsValidEmail(string source)
{
return new EmailAddressAttribute().IsValid(source);
}
Согласно комментариям, это "не получится", если source (адрес электронной почты) является нулевым.
public static bool IsValidEmailAddress(this string address) => address != null && new EmailAddressAttribute().IsValid(address);
Ответ 4
.net 4.5 добавлено System.ComponentModel.DataAnnotations.EmailAddressAttribute
Вы можете просмотреть источник EmailAddressAttribute, это регулярное выражение, которое оно использует внутри:
const string pattern = @"^((([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\uFDF0-\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-\uFFEF])))\.?$";
Ответ 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;
}
}
Ответ 6
Лично я бы сказал, что вы должны просто убедиться, что там есть символ @, возможно, a. персонаж. Там много регулярных выражений, которые вы могли бы использовать с различной правильностью, но я думаю, что большинство из них не учитывают действительные адреса электронной почты или пропускают недействительные. Если люди хотят ввести поддельный адрес электронной почты, они будут помещены в поддельный. Если вам нужно проверить, что адрес электронной почты является законным, и что человек контролирует этот адрес электронной почты, вам нужно будет отправить им электронное письмо со специальной кодированной ссылкой, чтобы они могли убедиться, что это действительно настоящий адрес.
Ответ 7
Я думаю, что лучший способ заключается в следующем:
public static bool EmailIsValid(string email)
{
string expression = "\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
if (Regex.IsMatch(email, expression))
{
if (Regex.Replace(email, expression, string.Empty).Length == 0)
{
return true;
}
}
return false;
}
Вы можете использовать эту статическую функцию в общем классе.
Ответ 8
Самый элегантный способ - использовать встроенные методы .Net.
Эти методы:
-
Пробовали и тестировали. Эти методы используются в моих собственных профессиональных проектах.
-
Используйте регулярные выражения, которые являются надежными и быстрыми.
-
Сделано Microsoft для С#. Нет необходимости изобретать велосипед.
-
Вернуть результат bool. True означает, что письмо действительно.
Для пользователей .Net 4.5 и выше
Добавьте ссылку на свой проект:
System.ComponentModel.DataAnnotations
Теперь вы можете использовать следующий код:
(new EmailAddressAttribute().IsValid("[email protected]"));
Пример использования
Вот несколько способов объявления:
protected List<string> GetRecipients() // Gets recipients from TextBox named `TxtRecipients`
{
List<string> MethodResult = null;
try
{
List<string> Recipients = TxtRecipients.Text.Replace(",",";").Replace(" ", "").Split(';').ToList();
List<string> RecipientsCleaned = new List<string>();
foreach (string Recipient in RecipientsCleaned)
{
if (!String.IsNullOrWhiteSpace(Recipient))
{
RecipientsNoBlanks.Add(Recipient);
}
}
MethodResult = RecipientsNoBlanks;
}
catch//(Exception ex)
{
//ex.HandleException();
}
return MethodResult;
}
public static bool IsValidEmailAddresses(List<string> recipients)
{
List<string> InvalidAddresses = GetInvalidEmailAddresses(recipients);
return InvalidAddresses != null && InvalidAddresses.Count == 0;
}
public static List<string> GetInvalidEmailAddresses(List<string> recipients)
{
List<string> MethodResult = null;
try
{
List<string> InvalidEmailAddresses = new List<string>();
foreach (string Recipient in recipients)
{
if (!(new EmailAddressAttribute().IsValid(Recipient)) && !InvalidEmailAddresses.Contains(Recipient))
{
InvalidEmailAddresses.Add(Recipient);
}
}
MethodResult = InvalidEmailAddresses;
}
catch//(Exception ex)
{
//ex.HandleException();
}
return MethodResult;
}
... и код, демонстрирующий их в действии:
List<string> Recipients = GetRecipients();
bool IsValidEmailAddresses = IsValidEmailAddresses(Recipients);
if (IsValidEmailAddresses)
{
//Emails are valid. Your code here
}
else
{
StringBuilder sb = new StringBuilder();
sb.Append("The following addresses are invalid:");
List<string> InvalidEmails = GetInvalidEmailAddresses(Recipients);
foreach (string InvalidEmail in InvalidEmails)
{
sb.Append("\n" + InvalidEmail);
}
MessageBox.Show(sb.ToString());
}
Кроме того, этот пример:
- Выходит за пределы спецификации, поскольку одна строка используется для размещения 0, одного или нескольких адресов электронной почты, переданных с помощью двоеточия
;. - Четко демонстрирует, как использовать метод IsValid объекта EmailAddressAttribute.
Альтернатива, для пользователей версии .Net менее 4,5
В ситуациях, когда .NET 4.5 недоступен, я использую следующее решение:
В частности, я использую:
public static bool IsValidEmailAddress(string emailAddress)
{
bool MethodResult = false;
try
{
MailAddress m = new MailAddress(emailAddress);
MethodResult = m.Address == emailAddress;
}
catch //(Exception ex)
{
//ex.HandleException();
}
return MethodResult;
}
public static List<string> GetInvalidEmailAddresses(List<string> recipients)
{
List<string> MethodResult = null;
try
{
List<string> InvalidEmailAddresses = new List<string>();
foreach (string Recipient in recipients)
{
if (!IsValidEmail(Recipient) && !InvalidEmailAddresses.Contains(Recipient))
{
InvalidEmailAddresses.Add(Recipient);
}
}
MethodResult = InvalidEmailAddresses;
}
catch //(Exception ex)
{
//ex.HandleException();
}
return MethodResult;
}
Ответ 9
Короткий и точный код
public static bool IsValidEmail(this string email)
{
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);
}
Ответ 10
Честно говоря, в производственном коде лучше всего проверить символ @.
Я никогда не могу полностью проверять электронные письма. Вы знаете, как я вижу, действительно ли это действительно? Если он был отправлен. Если это не так, это плохо, если так, жизнь хорошая. Это все, что мне нужно знать.
Ответ 11
Я нахожу это регулярное выражение хорошим компромиссом между проверкой чего-то большего, чем просто знака @, и принятия странных краевых случаев:
^[^@\s][email protected][^@\s]+(\.[^@\s]+)+$
Он по крайней мере заставит вас поместить что-то вокруг знака @и поместить хотя бы нормально выглядящий домен.
Ответ 12
Проверка адреса электронной почты не так проста, как может показаться. На самом деле теоретически невозможно полностью проверить адрес электронной почты, используя только регулярное выражение.
Отправляйте сообщение в блоге об этом для обсуждения темы и реализации F # с использованием FParsec. [/Shameless_plug]
Ответ 13
Здесь мой ответ - решение Фила не подходит для однобуквенных доменов, таких как "[email protected]". Верьте или нет, что используется =) (например, идет к centurylink).
Ответ Фила также будет работать только с стандартом PCRE... поэтому С# возьмет его, но javascript собирается бомбить. Это слишком сложно для javascript. Таким образом, вы не можете использовать решение Phil для атрибутов проверки mvc.
Здесь мое регулярное выражение. Это будет хорошо работать с атрибутами проверки MVC.
- Все до @упрощается, так что будет работать хотя бы javascript. Я хорошо разбираюсь в проверке здесь, пока сервер обмена не дает мне 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(), эта вещь является ПУТЕМ гибкой. Конечно, С# будет принимать сообщение электронной почты, но тогда обменный сервер будет бомбить с ошибкой выполнения 5.1.3, как только вы попытаетесь отправить электронное письмо.
Ответ 14
Если вы действительно и я имею в виду, действительно хотите узнать, действительно ли адрес электронной почты... спросите почтовый обменник, чтобы доказать это, не нужно регулярное выражение. Я могу предоставить код, если потребуется.
Общие шаги заключаются в следующем: 1. имеет ли адрес электронной почты часть имени домена? (индекс @ > 0) 2. с использованием DNS-запроса спросите, есть ли в домене почтовый обменник 3. Откройте соединение tcp с почтовым обменником. 4. используя протокол smtp, откройте сообщение на сервере, используя адрес электронной почты в качестве приемника 5. Разберите ответ сервера. 6. выйти из сообщения, если вы сделали это так далеко, все хорошо.
Это, как вы можете себе представить, очень дорогое время и полагается на smtp, но оно работает.
Ответ 15
Вообще говоря, регулярное выражение для проверки адресов электронной почты не так просто: на момент написания этой статьи синтаксис адреса электронной почты должен соответствовать относительно большому числу стандартов, и реализация их всех в рамках регулярного выражения практически неосуществима!
Я настоятельно рекомендую вам попробовать EmailVerify.NET, зрелую библиотеку .NET, которая может проверять адреса электронной почты, следующие за all(RFC 1123, RFC 2821, RFC 2822, RFC 3696, RFC 4291, RFC 5321 и RFC 5322), проверяет связанные записи DNS, проверяет, могут ли целевые почтовые ящики принимать сообщения и могут даже сказать, данный адрес является одноразовым или нет.
Отказ от ответственности: я являюсь ведущим разработчиком этого компонента.
Ответ 16
For the simple email like [email protected], 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;
}
Ответ 17
небольшая модификация ответа @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;
}
}
Ответ 18
Здесь много сильных ответов. Однако я рекомендую сделать шаг назад. @Cogwheel отвечает на вопрос fooobar.com/questions/25907/.... Тем не менее, это может быть дорогостоящим в сценарии массовой проверки, если многие из проверяемых адресов электронной почты являются недействительными. Я предлагаю использовать немного логики, прежде чем мы войдем в его блок try-catch. Я знаю, что следующий код может быть написан с использованием RegEx, но это может быть дорогостоящим для новых разработчиков. Это моя двойная стоимость:
public static bool IsEmail(this string input)
{
if (string.IsNullOrWhiteSpace(input)) return false;
// MUST CONTAIN ONE AND ONLY ONE @
var atCount = input.Count(c => c == '@');
if (atCount != 1) return false;
// MUST CONTAIN PERIOD
if (!input.Contains(".")) return false;
// @ MUST OCCUR BEFORE LAST PERIOD
var indexOfAt = input.IndexOf("@", StringComparison.Ordinal);
var lastIndexOfPeriod = input.LastIndexOf(".", StringComparison.Ordinal);
var atBeforeLastPeriod = lastIndexOfPeriod > indexOfAt;
if (!atBeforeLastPeriod) return false;
// CODE FROM COGWHEEL ANSWER: /questions/25907/c-code-to-validate-email-address/189439#189439
try
{
var addr = new System.Net.Mail.MailAddress(input);
return addr.Address == input;
}
catch
{
return false;
}
}
Ответ 19
Ответ с наибольшим количеством голосов от @Cogwheel - лучший ответ, однако я попытался реализовать метод строки trim() чтобы он урезал все пустое пространство пользователя от начала до конца строки. Проверьте код ниже для полной example-
bool IsValidEmail(string email)
{
try
{
email = email.Trim();
var addr = new System.Net.Mail.MailAddress(email);
return addr.Address == email;
}
catch
{
return false;
}
}
Ответ 20
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);
}
Ответ 21
Проверьте строку электронной почты в правильном формате или неправильном формате 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";
}
}
Ответ 22
/Использование внутреннего регулярного выражения, используемого при создании "new EmailAddressAttribute();" компонент в .Net4.5 → > с использованием System.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
Ответ 23
Я согласился ответить 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);
}
Ответ 24
Вот ответ на ваш вопрос, который вы можете проверить.
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;
}
}
Ответ 25
Я написал функцию для проверки правильности адреса электронной почты. В большинстве случаев это работает хорошо для меня.
Результаты:
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected]@asd.cm => FALSE
[email protected] => FALSE
[email protected] => FALSE
[email protected] => TRUE
[email protected] => TRUE
[email protected] => TRUE
[email protected] => 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(@"^[[email protected]]*$");
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;
}
Ответ 26
Простой способ идентификации электронной почты действителен или нет.
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})(\]?)$");
}
Ответ 27
Существует проблема с культурой в регулярном выражении в С#, а не в js. Поэтому нам нужно использовать регулярное выражение в режиме 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)
Ответ 28
Я закончил использование этого регулярного выражения, так как он успешно проверяет запятые, комментарии, символы Unicode и IP-адреса (v4).
Допустимыми адресами будут:
"" @example.org
(комментарий) [email protected]
тест@example.org
ტესტი @example.org
тест @[192.168.1.1]
public const string REGEX_EMAIL = @"^(((\([\w!#$%&'*+\/=?^_`{|}~-]*\))?[^<>()[\]\\.,;:\[email protected]\""]+(\.[^<>()[\]\\.,;:\[email protected]\""]+)*)|(\"".+\""))(\([\w!#$%&'*+\/=?^_`{|}~-]*\))[email protected]((\[[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,}))$";
Ответ 29
Простой, не используя Regex (который мне не нравится при его плохой читаемости):
bool IsValidEmail(string email)
{
string emailTrimed = email.Trim();
if (!string.IsNullOrEmpty(emailTrimed))
{
bool hasWhitespace = emailTrimed.Contains(" ");
int indexOfAtSign = emailTrimed.LastIndexOf('@');
if (indexOfAtSign > 0 && !hasWhitespace)
{
string afterAtSign = emailTrimed.Substring(indexOfAtSign + 1);
int indexOfDotAfterAtSign = afterAtSign.LastIndexOf('.');
if (indexOfDotAfterAtSign > 0 && afterAtSign.Substring(indexOfDotAfterAtSign).Length > 1)
return true;
}
}
return false;
}
Примеры:
-
IsValidEmail("@b.com") // false -
IsValidEmail("[email protected]") // false -
IsValidEmail("[email protected]") // false -
IsValidEmail("[email protected]") // false -
IsValidEmail("[email protected]") // false -
IsValidEmail("a [email protected]") // false -
IsValidEmail("[email protected] c.com") // false -
IsValidEmail("[email protected]") // true -
IsValidEmail("[email protected]") // true -
IsValidEmail("[email protected]") // true -
IsValidEmail("[email protected]") // true
Он должен быть простым и, следовательно, он не касается редких случаев, таких как электронные письма с заключенными в скобки доменами, которые содержат пробелы (обычно разрешены), электронные письма с адресами IPv6 и т.д.
Ответ 30
Если вы используете 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;