Code C # pour valider l'adresse e-mail
Quel est le code le plus élégant pour valider qu'une chaîne est une adresse e-mail valide?
30 réponses
Et ça?
bool IsValidEmail(string email)
{
try {
var addr = new System.Net.Mail.MailAddress(email);
return addr.Address == email;
}
catch {
return false;
}
}
Pour clarifier, la question Est de savoir si une chaîne particulière est une représentation valide d'une adresse e-mail, pas si une adresse e-mail est une destination valide pour envoyer un message. Pour cela, le seul moyen est d'envoyer un message pour confirmer.
Notez que les adresses e-mail sont plus indulgentes que vous pourriez d'abord supposer. Ce sont toutes des formes parfaitement valides:
- roue dentée
- " roue dentée le orange " @example.com
- 123@$.xyz
Pour la plupart des cas d'utilisation, un faux " invalide "est bien pire pour vos utilisateurs et pour l'avenir qu'un faux"valide". Voici un article qui était la réponse acceptée à cette question (cette réponse a depuis été supprimée). Il a beaucoup plus de détails et d'autres idées sur la façon de résoudre le problème.
Fournir des contrôles de santé mentale est toujours une bonne idée pour l'expérience utilisateur. En supposant que l'adresse e - mail est valide, Vous pouvez rechercher domaines de premier niveau connus, vérifiez le domaine pour un enregistrement MX, vérifiez les fautes d'orthographe des noms de domaine communs (gmail.ocm), etc. Ensuite, présentez un avertissement donnant à l'utilisateur une chance de dire "oui, mon serveur de messagerie permet vraiment une adresse e-mail."
En ce qui concerne l'utilisation de la gestion des exceptions pour la logique métier, je suis d'accord que c'est une chose à éviter. Mais c'est l'un de ces cas où la commodité et la clarté peuvent l'emporter sur le dogme.
D'ailleurs, si vous faites autre chose avec le adresse e-mail, il va probablement impliquer de le transformer en une adresse mail. Même si vous n'utilisez pas cette fonction exacte, vous voudrez probablement utiliser le même modèle. Vous pouvez également rechercher des types spécifiques d'échec en interceptant différentes exceptions : format null, vide ou invalide.
Par Commentaire de Stuart, cela compare l'adresse finale avec la chaîne d'origine au lieu de toujours renvoyer true. MailAddress essaie d'analyser une chaîne avec des espaces dans "Nom D'affichage" et "Adresse" portions, de sorte que la version originale renvoyait des faux positifs.
- - - Autres lectures - - -
C'est une vieille question, mais toutes les réponses que j'ai trouvées sur SO, y compris les plus récentes, sont répondues de la même manière que celle-ci. Cependant, dans. Net 4.5 / MVC 4, Vous pouvez ajouter une validation d'adresse e-mail à un formulaire en ajoutant l'annotation [EmailAddress] du système.ComponentModel.DataAnnotations, donc je me demandais pourquoi je ne pouvais pas simplement utiliser la fonctionnalité intégrée de. Net en général.
Cela semble fonctionner, et me semble être assez élégant:
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;
}
}
.net 4.5 ajouté Système.ComponentModel.DataAnnotations.EmailAddressAttribute
Vous pouvez parcourir la sourceEmailAddressAttribute , c'est la Regex qu'il utilise en interne:
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])))\.?$";
J'ai pris la réponse de Phil de #1 et créé cette classe.
Appelez-le comme ceci: bool isValid = Validator.EmailIsValid(emailString);
Voici la classe:
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;
}
}
J'utilise cette méthode de revêtement unique qui fait le travail pour moi -
using System.ComponentModel.DataAnnotations;
public bool IsValidEmail(string source)
{
return new EmailAddressAttribute().IsValid(source);
}
Personnellement, je dirais que vous devriez simplement vous assurer qu'il y a un symbole @ là-dedans, avec éventuellement un . caractère. Il y a beaucoup d'expressions rationnelles que vous pouvez utiliser avec une exactitude variable, mais je pense que la plupart d'entre elles omettent les adresses e-mail valides ou laissent passer celles qui ne sont pas valides. Si les gens veulent mettre dans une fausse adresse e-mail, ils vont mettre dans un faux. Si vous devez vérifier que l'adresse e-mail est légitime, et que la personne est en contrôle de cette adresse e-mail, alors vous devrez leur envoyer un email avec un lien codé spécial afin qu'ils puissent vérifier qu'il est en effet une adresse réelle.
Je pense que la meilleure façon est la suivante:
public static bool emailIsValid(string email)
{
string expresion;
expresion = "\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
if (Regex.IsMatch(email, expresion))
{
if (Regex.Replace(email, expresion, string.Empty).Length == 0)
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
, Vous pouvez avoir cette fonction statique dans une classe générale.
La façon la plus élégante est d'utiliser les méthodes intégrées de.Net.
Ces méthodes:
Sont éprouvés. Ces méthodes sont utilisées dans mes propres projets professionnels.
Utilisez des expressions régulières en interne, qui sont fiables et rapides.
Fait par Microsoft pour C#. Il n'y a pas besoin de réinventer la roue.
Renvoie un résultat bool. True signifie que l'e-mail est valide.
Pour les utilisateurs de .Net 4.5 et plus grand
Ajoutez cette référence à votre projet:
Système.ComponentModel.DataAnnotations
Maintenant, vous pouvez utiliser le code suivant:
(new EmailAddressAttribute().IsValid("youremailhere@test.test"));
Exemple d'utilisation de
Voici quelques méthodes à déclarer:
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;
}
...et le code les démontrant en action:
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());
}
En outre, cet exemple:
- S'étend au-delà de la spécification car une seule chaîne est utilisée pour contenir 0, une ou plusieurs adresses e-mail point-virgule
;. - montre clairement comment utiliser la méthode IsValid de L'objet EmailAddressAttribute.
Alternative, pour les utilisateurs d'une version de. Net inférieure à 4.5
Pour les situations où. Net 4.5 n'est pas disponible, j'utilise la solution suivante:
Plus précisément, j'utilise:
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;
}
Je trouve que cette regex est un bon compromis entre vérifier quelque chose de plus que la marque@, et accepter des cas de bord étranges:
^[^@\s]+@[^@\s]+(\.[^@\s]+)+$
Cela vous fera au moins mettre quelque chose autour de la marque@, et mettre au moins un domaine d'apparence normale.
Code court et précis
public static bool IsValidEmail(this string email)
{
const string pattern = @"^(?!\.)(""([^""\r\\]|\\[""\r\\])*""|" + @"([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)" + @"@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$";
var regex = new Regex(pattern, RegexOptions.IgnoreCase);
return regex.IsMatch(email);
}
La validation de l'adresse e-mail n'est pas aussi facile que cela puisse paraître. Il est théoriquement impossible de valider complètement une adresse e-mail en utilisant simplement une expression régulière.
Consultez mon blog post à ce sujet pour une discussion sur le sujet et une implémentation F # en utilisant FParsec. [/shameless_plug]
Pour être honnête, dans le code de production, le mieux que je fasse est de vérifier un symbole @.
Je ne suis jamais dans un endroit pour valider complètement les e-mails. Tu sais comment je vois si c'était vraiment valide? S'il a été envoyé. Si ce n'est pas le cas, c'est mauvais, si c'est le cas, la vie est bonne. C'est tout ce j'ai besoin de savoir.
Voici ma réponse-la solution de Phil échoue pour les domaines à une seule lettre comme "someone@q.com". croyez-le ou non, c'est utilisé =) (va à centurylink, par exemple).
La réponse de Phil ne fonctionnera également qu'avec la norme PCRE... donc C# le prendra, mais javascript va bombarder. C'est trop complexe pour le javascript. Vous ne pouvez donc pas utiliser la solution de Phil pour les attributs de validation mvc.
Voici ma regex. Cela fonctionnera bien avec les attributs de validation MVC.
- Tout avant de le @ est simplifié, de sorte qu'au moins javascript fonctionnera. Je suis d'accord pour détendre la validation ici tant que exchange server ne me donne pas un 5.1.3.
- Tout après le @ est la solution de Phil modifiée pour les domaines à une seule lettre.
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]$";
Pour les personnes suggérant d'utiliser system. net. mail MailMessage (), cette chose est très flexible. Bien sûr, C# acceptera l'e-mail, mais exchange server bombera avec une erreur d'exécution 5.1.3 dès que vous essayez d'envoyer l'e-mail.
Si vous voulez vraiment et je veux vraiment savoir si une adresse e-mail est valide...demandez à l'échangeur de courrier de le prouver, pas de regex nécessaire. Je peux fournir le code si demandé.
Les étapes générales sont les suivantes: 1. ne adresse email avoir un nom de domaine partie? (indice de @ > 0) 2. à l'aide d'une requête DNS demandez si le domaine a un échangeur de courrier 3. ouvrir la connexion tcp à l'échangeur de courrier 4. en utilisant le protocole smtp, ouvrez un message au serveur en utilisant l'adresse e-mail comme récepteur 5. analyser le serveur réponse. 6. quittez le message si vous l'avez fait jusqu'ici, tout est bon.
C'est comme vous pouvez l'imaginer, très coûteux en temps et repose sur smtp, mais cela fonctionne.
D'une manière générale, une expression régulière pour valider les adresses e-mail n'est pas une chose facile à trouver; au moment d'écrire ces lignes, la syntaxe d'une adresse e-mail doit suivre un nombre relativement élevé de normes et leur implémentation dans une expression régulière est pratiquement irréalisable!
Je vous suggère fortement d'essayer notre EmailVerify.NET , une bibliothèque. net mature qui peut valider les adresses e-mail suivant tous les des normes IETF actuelles (RFC 1123, RFC 2821, RFC 2822, RFC 3696, RFC 4291, RFC 5321 et RFC 5322), teste les enregistrements DNS associés, vérifie si les boîtes aux lettres cibles peuvent accepter des messages et peut même dire si une adresse donnée est jetable ou non.
Avertissement: je suis le développeur principal de ce composant.
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;
}
Vérifier que la chaîne d'e-mail est au bon format ou au mauvais format par 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";
}
}
/ Utilisation de L'expression rationnelle interne utilisée pour créer le composant" new EmailAddressAttribute (); " dans. Net4. 5 > > > Utilisation du système.ComponentModel.DataAnnotations; // Pour valider une adresse e-mail......Testé et de travail.
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;
}
}
Aussi, Vous pouvez utiliser ceci:
Http://msdn.microsoft.com/en-us/library/01escwtf(v=vs. 110).aspx
Voici une réponse à votre question à vérifier.
using System;
using System.Globalization;
using System.Text.RegularExpressions;
public class RegexUtilities
{
public bool IsValidEmail(string strIn)
{
if (String.IsNullOrEmpty(strIn))
{
return false;
}
// Use IdnMapping class to convert Unicode domain names.
try
{
strIn = Regex.Replace(strIn, @"(@)(.+)$", this.DomainMapper, RegexOptions.None, TimeSpan.FromMilliseconds(200));
}
catch (RegexMatchTimeoutException)
{
return false;
}
if (invalid)
{
return false;
}
// Return true if strIn is in valid e-mail format.
try
{
return Regex.IsMatch(strIn, @"^(?("")("".+?(?<!\\)""@)|(([0-9a-z]((\.(?!\.))| [-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-\w]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9]))$", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250));
}
catch (RegexMatchTimeoutException)
{
return false;
}
}
private string DomainMapper(Match match)
{
// IdnMapping class with default property values.
IdnMapping idn = new IdnMapping();
string domainName = match.Groups[2].Value;
try
{
domainName = idn.GetAscii(domainName);
}
catch (ArgumentException)
{
invalid = true;
}
return match.Groups[1].Value + domainName;
}
}
private static bool IsValidEmail(string emailAddress)
{
const string validEmailPattern = @"^(?!\.)(""([^""\r\\]|\\[""\r\\])*""|"
+ @"([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)"
+ @"@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$";
return new Regex(validEmailPattern, RegexOptions.IgnoreCase).IsMatch(emailAddress);
}
J'ai résumé la réponse de Poyson 1 comme ceci:
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);
}
J'ai écrit une fonction pour vérifier si un e-mail est valide ou non. Il semble bien fonctionner pour moi dans la plupart des cas.
Résultats:
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
Code:
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;
}
Un moyen Simple d'identifier l'emailid est valide ou non.
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})(\]?)$");
}
Il y a un problème de culture dans regex en C # plutôt que js. Nous devons donc utiliser regex en mode américain pour la vérification par courrier électronique. Si vous n'utilisez pas le mode ECMAScript, les caractères spéciaux de votre langue sont implicites dans Az avec regex.
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)
J'ai fini par utiliser cette expression rationnelle, car elle valide avec succès les virgules, les commentaires, les caractères Unicode et les adresses de domaine IP(v4).
Les adresses valides seront:
"" @example.org
(commentaire)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,}))$";
Si vous utilisez FluentValidation vous pouvez écrire quelque chose d'aussi simple que ceci:
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;
Basé sur la réponse de @ Cogwheel je veux partager une solution modifiée qui fonctionne pour SSIS et le "composant Script":
- Placez le "composant Script" dans votre Data Flow connect, puis ouvrez-le.
- dans la section "Colonnes D'entrée", définissez le champ contenant les Adresses E-Mail sur "ReadWrite" (dans l'exemple 'fieldName').
- Revenez à la section "Script" et cliquez sur "Modifier le Script". Ensuite, vous devez attendre après l'ouverture du code.
-
Placez ceci code dans la bonne méthode:
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"; } }
Ensuite, vous pouvez utiliser un Split conditionnel pour filtrer tous les enregistrements invalides ou tout ce que vous voulez faire.
Une petite modification à la réponse @ 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;
}
}
- dans un" try block " envoyer un e-mail de vérification.
- Faites en sorte que l'utilisateur ouvre l'e-mail et cliquez sur un lien pour vérifier que l'e-mail est réel.
Jusqu'à ce que ce processus se termine avec succès, l'e-mail est supposé invalide.
Il y a quelque temps, j'ai écrit un {[1] } qui devrait valider correctement à peu près n'importe quelle adresse e-mail relativement normale du formulaire
local-part@domain
Il est un System.ComponentModel.DataAnnotations.ValidationAttribute, donc l'utilisation est vraiment simple.
Et, puisque creuser à travers tous les RFC et errata et assembler tous les bits nécessaires pour énumérer correctement toutes les règles est...fastidieux - au mieux! - J'ai posté le code source pour le validateur ma réponse à la question C# Adresse Email de validation de pour la source code.
Mon validateur n'est pas parfait par l'imagination, bien que juste pour commencer, il n'a pas de support intégré pour l'émission de la validation javascript côté client,bien qu'il ne soit pas trop difficile d'ajouter cela. De ma réponse ci-dessus:
Voici l'attribut de validation que j'ai écrit. Il valide à peu près tous les e-mails "bruts" l'adresse, c'est à dire ceux de la forme local-part@domaine. Il ne supporte aucun des l'autre, plus...créatif construit que les RFC autorisent (cette liste n'est pas complet par tous les moyens):
- commentaires (par exemple,
jsmith@whizbang.com (work))- chaînes entre guillemets (texte échappé, pour autoriser les caractères non autorisés dans un atome)
- littéraux de domaine (par exemple
foo@[123.45.67.012])- Bang-chemins (aka routage source)
- adresses d'angle (par exemple
John Smith <jsmith@whizbang.com>)- espace pliant
- caractères à deux octets dans Local-part ou domain (ASCII 7 bits uniquement).
- etc.
Il devrait accepter presque n'importe quelle adresse e-mail qui peut être exprimée ainsi
foo.bar@bazbat.comSans nécessiter l'utilisation de guillemets (
"), les crochets ('') ou entre crochets ([]).Aucune tentative n'est faite pour valider que l'étiquette DNS la plus à droite dans le domaine est valide TLD (top-level domain). C'est parce que la liste des TLD est beaucoup plus grande maintenant que le "big 6" (. com,. edu,. gov,. mil,. net,. org) plus les codes de pays ISO à 2 lettres. L'ICANN met à jour quotidiennement la liste des TLD, bien que je soupçonne que la liste ne fait pas les changer tous les jours. En outre, [L'ICANN vient d'approuver une grande expansion de la espace de noms TLD générique][2]). Et certaines adresses e mail n'ont pas ce que vous reconnaîtriez en tant que TLD (saviez-vous que
postmaster@.est théoriquement valide et publiable? Courrier à cette adresse devrait être livré au maître de poste de la zone racine DNS.)Étendre le l'expression pour prendre en charge les littéraux de domaine ne devrait pas être trop difficile.