c#代码验证电子邮件地址

就我个人而言，我会说你应该确保在那里有一个@符号，可能还有一个。的性格。你可以使用许多正则表达式来改变正确性，但我认为大多数正则表达式都会遗漏有效的电子邮件地址，或者让无效的电子邮件地址通过。如果人们想输入一个假的电子邮件地址，他们就会输入一个假的。如果您需要验证电子邮件地址是否合法，并且这个人控制着该电子邮件地址，那么您将需要向他们发送带有特殊编码链接的电子邮件，以便他们可以验证它确实是一个真实的地址。

电子邮件地址验证并不像看起来那么简单。实际上，从理论上讲，仅使用正则表达式完全验证电子邮件地址是不可能的。

查看我的博客关于这个主题的讨论以及使用FParsec的f#实现。[/ shameless_plug]

老实说，在产品代码中，我所做的最好的事情就是检查@符号。

我从来没有在一个地方完全验证电子邮件。你知道我怎么判断它是否有效吗?如果发送出去了。如果没有，那就糟了，如果有，生活就好了。这就是我需要知道的。

我发现这个正则表达式在检查@标记以外的东西和接受奇怪的边缘情况之间是一个很好的权衡:

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

它至少会让你在@标记周围放一些东西，并且至少放一个正常的域。

如果你真的，我是说真的想知道一个电子邮件地址是否有效……请邮件交换器来证明它，不需要正则表达式。如果需要，我可以提供代码。

一般步骤如下: 1. 电子邮件地址有域名部分吗?(@ > 0的索引) 2. 使用DNS查询询问域是否有邮件交换器 3.打开到邮件交换器的TCP连接 4. 使用SMTP协议，以电子邮件地址作为接收者打开到服务器的消息 5. 解析服务器的响应。 6.

正如您可以想象的那样，这是非常昂贵的时间，并且依赖于smtp，但它确实有效。

这个呢?

bool IsValidEmail(string email)
{
var trimmedEmail = email.Trim();


if (trimmedEmail.EndsWith(".")) {
return false; // suggested by @TK-421
}
try {
var addr = new System.Net.Mail.MailAddress(email);
return addr.Address == trimmedEmail;
}
catch {
return false;
}
}

根据Stuart的评论，这将最终地址与原始字符串进行比较，而不是总是返回true。MailAddress尝试将包含空格的字符串解析为“显示名称”;和“;Address"所以最初的版本是假阳性。

为了澄清，这个问题问的是特定字符串是否是电子邮件地址的有效表示，而不是电子邮件地址是否是发送消息的有效目的地。对于这一点，唯一真正的方法是发送一个信息来确认。

请注意，电子邮件地址比您最初想象的更宽容。这些都是完全有效的形式:

• cog@wheel
• “齿轮橘子”@example.com
• @ 123 .xyz

对于大多数用例，错误的“invalid"对于你的用户和未来的校对来说，比一个错误的“有效性”更糟糕。这里有一个这篇文章曾经是公认的答案来回答这个问题(这个答案已经被删除了)。它有更多的细节和解决问题的其他想法。

提供健全检查对于用户体验来说仍然是一个好主意。假设电子邮件地址是有效的，您可以寻找已知的顶级域名，检查域名中的MX记录，检查普通域名(gmail.cmo)的拼写错误，等等。然后给出一个警告，让用户有机会说“是的，我的邮件服务器确实允许🌮🍳🎁作为电子邮件地址。”

至于在业务逻辑中使用异常处理，我同意这是一件应该避免的事情。但这是其中的一种情况，方便和清晰可能超过教条。

此外，如果对电子邮件地址进行其他操作，则可能涉及将其转换为MailAddress。即使您不使用这个确切的函数，您也可能希望使用相同的模式。您还可以通过捕获不同的异常: null、空或无效格式来检查特定类型的失败。

——进一步阅读——

System.Net.Mail.MailAddress文档

有效的电子邮件地址的组成说明

一般来说，使用正则表达式来验证电子邮件地址并不是一件容易的事情;在撰写本文时，电子邮件地址的语法必须遵循相对较多的标准，在正则表达式中实现所有这些标准实际上是不可行的!

