이메일 주소를 확인하는 C # 코드

문자열이 유효한 이메일 주소인지 확인하는 가장 우아한 코드는 무엇입니까?

이건 어때?

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

명확히하기 위해 전자 메일 주소가 메시지를 보낼 수있는 유효한 대상인지 여부가 아니라 특정 문자열이 전자 메일 주소의 유효한 표현인지 묻습니다. 이를위한 유일한 방법은 확인 메시지를 보내는 것입니다.

전자 우편 주소는 처음 생각했던 것보다 더 관대합니다. 이들은 모두 완벽하게 유효한 형식입니다.

• 톱니 바퀴
• "오렌지 톱니 바퀴"@ example.com
• 123@$.xyz

대부분의 사용 사례에서 잘못된 "유효하지 않은"은 잘못된 "유효한"것보다 사용자와 향후 교정에 훨씬 나쁩니다. 다음은 이 질문에 대한 답변 으로 사용 된 기사입니다 (해당 답변은 삭제됨). 문제를 해결하는 방법에 대한 더 자세한 내용과 다른 아이디어가 있습니다.

온 전성 검사를 제공하는 것은 여전히 ​​사용자 경험에 대한 좋은 아이디어입니다. 전자 메일 주소가 유효하다고 가정하면 알려진 최상위 도메인을 찾고 도메인에서 MX 레코드를 확인하고 일반적인 도메인 이름 (gmail.cmo)의 철자 오류를 검사하는 등의 작업을 수행 할 수 있습니다. "예, 내 메일 서버는 실제로 이메일 주소로 🌮🍳🎁을 허용합니다."

비즈니스 로직에 예외 처리를 사용하는 것은 피해야 할 것에 동의합니다. 그러나 이것은 편의성과 명확성이 교리보다 클 수있는 경우 중 하나입니다.

또한 전자 메일 주소로 다른 작업을 수행하는 경우 MailAddress로 설정해야 할 수 있습니다. 이 정확한 기능을 사용하지 않더라도 동일한 패턴을 사용하고 싶을 것입니다. 널 (null), 비어 있거나 유효하지 않은 형식 과 같은 다른 예외 를 발견하여 특정 종류의 실패를 확인할 수도 있습니다 .

스튜어트의 의견에 따르면, 이것은 항상 true를 반환하는 대신 최종 주소를 원래 문자열과 비교합니다. MailAddress는 공백이있는 문자열을 "표시 이름"및 "주소"부분으로 구문 분석하려고하므로 원래 버전이 오 탐지를 리턴했습니다.

--- 더 읽기 ---

System.Net.Mail.MailAddress에 대한 설명서

유효한 이메일 주소를 구성하는 것에 대한 설명

이것은 오래된 질문이지만 최근 답변을 포함하여 SO에서 찾은 모든 답변은이 답변과 비슷합니다. 그러나 .Net 4.5 / MVC 4에서는 System.ComponentModel.DataAnnotations에서 [EmailAddress] 주석을 추가하여 전자 메일 주소 유효성 검사를 양식에 추가 할 수 있으므로에서 내장 기능을 사용할 수없는 이유가 궁금했습니다. 일반적으로 그물.

이것은 작동하는 것처럼 보이며 상당히 우아합니다.

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

나는이 단일 라이너 방법을 사용하여 나를 위해 일한다.

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

설명에 따라 source(이메일 주소)가 null 인 경우 "실패"합니다 .

public static bool IsValidEmailAddress(this string address) => address != null && new EmailAddressAttribute().IsValid(address);

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

필의 답변을 # 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;
    }
}

개인적으로, 나는 거기에 @ 기호가 있는지 확인해야한다고 말하고 싶습니다. 캐릭터. 다양한 정확성으로 사용할 수있는 정규 표현식이 많이 있지만 대부분은 유효한 전자 메일 주소를 남기거나 유효하지 않은 주소를 허용한다고 생각합니다. 사람들이 가짜 전자 메일 주소를 입력하려면 가짜 전자 메일 주소를 입력합니다. 전자 메일 주소가 합법적이며 해당 전자 메일 주소를 제어하는 ​​사람인지 확인해야하는 경우 실제 코드인지 확인할 수 있도록 특수 코드 링크가 포함 된 전자 메일을 보내야합니다.

