Я использую этот
@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$"
regexp для проверки электронной почты
([\w\.\-]+) - это для домена первого уровня (много букв и цифр, также точка и дефис) ([\w\-]+) - это для домена второго уровня ((\.(\w){2,3})+) - и это для других доменов уровня (от 3 до бесконечности), которые включают точку и 2 или 3 литерала
что не так с этим регулярным выражением?
EDIT: он не соответствует электронной почте "[email protected]"
TLD, подобные .museum, не сопоставляются таким образом, и есть несколько других длинных TLD. Кроме того, вы можете проверить адреса электронной почты, используя класс MailAddress, поскольку Microsoft объясняет здесь в примечании:
Вместо использования регулярного выражения для проверки адреса электронной почты, вы можете использовать класс System.Net.Mail.MailAddress. Определить действительно ли адрес электронной почты действителен, передать адрес электронной почты в MailAddress.MailAddress(String).
public bool IsValid(string emailaddress)
{
try
{
MailAddress m = new MailAddress(emailaddress);
return true;
}
catch (FormatException)
{
return false;
}
}
Это экономит много головных болей, потому что вам не нужно писать (или пытаться понять чужое) регулярное выражение.
Я думаю, что @"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$" должен работать.
Вам нужно написать это как
string email = txtemail.Text;
Regex regex = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
Match match = regex.Match(email);
if (match.Success)
Response.Write(email + " is correct");
else
Response.Write(email + " is incorrect");
Будьте предупреждены, что это произойдет, если:
Под символом @ имеется поддомен.
Вы используете TLD с длиной больше 3, например .info
У меня есть выражение для проверки адресов электронной почты, которые я использую.
Поскольку ни один из вышеперечисленных документов не был настолько коротким и точным, как мой, я решил опубликовать его здесь.
@"^[\w!#$%&'*+\-/=?\^_'{|}~]+(\.[\w!#$%&'*+\-/=?\^_'{|}~]+)*"
+ "@"
+ @"((([\-\w]+\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\.){3}[0-9]{1,3}))$";
Подробнее об этом читайте здесь: С# - Регулярное выражение электронной почты
Кроме того, это проверяет достоверность RFC на основе синтаксиса электронной почты, а не на наличие электронной почты. Единственный способ проверить, действительно ли электронная почта существует, - это отправить и отправить электронное письмо, а пользователь должен подтвердить, что он получил электронное письмо, щелкнув ссылку или введя токен.
Затем существуют одноразовые домены, такие как Mailinator.com и другие. Это не делает ничего, чтобы проверить, является ли электронная почта от одноразового домена или нет.
Я нашел для него хороший документ на MSDN.
Практическое руководство. Убедитесь, что строки в действительном формате электронной почты http://msdn.microsoft.com/en-us/library/01escwtf.aspx (проверьте, что этот код также поддерживает использование символов, отличных от ASCII, для имен доменов в Интернете.)
Есть 2 реализации, для .Net 2.0/3.0 и для .Net 3.5 и выше.
версия 2.0/3.0:
bool IsValidEmail(string strIn)
{
// Return true if strIn is in valid e-mail format.
return Regex.IsMatch(strIn, @"^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$");
}
Мои тесты по этому методу дают:
Invalid: @majjf.com
Invalid: [email protected]@[email protected]
Invalid: Abc.example.com
Valid: [email protected]
Valid: [email protected]
Invalid: js*@proseware.com
Invalid: [email protected]
Valid: [email protected]
Valid: [email protected]
Invalid: [email protected]@jjf.com
Invalid: [email protected]
Invalid: [email protected]
Invalid: [email protected]
Invalid: [email protected]
Invalid: [email protected]
Valid: [email protected]
Invalid: -------
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Invalid: [email protected]
Valid: [email protected][129.126.118.1]
Valid: [email protected]
Invalid: js#[email protected]
Invalid: [email protected]
Invalid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Invalid: [email protected]
Invalid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Valid: [email protected]
Это не соответствует всем требованиям RFC 5321 и 5322, но работает со следующими определениями.
@"^([0-9a-zA-Z]([\+\-_\.][0-9a-zA-Z]+)*)+"@(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]*\.)+[a-zA-Z0-9]{2,17})$";
Ниже приведен код
const String pattern =
@"^([0-9a-zA-Z]" + //Start with a digit or alphabetical
@"([\+\-_\.][0-9a-zA-Z]+)*" + // No continuous or ending +-_. chars in email
@")+" +
@"@(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]*\.)+[a-zA-Z0-9]{2,17})$";
var validEmails = new[] {
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]",
};
var invalidEmails = new[] {
"Abc.example.com", // No `@`
"[email protected]@[email protected]", // multiple `@`
"[email protected]", // continuous multiple dots in name
"[email protected]", // only 1 char in extension
"[email protected]", // continuous multiple dots in domain
"[email protected]@jjf.com", // continuous multiple `@`
"@majjf.com", // nothing before `@`
"[email protected]", // nothing after `.`
"[email protected]", // nothing after `_`
"[email protected]", // no domain extension
"[email protected]", // nothing after `_` and .
"[email protected]", // nothing after `.`
};
foreach (var str in validEmails)
{
Console.WriteLine("{0} - {1} ", str, Regex.IsMatch(str, pattern));
}
foreach (var str in invalidEmails)
{
Console.WriteLine("{0} - {1} ", str, Regex.IsMatch(str, pattern));
}
Следующий код основан на реализации аннотаций Microsoft Data на github, и я считаю его наиболее полной проверкой электронной почты:
public static Regex EmailValidation()
{
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])))\.?$";
const RegexOptions options = RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture;
// Set explicit regex match timeout, sufficient enough for email parsing
// Unless the global REGEX_DEFAULT_MATCH_TIMEOUT is already set
TimeSpan matchTimeout = TimeSpan.FromSeconds(2);
try
{
if (AppDomain.CurrentDomain.GetData("REGEX_DEFAULT_MATCH_TIMEOUT") == null)
{
return new Regex(pattern, options, matchTimeout);
}
}
catch
{
// Fallback on error
}
// Legacy fallback (without explicit match timeout)
return new Regex(pattern, options);
}
Лучшее регулярное выражение для проверки электронной почты
[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?
И это использование: -
bool isEmail = Regex.IsMatch(emailString, @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z", RegexOptions.IgnoreCase);
Попробуйте это для размера:
public static bool IsValidEmailAddress(this string s)
{
var regex = new Regex(@"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?");
return regex.IsMatch(s);
}
Попробуйте, это работает для меня:
public bool IsValidEmailAddress(string s)
{
if (string.IsNullOrEmpty(s))
return false;
else
{
var regex = new Regex(@"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");
return regex.IsMatch(s) && !s.EndsWith(".");
}
}
Это предотвращает недействительные сообщения, указанные другими в комментариях:
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
Он также предотвращает электронные письма с двойными точками:
[email protected]
Попробуйте протестировать его с таким количеством недействительных адресов электронной почты, как вы можете найти.
using System.Text.RegularExpressions;
public static bool IsValidEmail(string email)
{
return Regex.IsMatch(email, @"\A[a-z0-9]+([-._][a-z0-9]+)*@([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,4}\z")
&& Regex.IsMatch(email, @"^(?=.{1,64}@.{4,64}$)(?=.{6,100}$).*");
}
См. проверить адрес электронной почты, используя регулярное выражение в С#.
Почему бы не использовать проверку подлинности на основе атрибутов на основе EF6?
Как вы можете видеть выше, для проверки правильности регулярных выражений для электронной почты всегда есть небольшое отверстие. Если вы используете аннотации данных EF6, вы можете легко добиться надежной и более сильной проверки электронной почты с помощью атрибута аннотации данных EmailAddress. Мне пришлось удалить проверку регулярных выражений, которую я использовал ранее для электронной почты, когда у меня возникла ошибка регулярного выражения мобильного устройства в поле ввода электронной почты. Когда атрибут аннотации данных используется для проверки электронной почты, проблема с мобильностью была решена.
public class LoginViewModel
{
[EmailAddress(ErrorMessage = "The email format is not valid")]
public string Email{ get; set; }
Это регулярное выражение работает отлично:
bool IsValidEmail(string email)
{
return Regex.IsMatch(email, @"^[\w!#$%&'*+\-/=?\^_'{|}~]+(\.[\w!#$%&'*+\-/=?\^_'{|}~]+)*@((([\-\w]+\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\.){3}[0-9]{1,3}))\z");
}
new System.ComponentModel.DataAnnotations.EmailAddressAttribute().IsValid(input)
public static bool ValidateEmail(string str)
{
return Regex.IsMatch(str, @"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");
}
Я использую приведенный выше код для проверки адреса электронной почты.
public bool VailidateEntriesForAccount()
{
if (!(txtMailId.Text.Trim() == string.Empty))
{
if (!IsEmail(txtMailId.Text))
{
Logger.Debug("Entered invalid Email ID's");
MessageBox.Show("Please enter valid Email Id's" );
txtMailId.Focus();
return false;
}
}
}
private bool IsEmail(string strEmail)
{
Regex validateEmail = new Regex("^[\\W]*([\\w+\\-.%][email protected][\\w\\-.]+\\.[A-Za-z] {2,4}[\\W]*,{1}[\\W]*)*([\\w+\\-.%][email protected][\\w\\-.]+\\.[A-Za-z]{2,4})[\\W]*$");
return validateEmail.IsMatch(strEmail);
}
Было предпринято много попыток создать валидатор электронной почты, который улавливает почти все мировые требования к электронной почте.
Метод расширения, с которым вы можете позвонить:
myEmailString.IsValidEmailAddress();
Строка шаблона Regex, которую вы можете получить, вызывая:
var myPattern = Regex.EmailPattern;
Код (в основном комментарии):
/// <summary>
/// Validates the string is an Email Address...
/// </summary>
/// <param name="emailAddress"></param>
/// <returns>bool</returns>
public static bool IsValidEmailAddress(this string emailAddress)
{
var valid = true;
var isnotblank = false;
var email = emailAddress.Trim();
if (email.Length > 0)
{
// Email Address Cannot start with period.
// Name portion must be at least one character
// In the Name, valid characters are: a-z 0-9 ! # _ % & ' " = ` { } ~ - + * ? ^ | / $
// Cannot have period immediately before @ sign.
// Cannot have two @ symbols
// In the domain, valid characters are: a-z 0-9 - .
// Domain cannot start with a period or dash
// Domain name must be 2 characters.. not more than 256 characters
// Domain cannot end with a period or dash.
// Domain must contain a period
isnotblank = true;
valid = Regex.IsMatch(email, Regex.EmailPattern, RegexOptions.IgnoreCase) &&
!email.StartsWith("-") &&
!email.StartsWith(".") &&
!email.EndsWith(".") &&
!email.Contains("..") &&
!email.Contains("[email protected]") &&
!email.Contains("@.");
}
return (valid && isnotblank);
}
/// <summary>
/// Validates the string is an Email Address or a delimited string of email addresses...
/// </summary>
/// <param name="emailAddress"></param>
/// <returns>bool</returns>
public static bool IsValidEmailAddressDelimitedList(this string emailAddress, char delimiter = ';')
{
var valid = true;
var isnotblank = false;
string[] emails = emailAddress.Split(delimiter);
foreach (string e in emails)
{
var email = e.Trim();
if (email.Length > 0 && valid) // if valid == false, no reason to continue checking
{
isnotblank = true;
if (!email.IsValidEmailAddress())
{
valid = false;
}
}
}
return (valid && isnotblank);
}
public class Regex
{
/// <summary>
/// Set of Unicode Characters currently supported in the application for email, etc.
/// </summary>
public static readonly string UnicodeCharacters = "À-ÿ\p{L}\p{M}ÀàÂâÆæÇçÈèÉéÊêËëÎîÏïÔôŒœÙùÛûÜü«»€₣äÄöÖüÜß"; // German and French
/// <summary>
/// Set of Symbol Characters currently supported in the application for email, etc.
/// Needed if a client side validator is being used.
/// Not needed if validation is done server side.
/// The difference is due to subtle differences in Regex engines.
/// </summary>
public static readonly string SymbolCharacters = @"!#%&'""=`{}~\.\-\+\*\?\^\|\/\$";
/// <summary>
/// Regular Expression string pattern used to match an email address.
/// The following characters will be supported anywhere in the email address:
/// ÀàÂâÆæÇçÈèÉéÊêËëÎîÏïÔôŒœÙùÛûÜü«»€₣äÄöÖüÜß[a - z][A - Z][0 - 9] _
/// The following symbols will be supported in the first part of the email address(before the @ symbol):
/// !#%&'"=`{}~.-+*?^|\/$
/// Emails cannot start or end with periods,dashes or @.
/// Emails cannot have two @ symbols.
/// Emails must have an @ symbol followed later by a period.
/// Emails cannot have a period before or after the @ symbol.
/// </summary>
public static readonly string EmailPattern = String.Format(
@"^([\w{0}{2}])[email protected]{1}[\w{0}]+([-.][\w{0}]+)*\.[\w{0}]+([-.][\w{0}]+)*$", // @"^[{0}\w]+([-+.'][{0}\w]+)*@[{0}\w]+([-.][{0}\w]+)*\.[{0}\w]+([-.][{0}\w]+)*$",
UnicodeCharacters,
"{1}",
SymbolCharacters
);
}
string patternEmail = @"(?<email>\[email protected]\w+\.[a-z]{0,3})";
Regex regexEmail = new Regex(patternEmail);
Чтобы проверить свой идентификатор электронной почты, вы можете просто создать такой метод и использовать его.
public static bool IsValidEmail(string email)
{
var r = new Regex(@"^([0-9a-zA-Z]([-\.\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})$");
return !String.IsNullOrEmpty(email) && r.IsMatch(email);
}
Это вернет True/False. (Действительный/Недействительный идентификатор электронной почты)
Это мой любимый подход к этому пока:
public static class CommonExtensions
{
public static bool IsValidEmail(this string thisEmail)
=> !string.IsNullOrWhiteSpace(thisEmail) &&
new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$").IsMatch(thisEmail);
}
Затем используйте созданное расширение строки, например:
if (!emailAsString.IsValidEmail()) throw new Exception("Invalid Email");
Просто дайте мне знать, если это не работает :)
public static bool isValidEmail(this string email)
{
string[] mail = email.Split(new string[] { "@" }, StringSplitOptions.None);
if (mail.Length != 2)
return false;
//check part before [email protected]
if (mail[0].Length < 1)
return false;
System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"^[a-zA-Z0-9_\-\.]+$");
if (!regex.IsMatch(mail[0]))
return false;
//check part after @...
string[] domain = mail[1].Split(new string[] { "." }, StringSplitOptions.None);
if (domain.Length < 2)
return false;
regex = new System.Text.RegularExpressions.Regex(@"^[a-zA-Z0-9_\-]+$");
foreach (string d in domain)
{
if (!regex.IsMatch(d))
return false;
}
//get TLD
if (domain[domain.Length - 1].Length < 2)
return false;
return true;
}
Попробуйте следующий код:
using System.Text.RegularExpressions;
if (!Regex.IsMatch(txtEmail.Text, @"^[a-z,A-Z]{1,10}((-|.)\w+)*@\w+.\w{3}$"))
MessageBox.Show("Not valid email.");
Поиск STRING с использованием метода REGEX в С#
Как проверить электронную почту с помощью регулярного выражения?
string EmailPattern = @"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*";
if (Regex.IsMatch(Email, EmailPattern, RegexOptions.IgnoreCase))
{
Console.WriteLine("Email: {0} is valid.", Email);
}
else
{
Console.WriteLine("Email: {0} is not valid.", Email);
}
Использовать ссылку Метод String.Regex()
1
^[\w!#$%&'*+\-/=?\^_`{|}~]+(\.[\w!#$%&'*+\-/=?\^_`{|}~]+)*@((([\-\w]+\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\.){3}[0-9]{1,3}))$
2
^(([^<>()[\]\\.,;:\[email protected]\""]+(\.[^<>()[\]\\.,;:\[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,}))$
Я думаю, что ваш знак каретки и доллара является частью проблемы Вы также должны немного изменить регулярное выражение, я использую следующий @ "[:] + ([\ w.-] +) @([\ w -.]) + ((. (\ w) {2,3}) +)"
Шаблон электронной почты для регулярного выражения:
^(?:[\\w\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`\\{\\|\\}\\~]+\\.)*[\\w\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`\\{\\|\\}\\~][email protected](?:(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9\\-](?!\\.)){0,61}[a-zA-Z0-9]?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9\\-](?!$)){0,61}[a-zA-Z0-9]?)|(?:\\[(?:(?:[01]?\\d{1,2}|2[0-4]\\d|25[0-5])\\.){3}(?:[01]?\\d{1,2}|2[0-4]\\d|25[0-5])\\]))$
Я использую Regex.IsMatch().
Прежде всего вам необходимо добавить следующее утверждение:
using System.Text.RegularExpressions;
Тогда метод выглядит так:
private bool EmailValidation(string pEmail)
{
return Regex.IsMatch(pEmail,
@"^(?("")("".+?(?<!\\)""@)|(([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));
}
Это закрытый метод из-за моей логики, но вы можете поместить метод как статический в другой слой, такой как "Утилиты", и вызывать его там, где вам нужно.
Там нет идеального регулярного выражения, но это довольно сильное, я думаю, на основе изучения RFC5322. И с интерполяцией строк С#, я думаю, довольно легко следовать.
const string atext = @"a-zA-Z\d!#\$%&'\*\+-/=\?\^_'\{\|\}~";
var localPart = $"[{atext}]+(\\.[{atext}]+)*";
var domain = $"[{atext}]+(\\.[{atext}]+)*";
Assert.That(() => EmailRegex = new Regex($"^{localPart}@{domain}$", Compiled),
Throws.Nothing);
Проверено с NUnit 2.x
Вот идеальное решение для проверки электронной почты Csharp http://koiralaprakash.com.np/c-sharp-email-validation/
Я создал класс FormValidationUtils для проверки электронной почты:
public static class FormValidationUtils
{
const string ValidEmailAddressPattern = "^[A-Z0-9._%+-][email protected][A-Z0-9.-]+\\.[A-Z]{2,6}$";
public static bool IsEmailValid(string email)
{
var regex = new Regex(ValidEmailAddressPattern, RegexOptions.IgnoreCase);
return regex.IsMatch(email);
}
}
У Visual Studio это было много лет.
\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
Надеюсь, это поможет!