我强烈建议您尝试我们的EmailVerify。网，一个成熟的。net库，它可以验证当前IETF标准(RFC 1123, RFC 2821, RFC 2822, RFC 3696, RFC 4291, RFC 5321和RFC 5322)中所有之后的电子邮件地址，测试相关的DNS记录，检查目标邮箱是否可以接受消息，甚至可以判断给定的地址是否可用。

免责声明:我是这个组件的主要开发人员。

下面是这个类:

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;
}
}

这是一个老问题，但我在SO上找到的所有答案，包括最近的答案，都与这个问题类似。然而，在。net 4.5 / MVC 4中，你可以通过从System.ComponentModel中添加[EmailAddress]注释来向表单添加电子邮件地址验证。DataAnnotations，所以我想知道为什么我不能只使用。net的内置功能。

这似乎是可行的，而且在我看来是相当优雅的:

using System.ComponentModel.DataAnnotations;


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

email.IsValid("fdsa");                          //false
email.IsValid("fdsa@");                         //false
email.IsValid("fdsa@fdsa");                     //false
email.IsValid("fdsa@fdsa.");                    //false


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

我认为最好的方法如下:

    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;
}

你可以在一个通用类中使用这个静态函数。

public static bool IsEmail(string strEmail)
{
Regex rgxEmail = new Regex(@"^([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})(\]?)$");
return rgxEmail.IsMatch(strEmail);
}

1. 在“尝试块”发送一个验证电子邮件。
2. 让用户打开电子邮件并单击一个链接，以验证电子邮件是真实的。

在此过程成功完成之前，该电子邮件被认为是无效的。

.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])))\.?$";

这是我的答案——Phil的解决方案不适用于“someone@q.com”这样的单字母域名。信不信由你，这是used =)(例如，转到centurylink)。

菲尔的答案也只适用于PCRE标准…所以c#将会接受它，但javascript将会爆炸。这对于javascript来说太复杂了。所以你不能使用Phil的mvc验证属性的解决方案。

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.mailmessage()的人来说，这个东西太灵活了。当然，c#将接受电子邮件，但交换服务器将爆炸5.1.3运行时错误一旦你试图发送电子邮件。

前段时间，我写了一个EmailAddressValidationAttribute，它可以正确地验证表单中任何相对正常的电子邮件地址

local-part@domain

它是System.ComponentModel.DataAnnotations.ValidationAttribute，所以使用起来非常简单。

而且，由于挖掘所有rfc和勘误表，并组装所需的所有位来正确枚举所有规则……乏味的本;在最好的情况下!本;我在我的答案中发布了验证器的源代码到问题c#电子邮件地址验证的源代码。

我的验证器无论怎么想象都不是完美的，只是对于初学者来说，它没有任何内置的对发出客户端javascript验证的支持，尽管将其添加进来并不太难。从我上面的回答来看:

这是我写的验证属性。它几乎验证了每一封“原始”电子邮件 地址，即表单为local-part@domain的那些。它不支持任何 另一个，更……rfc允许的创造性结构(此列表不允许) 综合任何方式):

• 注释(例如，jsmith@whizbang.com (work))
• 带引号的字符串(转义文本，以允许原子中不允许的字符)
• 域字面量(例如foo@[123.45.67.012])
• bangs路径(又名源路由)
• 角度地址(例如John Smith <jsmith@whizbang.com>)
• 折叠的空白
• 本地部分或域的双字节字符(仅限7位ASCII)。
• 等。

它应该接受几乎任何可以这样表示的电子邮件地址

• # EYZ0

而不需要使用引号(")，尖括号('<>') 或方括号([])

没有尝试验证域中最右边的dns标签是否有效 TLD(顶级域名)。这是因为顶级域名的列表现在远远大于 “大6”(.com， .edu， .gov， .mil， .net， .org)加上2个字母的ISO国家代码。 ICANN实际上每天都会更新TLD列表，虽然我怀疑这个列表 并不是每天都在变化。此外，[ICANN刚刚批准了一个很大的扩展 通用TLD命名空间][2])。有些电子邮件地址没有你能认出来的地址 作为TLD(你知道postmaster@.在理论上是有效的并且可以邮寄的吗?邮件 到该地址应该被发送到DNS根区域的邮政管理员。

扩展正则表达式以支持域字面量应该不会太难。

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);
}