가장 좋은 방법은 다음과 같습니다.

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

이 정적 함수는 일반 클래스에서 가질 수 있습니다.

짧고 정확한 코드

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

가장 우아한 방법은 .Net의 내장 메소드를 사용하는 것입니다.

이 방법들 :

• 시도하고 테스트했습니다. 이 방법은 내 전문 프로젝트에 사용됩니다.

• 신뢰할 수 있고 빠른 정규식을 내부적으로 사용하십시오.

• C #을 위해 Microsoft에서 제작했습니다. 바퀴를 재발 명할 필요가 없습니다.

• 부울 결과를 반환합니다. 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());

}

또한이 예는 다음과 같습니다.

• 단일 문자열을 사용하여 세미콜론으로 구분 된 하나 또는 여러 개의 전자 메일 주소를 포함하기 때문에 단일 문자열이 사용되므로 사양을 넘어 확장됩니다 ;.
• EmailAddressAttribute 개체의 IsValid 메서드를 사용하는 방법을 명확하게 보여줍니다.

대안, 4.5 미만의 .Net 버전 사용자

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

}

솔직히 말해서, 프로덕션 코드에서 내가하는 최선의 방법은 @기호를 확인하는 것 입니다.

이메일을 완전히 검증 할 수있는 곳이 아닙니다. 그것이 실제로 유효한지 어떻게 알 수 있습니까? 보내 졌다면. 그렇지 않은 경우, 나쁜 경우, 인생은 좋습니다. 그게 내가 알아야 할 전부입니다.

이 정규식은 @ 마크 이상의 것을 확인하고 이상한 경우를 받아들이는 것 사이에 좋은 절충안이라는 것을 알았습니다.

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

적어도 @ 마크 주위에 무언가를 넣고 최소한 정상적인 도메인을 배치합니다.

이메일 주소 확인은 생각보다 쉽지 않습니다. 실제로는 정규식 만 사용하여 전자 메일 주소를 완전히 검증하는 것은 이론적으로 불가능합니다.

주제에 대한 토론과 FParsec을 사용한 F # 구현에 대해서는 내 블로그 게시물을 확인하십시오 . [/ shameless_plug]

내 대답은 다음과 같습니다. Phil의 솔루션은 "someone@q.com"과 같은 단일 문자 도메인에서 실패합니다. 믿거 나 말거나, =) 사용됩니다 (예를 들어 CenturyLink로 이동).

Phil의 대답은 PCRE 표준에서만 작동 할 것입니다 ... 그래서 C #은 그것을 취할 것이지만 자바 스크립트는 폭발 할 것입니다. 자바 스크립트에는 너무 복잡합니다. 따라서 mvc 유효성 검사 속성에 Phil의 솔루션을 사용할 수 없습니다.

여기 내 정규식이 있습니다. MVC 유효성 검사 속성과 잘 작동합니다.
-@ 앞의 모든 것이 단순화되어 적어도 자바 스크립트가 작동합니다. Exchange 서버가 5.1.3을 제공하지 않는 한 여기에서 유효성 검사를 완화해도 좋습니다. -@ 뒤의 모든 것은 단일 문자 도메인에 대해 수정 된 Phil의 솔루션입니다.

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

system.net.mail MailMessage () 사용을 제안하는 사람들에게는 그 방법이 유연합니다. 물론 C #은 전자 메일을 수락하지만 전자 메일을 보내려고하면 Exchange 서버에서 5.1.3 런타임 오류가 발생합니다.

당신이 정말로 이메일 주소가 유효한지 알고 싶다면 메일 교환기에게 그것을 증명하도록 요청하십시오. 정규식이 필요하지 않습니다. 요청하면 코드를 제공 할 수 있습니다.

