Discussion :

[Johann7751]

Bonjour,

Je cherche à faire un regex qui n'accepte que les chaînes de caractères au format suivant :

adresse mail simple
ou
adresses mails séparées par des "," ou des ";"

Dans le cas d'une succession d'adresses mails, la dernière n'a pas de "," ou de ";" à la fin.

J'ai déjà le regex pour vérifier une adresse mail. Il fonctionne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

string pattern = @"^([a-zA-Z0-9_\.]+)@([a-zA-Z0-9_\-]+)\.([\w]{2,4})$";

Voilà, si vous avez des idées ou si vous l'avez déjà fait..
Je cherche de mon côté mais j'ai tendance à vite m'embrouiller avec les expressions régulières.


Johann

[Kaidan]

Un Split avec un char[] { ',' , ';' } et une vérification email par email ?

Sinon, il faut utiliser un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
(^([a-zA-Z0-9_\.]+)@([a-zA-Z0-9_\-]+)\.([\w]{2,4})$)|(^(([a-zA-Z0-9_\.]+)@([a-zA-Z0-9_\-]+)\.([\w]{2,4})[ ]*([,;])[ ]*)+(([a-zA-Z0-9_\.]+)@([a-zA-Z0-9_\-]+)\.([\w]{2,4}))$)

(probablement des erreurs de parenthèses... )

[Max]

Salut.

Je pense que tu peux simplement splitter ta chaîne et appliquer ta regex existante sur chaque morceau... ce n'est pas très propre mais ça a le mérite d'être simple

edit : pas assez rapide

[StormimOn]

On peut simplifier ton expression kaidan

Sans capture par les groupes pour tester uniquement la forme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

^(?:[\w.]+@[\w-]+\.\w{2,4}[,;]?)*[\w.]+@[\w-]+\.\w{2,4}$

J'ai mis des \w au lieu des a-zA-Z0-9_ juste pour le confort de lecture.

Avec capture, ce qui permet de tester et d'avoir accès aux adresses en même temps si besoin

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

^(?:(?<mail>[\w.]+@[\w-]+\.\w{2,4})[,;]?)*(?<mail>[\w.]+@[\w-]+\.\w{2,4})$

[Johann7751]

Salut,

Merci pour vos réponses.
La méthode du Split c'est excellent, je connaissais pas, c'est parfaitement adapté à mon problème.


Voici ma méthode de validation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/// <summary>
        /// Vérifie si une chaîne de caractères est dans le format 'adresse mail' ou 'succession d'adresse mails'
        /// </summary>
        /// <param name="mail">chaîne de caractères à analyser</param>
        /// <returns>retourne 'true' si la chaîne de caractères passée en paramètre est un format valide. Retourne 'false' dans le cas contraire.</returns>
        public static bool ValidMail(string mail)
        {
 
            string pattern = @"^([a-zA-Z0-9_\.]+)@([a-zA-Z0-9_\-]+)\.([\w]{2,4})$";
            bool validity = true;
 
 
            // 1er Test : Test de la syntaxe pour une unique adresse mail
            bool test1;
            Regex r1 = new Regex(pattern);
            test1 = r1.IsMatch(mail);
 
            if (test1 == true)
            {
                return validity;
            }
 
            // 2ème Test : Test pour une succession d'adresse mails séparées soit par des ";", soit par des ","
            else
            {
                validity = true;
 
                bool test2;
 
                // Déclaration d'u tableau de séparateurs
                char []separators = {',',';'};
 
                // Séparation de la chaîne récupérée d'adresses mails
                string[] sousChaines = mail.Split(separators);
 
                // Pour chaque sous chaînes..
                foreach (string s in sousChaines)
                {
                    // Si la sous chaîne n'est pas vide..
                    if (s.Equals(string.Empty) == false)
                    {
                        // Vérification de la syntaxe de la sous chaîne
                        Regex r2 = new Regex(pattern);
                        test2 = r2.IsMatch(s.Trim());
 
                        // Si la sous chaîne n'a pas la bonne syntaxe..
                        if (test2 == false)
                        {
                            // validité incorrecte
                            validity = false;
                        }
                    }
                }
 
                return validity;
            }

Par contre j'ai pas testé votre nouveau regex..

Merci à tous.

[StormimOn]

Tu te compliques un peu la vie, on va simplifier ça ^^

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static bool ValidMail(string mail)
{
    if (string.IsNullOrEmpty(mail)) { return false; }
 
    string pattern = @"^([a-zA-Z0-9_.]+)@([a-zA-Z0-9_-]+)\.([\w]{2,4})$";
    string[] emails = mail.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
 
    foreach (string s in emails)
    {
        if (!Regex.IsMatch(s.Trim(), pattern))
        {
            return false;
        }
    }
 
    return true;
}

Si on considère que des séparateurs qui se suivent sont valides et qu'il peut y avoir des espaces non gênants, ceci devrait donner le même résultat

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
public static bool ValidMail2(string mail)
{
    string pattern = @"^(?:\s*(?:[a-zA-Z0-9_.]+@[a-zA-Z0-9_-]+\.\w{2,4})?\s*[,;]?)*\s*(?:[a-zA-Z0-9_.]+@[a-zA-Z0-9_-]+\.\w{2,4})\s*$";
 
    return Regex.IsMatch(mail, pattern);
}

[Johann7751]

Effectivement, tu fais tenir en 10 lignes ce que je fais en 30 lignes.
Merci.