检查电子邮件字符串是正确的格式或错误的格式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";
}
}

/使用内部Regex在.Net4.5 >>>中创建“new EmailAddressAttribute();”组件使用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

    /// <summary>
/// Validates the email if it follows the valid email format
/// </summary>
/// <param name="emailAddress"></param>
/// <returns></returns>
public static bool EmailIsValid(string emailAddress)
{
//if string is not null and empty then check for email follow the format
return string.IsNullOrEmpty(emailAddress)?false : new Regex(@"^(?!\.)(""([^""\r\\]|\\[""\r\\])*""|([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$", RegexOptions.IgnoreCase).IsMatch(emailAddress);
}

   public bool IsValidEmail(string email)
{
try
{
var addr = new System.Net.Mail.MailAddress(email);
return addr.Address == email;
}
catch
{
return false;
}
}

我用的是单线法，它对我有用

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);

我将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);
}

我根据维基百科的规则和样本地址创建了一个电子邮件地址验证程序。对于那些不介意多看一点代码的人，这里。说实话，我不知道电子邮件地址规范中有这么多疯狂的规则。我没有完全验证主机名或ipaddress，但它仍然通过了维基百科上的所有测试用例。

using Microsoft.VisualStudio.TestTools.UnitTesting;


namespace EmailValidateUnitTests
{
[TestClass]
public class EmailValidationUnitTests
{
[TestMethod]
public void TestEmailValidate()
{
// Positive Assertions
Assert.IsTrue("prettyandsimple@example.com".IsValidEmailAddress());
Assert.IsTrue("very.common@example.com".IsValidEmailAddress());
Assert.IsTrue("disposable.style.email.with+symbol@example.com".IsValidEmailAddress());
Assert.IsTrue("other.email-with-dash@example.com".IsValidEmailAddress());
Assert.IsTrue("\"much.more unusual\"@example.com".IsValidEmailAddress());
Assert.IsTrue("\"very.unusual.@.unusual.com\"@example.com".IsValidEmailAddress()); //"very.unusual.@.unusual.com"@example.com
Assert.IsTrue("\"very.(),:;<>[]\\\".VERY.\\\"very@\\\\ \\\"very\\\".unusual\"@strange.example.com".IsValidEmailAddress()); //"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com
Assert.IsTrue("admin@mailserver1".IsValidEmailAddress());
Assert.IsTrue("#!$%&'*+-/=?^_`{}|~@example.org".IsValidEmailAddress());
Assert.IsTrue("\"()<>[]:,;@\\\\\\\"!#$%&'*+-/=?^_`{}| ~.a\"@example.org".IsValidEmailAddress()); //"()<>[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.a"@example.org
Assert.IsTrue("\" \"@example.org".IsValidEmailAddress()); //" "@example.org (space between the quotes)
Assert.IsTrue("example@localhost".IsValidEmailAddress());
Assert.IsTrue("example@s.solutions".IsValidEmailAddress());
Assert.IsTrue("user@com".IsValidEmailAddress());
Assert.IsTrue("user@localserver".IsValidEmailAddress());
Assert.IsTrue("user@[IPv6:2001:db8::1]".IsValidEmailAddress());
Assert.IsTrue("user@[192.168.2.1]".IsValidEmailAddress());
Assert.IsTrue("(comment and stuff)joe@gmail.com".IsValidEmailAddress());
Assert.IsTrue("joe(comment and stuff)@gmail.com".IsValidEmailAddress());
Assert.IsTrue("joe@(comment and stuff)gmail.com".IsValidEmailAddress());
Assert.IsTrue("joe@gmail.com(comment and stuff)".IsValidEmailAddress());


// Failure Assertions
Assert.IsFalse("joe(fail me)smith@gmail.com".IsValidEmailAddress());
Assert.IsFalse("joesmith@gma(fail me)il.com".IsValidEmailAddress());
Assert.IsFalse("joe@gmail.com(comment and stuff".IsValidEmailAddress());
Assert.IsFalse("Abc.example.com".IsValidEmailAddress());
Assert.IsFalse("A@b@c@example.com".IsValidEmailAddress());
Assert.IsFalse("a\"b(c)d,e:f;g<h>i[j\\k]l@example.com".IsValidEmailAddress()); //a"b(c)d,e:f;g<h>i[j\k]l@example.com
Assert.IsFalse("just\"not\"right@example.com".IsValidEmailAddress()); //just"not"right@example.com
Assert.IsFalse("this is\"not\\allowed@example.com".IsValidEmailAddress()); //this is"not\allowed@example.com
Assert.IsFalse("this\\ still\\\"not\\\\allowed@example.com".IsValidEmailAddress());//this\ still\"not\\allowed@example.com
Assert.IsFalse("john..doe@example.com".IsValidEmailAddress());
Assert.IsFalse("john.doe@example..com".IsValidEmailAddress());
Assert.IsFalse(" joe@gmail.com".IsValidEmailAddress());
Assert.IsFalse("joe@gmail.com ".IsValidEmailAddress());
}
}


public static class ExtensionMethods
{
private const string ValidLocalPartChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'*+-/=?^_`{|}~";
private const string ValidQuotedLocalPartChars = "(),:;<>@[]. ";
private const string ValidDomainPartChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-:";


private enum EmailParseMode
{
BeginLocal, Local, QuotedLocalEscape, QuotedLocal, QuotedLocalEnd, LocalSplit, LocalComment,
At,
Domain, DomainSplit, DomainComment, BracketedDomain, BracketedDomainEnd
};


public static bool IsValidEmailAddress(this string s)
{
bool valid = true;


bool hasLocal = false, hasDomain = false;
int commentStart = -1, commentEnd = -1;
var mode = EmailParseMode.BeginLocal;
for (int i = 0; i < s.Length; i++)
{
char c = s[i];
if (mode == EmailParseMode.BeginLocal || mode == EmailParseMode.LocalSplit)
{
if (c == '(') { mode = EmailParseMode.LocalComment; commentStart = i; commentEnd = -1; }
else if (c == '"') { mode = EmailParseMode.QuotedLocal; }
else if (ValidLocalPartChars.IndexOf(c) >= 0) { mode = EmailParseMode.Local; hasLocal = true; }
else { valid = false; break; }
}
else if (mode == EmailParseMode.LocalComment)
{
if (c == ')')
{
mode = EmailParseMode.Local; commentEnd = i;
// comments can only be at beginning and end of parts...
if (commentStart != 0 && ((commentEnd + 1) < s.Length) && s[commentEnd + 1] != '@') { valid = false; break; }
}
}
else if (mode == EmailParseMode.Local)
{
if (c == '.') mode = EmailParseMode.LocalSplit;
else if (c == '@') mode = EmailParseMode.At;
else if (c == '(') { mode = EmailParseMode.LocalComment; commentStart = i; commentEnd = -1; }
else if (ValidLocalPartChars.IndexOf(c) >= 0) { hasLocal = true; }
else { valid = false; break; }
}
else if (mode == EmailParseMode.QuotedLocal)
{
if (c == '"') { mode = EmailParseMode.QuotedLocalEnd; }
else if (c == '\\') { mode = EmailParseMode.QuotedLocalEscape; }
else if (ValidLocalPartChars.IndexOf(c) >= 0 || ValidQuotedLocalPartChars.IndexOf(c) >= 0) { hasLocal = true; }
else { valid = false; break; }
}
else if (mode == EmailParseMode.QuotedLocalEscape)
{
if (c == '"' || c == '\\') { mode = EmailParseMode.QuotedLocal; hasLocal = true; }
else { valid = false; break; }
}
else if (mode == EmailParseMode.QuotedLocalEnd)
{
if (c == '.') { mode = EmailParseMode.LocalSplit; }
else if (c == '@') mode = EmailParseMode.At;
else if (c == '(') { mode = EmailParseMode.LocalComment; commentStart = i; commentEnd = -1; }
else { valid = false; break; }
}
else if (mode == EmailParseMode.At)
{
if (c == '[') { mode = EmailParseMode.BracketedDomain; }
else if (c == '(') { mode = EmailParseMode.DomainComment; commentStart = i; commentEnd = -1; }
else if (ValidDomainPartChars.IndexOf(c) >= 0) { mode = EmailParseMode.Domain; hasDomain = true; }
else { valid = false; break; }
}
else if (mode == EmailParseMode.DomainComment)
{
if (c == ')')
{
mode = EmailParseMode.Domain;
commentEnd = i;
// comments can only be at beginning and end of parts...
if ((commentEnd + 1) != s.Length && (commentStart > 0) && s[commentStart - 1] != '@') { valid = false; break; }
}
}
else if (mode == EmailParseMode.DomainSplit)
{
if (ValidDomainPartChars.IndexOf(c) >= 0) { mode = EmailParseMode.Domain; hasDomain = true; }
else { valid = false; break; }
}
else if (mode == EmailParseMode.Domain)
{
if (c == '(') { mode = EmailParseMode.DomainComment; commentStart = i; commentEnd = -1; }
else if (c == '.') { mode = EmailParseMode.DomainSplit; }
else if (ValidDomainPartChars.IndexOf(c) >= 0) { hasDomain = true; }
else { valid = false; break; }
}
else if (mode == EmailParseMode.BracketedDomain)
{
if (c == ']') { mode = EmailParseMode.BracketedDomainEnd; }
else if (c == '.' || ValidDomainPartChars.IndexOf(c) >= 0) { hasDomain = true; }
else { valid = false; break; }
}
else if (mode == EmailParseMode.BracketedDomain)
{
if (c == '(') { mode = EmailParseMode.DomainComment; commentStart = i; commentEnd = -1; }
else { valid = false; break; }
}
}
bool unfinishedComment = (commentEnd == -1 && commentStart >= 0);


return hasLocal && hasDomain && valid && !unfinishedComment;
}
}
}