일반적인 단계는 다음과 같습니다. 1. 이메일 주소에 도메인 이름 부분이 있습니까? (@> 0의 색인) 2. DNS 쿼리를 사용하여 도메인에 메일 교환기가 있는지 묻습니다. 3. 메일 교환기에 대한 TCP 연결을 엽니 다 4. smtp 프로토콜을 사용하여 전자 메일 주소를 수신자로 사용하여 서버에 메시지를 엽니 다 5. 서버의 응답을 구문 분석하십시오. 6. 지금까지 메시지를 작성한 경우 모든 메시지가 종료됩니다.

이것은 상상할 수 있듯이 시간이 많이 걸리고 smtp에 의존하지만 작동합니다.

일반적으로, 이메일 주소를 확인하는 정규식은 쉽게 구할 수 없습니다. 이 글을 쓰는 시점에서 전자 메일 주소의 구문은 비교적 많은 수의 표준을 따라야하며 정규 표현식 내에서 모든 표준을 구현하는 것은 실제로 불가능합니다!

현재 모든 IETF 표준 (RFC 1123, RFC 2821, RFC 2822, RFC 3696, RFC 4291, RFC 5321 및 RFC 5322)에 따라 전자 메일 주소를 확인할 수있는 성숙한 .NET 라이브러리 인 EmailVerify.NET 을 사용해보십시오. , 관련 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;
        }

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 답변에 약간의 수정

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 질문에 답변합니다 . 그럼에도 불구하고, 검증되는 많은 이메일 주소가 유효하지 않은 경우 대량 검증 시나리오에서 비용이 많이들 수 있습니다. 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'S ANSWER: https://stackoverflow.com/a/1374644/388267 
        try
        {
            var addr = new System.Net.Mail.MailAddress(input);
            return addr.Address == input;
        }
        catch
        {
            return false;
        }
    }

@Cogwheel에서 가장 많이 투표 된 답변은 가장 좋은 답변이지만 trim()문자열 방법 을 구현하려고 시도 했기 때문에 문자열 시작에서 끝까지 모든 사용자 공백을 잘라냅니다. 전체 예제는 다음 코드를 확인하십시오.

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

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

/ "new EmailAddressAttribute ();"작성에 사용 된 내부 정규식 사용 System.ComponentModel.DataAnnotations를 사용하는 .Net4.5의 >>> 구성 요소; // 이메일 주소의 유효성을 검사하려면 ...... 테스트 및 작동.

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

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

이메일 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 #의 정규 표현식에는 js가 아닌 문화 문제가 있습니다. 따라서 이메일 확인을 위해 미국 모드에서 정규식을 사용해야합니다. ECMAScript 모드를 사용하지 않으면 언어 특수 문자가 정규식이있는 AZ에 포함됩니다.

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

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

예 :

• IsValidEmail("@b.com") // false
• IsValidEmail("a@.com") // false
• IsValidEmail("a@bcom") // false
• IsValidEmail("a.b@com") // false
• IsValidEmail("a@b.") // false
• IsValidEmail("a b@c.com") // false
• IsValidEmail("a@b c.com") // false
• IsValidEmail("a@b.com") // true
• IsValidEmail("a@b.c.com") // true
• IsValidEmail("a+b@c.com") // true
• IsValidEmail("a@123.45.67.89") // true

단순해야하므로 공백이 포함 된 괄호로 묶인 도메인이있는 이메일 (일반적으로 허용됨), IPv6 주소가있는 이메일 등과 같은 드문 경우를 처리하지 않습니다.

확인할 질문에 대한 답변입니다.

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;

   }

}

@Cogwheel의 답변을 바탕으로 SSIS와 "스크립트 구성 요소"에서 작동하는 수정 된 솔루션을 공유하고 싶습니다.

1. "스크립트 구성 요소"를 Data Flow Connect에 배치 한 다음여십시오.
2. "입력 열"섹션에서 전자 우편 주소가 포함 된 필드를 "ReadWrite"(예 : 'fieldName')로 설정하십시오.
3. "스크립트"섹션으로 다시 전환하고 "스크립트 편집"을 클릭하십시오. 그런 다음 코드가 열린 후 기다려야합니다.

4. 이 코드를 올바른 방법으로 배치하십시오.

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

그런 다음 조건부 분할을 사용하여 모든 유효하지 않은 레코드 나 원하는 것을 필터링 할 수 있습니다.