这可能是对文本框进行电子邮件验证的最佳方式。

string pattern = null;
pattern = "^([0-9a-zA-Z]([-\\.\\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\\w]*[0-9a-zA-Z]\\.)+[a-zA-Z]{2,9})$";


if (Regex.IsMatch("txtemail.Text", pattern))
{
MessageBox.Show ("Valid Email address ");
}
else
{
MessageBox.Show("Invalid Email Email");
}

只要在任何你想要的函数中包含。

最优雅的方法是使用. net的内置方法。

这些方法:

• 都是经过考验的。我在自己的专业项目中使用了这些方法。

• 内部使用正则表达式，这是可靠和快速的。

• 由微软为c#编写。没有必要做重复的工作。

• 返回bool类型的结果。True表示邮件有效。

适用于。net 4.5及以上版本的用户

将此引用添加到项目中:

System.ComponentModel.DataAnnotations

现在你可以使用下面的代码:

(new EmailAddressAttribute().IsValid("youremailhere@test.test"));

使用实例

下面是一些需要声明的方法:

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，一个或多个电子邮件地址，以分号;分隔。
• 清楚地演示了如何使用EmailAddressAttribute对象的IsValid方法。

对于.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;


}

这是你问题的答案，供你核对。

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;


}


}

我写了一个函数来检查电子邮件是否有效。在大多数情况下，这似乎对我很有效。

结果:

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;
}

识别电子邮件id是否有效的简单方法。

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#的regex中有文化问题，而不是js。所以我们需要在US模式下使用regex进行邮件检查。如果你不使用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)

我最终使用了这个正则表达式，因为它成功地验证了逗号、注释、Unicode字符和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,}))$";

一个简单的没有使用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;
}

例子:

• # EYZ0
• # EYZ0
• # EYZ0
• # EYZ0
• # EYZ0
• # EYZ0
• # EYZ0
• # EYZ0
• # EYZ0
• # EYZ0
• # EYZ0

它意味着简单，因此它不处理罕见的情况，如电子邮件的括号域包含空格(通常是允许的)，电子邮件的IPv6地址等。

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;
}

# EYZ0

string Email = txtEmail.Text;
if (Email.IsValidEmail())
{
//use code here
}


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);
}

如果你正在使用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. 将“脚本组件”放入数据流连接中，然后打开它。
2. 在“Input Columns”部分中，将包含电子邮件地址的字段设置为“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";
   }
   }
   

Then you can use a Conditional Split to filter out all invalid records or whatever you want to do.

对@齿轮回答做了一点修改

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;
}
}

这里有很多强有力的答案。然而，我建议我们后退一步。@Cogwheel回答问题https://stackoverflow.com/a/1374644/388267。然而，在批量验证场景中，如果许多被验证的电子邮件地址是无效的，那么代价可能很高。我建议我们在进入他的试接方块之前使用一点逻辑。我知道下面的代码可以使用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'S ANSWER: https://stackoverflow.com/a/1374644/388267
try
{
var addr = new System.Net.Mail.MailAddress(input);
return addr.Address == input;
}
catch
{
return false;
}
}

从@齿轮投票最多的答案是最好的答案，但我已经尝试实现trim()字符串方法，所以它将从字符串开始到结束修剪所有用户空白。检查代码下面的完整示例-

bool IsValidEmail(string email)
{
try
{
email = email.Trim();
var addr = new System.Net.Mail.MailAddress(email);
return addr.Address == email;
}
catch
{
return false;
}
}

另一个正则表达式匹配答案:

   /// <summary>
/// Validates the email input
/// </summary>
internal static bool ValidateEmail(string _emailAddress)
{


string _regexPattern = @"^(([\w-]+\.)+[\w-]+|([a-zA-Z]{1}|[\w-]{2,}))@"
+ @"((([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\.([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\."
+ @"([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\.([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])){1}|"
+ @"([a-zA-Z]+[\w-]+\.)+[a-zA-Z]{2,4})$";


return (string.IsNullOrEmpty(_emailAddress) == false && System.Text.RegularExpressions.Regex.IsMatch(_emailAddress, _regexPattern))
? true
: false;
}

如果你结合多个解决方案来制作一个完美的代码呢?

我得到了排名最高的2个解决方案，并将它们结合起来，以获得更准确的答案。

    public static bool isValidEmail(string email)
{
try
{
var addr = new System.Net.Mail.MailAddress(email);
if (addr.Address == 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;
}
return false;
}
catch
{
return false;
}
}

正如在许多回答中提到的，电子邮件地址的领域是复杂的。在这种情况下，我强烈反对使用正则表达式。那些匹配(大多数)用例的异常复杂，难以读取，因此也难以维护。此外，它们仍然难以支持所有病例，而且速度缓慢。

微软的EmailAddress类在这方面有所帮助，但我认为它也不是完美的。对于几年前的一个开源项目，我尝试使用自定义的EmailParser。

在[EmailAddress]https://github.com/Qowaiv/Qowaiv/blob/master/src/Qowaiv/EmailAddress.cs)中使用。

通过使用这种方法，您不仅可以验证电子邮件地址，还可以清除显示名称的多种格式，去掉# eyz0前缀，并根据ip地址规范化域文字，并将所有内容小写(注意，本地部分正式是区分大小写的)。

你的解决方案应该支持的场景(上面提到的就是):

[TestCase(null)]
[TestCase("")]
[TestCase("..@test.com")]
[TestCase(".a@test.com")]
[TestCase("ab@sd@dd")]
[TestCase(".@s.dd")]
[TestCase("ab@988.120.150.10")]
[TestCase("ab@120.256.256.120")]
[TestCase("ab@120.25.1111.120")]
[TestCase("ab@[188.120.150.10")]
[TestCase("ab@188.120.150.10]")]
[TestCase("ab@[188.120.150.10].com")]
[TestCase("a@b.-de.cc")]
[TestCase("a@bde-.cc")]
[TestCase("a@bde.c-c")]
[TestCase("a@bde.cc.")]
[TestCase("ab@b+de.cc")]
[TestCase("a..b@bde.cc")]
[TestCase("_@bde.cc,")]
[TestCase("plainaddress")]
[TestCase("plain.address")]
[TestCase("@%^%#$@#$@#.com")]
[TestCase("@domain.com")]
[TestCase("Joe Smith <email@domain.com>")]
[TestCase("email.domain.com")]
[TestCase("email@domain@domain.com")]
[TestCase(".email@domain.com")]
[TestCase("email.@domain.com")]
[TestCase("email..email@domain.com")]
[TestCase("email@-domain.com")]
[TestCase("email@domain-.com")]
[TestCase("email@domain.com-")]
[TestCase("email@.domain.com")]
[TestCase("email@domain.com.")]
[TestCase("email@domain..com")]
[TestCase("email@111.222.333")]
[TestCase("email@111.222.333.256")]
[TestCase("email@[123.123.123.123")]
[TestCase("email@[123.123.123].123")]
[TestCase("email@123.123.123.123]")]
[TestCase("email@123.123.[123.123]")]
[TestCase("email@{leftbracket.com")]
[TestCase("email@rightbracket}.com")]
[TestCase("email@p|pe.com")]
[TestCase("isis@100%.nl")]
[TestCase("email@dollar$.com")]
[TestCase("email@r&d.com")]
[TestCase("email@#hash.com")]
[TestCase("email@wave~tilde.com")]
[TestCase("email@exclamation!mark.com")]
[TestCase("email@question?mark.com")]
[TestCase("email@obelix*asterisk.com")]
[TestCase("email@grave`accent.com")]
[TestCase("email@colon:colon.com")]
[TestCase("email@caret^xor.com")]
[TestCase("email@=qowaiv.com")]
[TestCase("email@plus+.com")]
[TestCase("email@domain.com>")]
[TestCase("email( (nested) )@plus.com")]
[TestCase("email)mirror(@plus.com")]
[TestCase("email@plus.com (not closed comment")]
[TestCase("email(with @ in comment)plus.com")]
[TestCase(@"""Joe Smith email@domain.com")]
[TestCase(@"""Joe Smith' email@domain.com")]
[TestCase(@"""Joe Smith""email@domain.com")]
[TestCase("email@mailto:domain.com")]
[TestCase("mailto:mailto:email@domain.com")]
[TestCase("Display Name <email@plus.com> (after name with display)")]
[TestCase("ReDoSaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")]
public void IsInvalid(string email)
{
Assert.IsFalse(EmailAddress.IsValid(email), email);
}


[TestCase("w@com")]
[TestCase("w.b.f@test.com")]
[TestCase("w.b.f@test.museum")]
[TestCase("a.a@test.com")]
[TestCase("ab@288.120.150.10.com")]
[TestCase("ab@188.120.150.10")]
[TestCase("ab@1.0.0.10")]
[TestCase("ab@120.25.254.120")]
[TestCase("ab@01.120.150.1")]
[TestCase("ab@88.120.150.021")]
[TestCase("ab@88.120.150.01")]
[TestCase("ab@[120.254.254.120]")]
[TestCase("local@2001:0db8:85a3:0000:0000:8a2e:0370:7334")]
[TestCase("local@[2001:0db8:85a3:0000:0000:8a2e:0370:7334]")]
[TestCase("2@bde.cc")]
[TestCase("-@bde.cc")]
[TestCase("a2@bde.cc")]
[TestCase("a-b@bde.cc")]
[TestCase("ab@b-de.cc")]
[TestCase("a+b@bde.cc")]
[TestCase("f.f.f@bde.cc")]
[TestCase("ab_c@bde.cc")]
[TestCase("_-_@bde.cc")]
[TestCase("k.haak@12move.nl")]
[TestCase("K.HAAK@12MOVE.NL")]
[TestCase("email@domain.com")]
[TestCase("email@domain")]
[TestCase("あいうえお@domain.com")]
[TestCase("local@あいうえお.com")]
[TestCase("firstname.lastname@domain.com")]
[TestCase("email@subdomain.domain.com")]
[TestCase("firstname+lastname@domain.com")]
[TestCase("email@123.123.123.123")]
[TestCase("email@[123.123.123.123]")]
[TestCase("1234567890@domain.com")]
[TestCase("a@domain.com")]
[TestCase("a.b.c.d@domain.com")]
[TestCase("aap.123.noot.mies@domain.com")]
[TestCase("1@domain.com")]
[TestCase("email@domain-one.com")]
[TestCase("_______@domain.com")]
[TestCase("email@domain.topleveldomain")]
[TestCase("email@domain.co.jp")]
[TestCase("firstname-lastname@domain.com")]
[TestCase("firstname-lastname@d.com")]
[TestCase("FIRSTNAME-LASTNAME@d--n.com")]
[TestCase("first-name-last-name@d-a-n.com")]
[TestCase("{local{name\{\{with{@leftbracket.com")]
[TestCase("}local}name}}with{@rightbracket.com")]
[TestCase("|local||name|with|@pipe.com")]
[TestCase("%local%%name%with%@percentage.com")]
[TestCase("$local$$name$with$@dollar.com")]
[TestCase("&local&&name&with&$@amp.com")]
[TestCase("#local##name#with#@hash.com")]
[TestCase("~local~~name~with~@tilde.com")]
[TestCase("!local!!name!with!@exclamation.com")]
[TestCase("?local??name?with?@question.com")]
[TestCase("*local**name*with*@asterisk.com")]
[TestCase("`local``name`with`@grave-accent.com")]
[TestCase("^local^^name^with^@xor.com")]
[TestCase("=local==name=with=@equality.com")]
[TestCase("+local++name+with+@equality.com")]
[TestCase("Joe Smith <email@domain.com>")]
[TestCase("email@domain.com (joe Smith)")]
[TestCase(@"""Joe Smith"" email@domain.com")]
[TestCase(@"""Joe\\tSmith"" email@domain.com")]
[TestCase(@"""Joe\""Smith"" email@domain.com")]
[TestCase(@"Test |<gaaf <email@domain.com>")]
[TestCase("MailTo:casesensitve@domain.com")]
[TestCase("mailto:email@domain.com")]
[TestCase("Joe Smith <mailto:email@domain.com>")]
[TestCase("Joe Smith <mailto:email(with comment)@domain.com>")]
[TestCase(@"""With extra < within quotes"" Display Name<email@domain.com>")]
[TestCase("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")]
public void IsValid(string email)
{
Assert.IsTrue(EmailAddress.IsValid(email), email);
}

我经常用这个来验证电子邮件，它就像一个魅力。这验证了电子邮件必须在@之前至少有一个字符，并且在“。”之前至少有一个字符

public static bool ValidateEmail(string value, bool required, int minLength, int maxLength)
{
value = value.Trim();
if (required == false && value == "") return true;
if (required && value == "") return false;
if (value.Length < minLength || value.Length > maxLength) return false;


//Email must have at least one character before an @, and at least one character before the .
int index = value.IndexOf('@');
if (index < 1 || value.LastIndexOf('.') < index + 2) return false;
return true;
}

https://learn.microsoft.com/en-us/dotnet/standard/base-types/how-to-verify-that-strings-are-in-valid-email-format

为了方便起见，下面是他们的测试结果:

//       Valid: david.jones@proseware.com
//       Valid: d.j@server1.proseware.com
//       Valid: jones@ms1.proseware.com
//       Invalid: j.@server1.proseware.com
//       Valid: j@proseware.com9
//       Valid: js#internal@proseware.com
//       Valid: j_9@[129.126.118.1]
//       Invalid: j..s@proseware.com
//       Invalid: js*@proseware.com
//       Invalid: js@proseware..com
//       Valid: js@proseware.com9
//       Valid: j.s@server1.proseware.com
//       Valid: "j\"s\""@proseware.com
//       Valid: js@contoso.中国

我总结了以上所有的答案，截至2021年，我在这门课上为自己写的答案:

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


public static bool IsValidMailAddress(this string pThis)
=> pThis is not null
&& Regex.IsMatch(pThis, emailPattern, RegexOptions.IgnoreCase);
}

我是来偷电子邮件的验证码的。然后我发现答案中的代码不必要地扩展了。我相信我用最短的方式写出了最好的解决方案:

public static bool IsEmail(string email)
{
try
{
return new System.Net.Mail.MailAddress(email).Address == email && !email.Trim().EndsWith(".");
}
catch
{
return false;
}
}