Discussion :

[Rodie]

Bonjour

Quelqu'un connaîtrait-il un algo C# pour détecter des doublons dans une List<string> ?
Ou y-t-il déjà qqch de prévu dans le framework ?
Merci bien

[Thomas Lebrun]

Utilise la méthode Contains

List<String> list = new List<String>();

foreach(string s in list)
{
if (list.Contains(s))
{
// Ta liste contient s
}
}

[Mehdi Feki]

Salut,

foreach(string s in list)
if (list.Contains(s))

Morpheus, je crois que ton algorithme n'est pas bon, la liste contient forcement s.
Ou surement tu voulais faire ca :

Code :

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

1
2
3
4
5
6
 
List<String> ListAvecDuplication = new List<String>();
List<String> ListSansDuplication = new List<String>();
foreach (string s in ListAvecDuplication )
    if (!ListSansDuplication.Contains(s))
          ListSansDuplication .Add(s);

[Thomas Lebrun]

Ah oui, c'est pas bête: je me disais bien qu'il manquait des lignes d ecode
Enfin, l'important ici, c'est tout de même la méthode Contains

[Mehdi Feki]

T'inquiete on est là pour terminer tes lignes de codes manquantes, tu n'a qu'à proposer l'idée

[Rodie]

Ah, pas mal ton algo
Je me disais bien qu'il fallait pas prendre chaque élément et les comparer à tous les autres

Par contre, il manque la fin de l'algo.
Je suppose qu'il suffit de comparer le nombre d'élements de chaque liste, et si ceux-ci sont différents, c'est qu'il y avait un doublon dans la liste.

Merci bcp à vous en tout cas

[Mehdi Feki]

Ah la non je ne savais qu'il fallait juste savoir s'il y avait des doublons
dans ce cas :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
List<String> ListAvecDuplication = new List<String>();
List<String> ListSansDuplication = new List<String>();
bool IlExisteDesDoublons=false;
foreach (string s in ListAvecDuplication )
    if (!ListSansDuplication.Contains(s))
          ListSansDuplication .Add(s);
    else 
    {
         IlExisteDesDoublons=true;
         break;
     }

Pas la peine de terminer la boucle dés que tu trouve le premier doublon tu sors (break

[Rodie]

Ah oui, pas bête...
Je commanderai un cerveau pour Noël
Mici bien

[dacamp]

Bonjour,

Je reviens sur ce topic.
La méthode proposée par mehdi_tn fonctionne parfaitement si votre liste est composé de string.
De mon côté, j'ai une liste contenant des objets personne.
Like this :

Code :

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

1
2
 
List<Personne> ListPersonne = new List<Personne>();

J'ai besoin de supprimer les doublons de ma liste sur deux attributs de mon objet personne (ex : le nom et le prénom)
En gros, si une personne a le meme nom & le meme prénom qu'un autre alors je le supprime.

Visiblement je ne peux pas utiliser la méthode Contains, exact ?

Thx

[joujou_le_fou]

peu être qu'en implémentant l'interface IComparable ca résoudrait le problème?

[dacamp]

Je t'avoue y avoir penser mais je ne maitrise pas vraiment le sujet
Si tu as un exemple de code ?

[Mehdi Feki]

Salut dacamp, tu es en quelle version du framework ?

[dacamp]

je suis en 2.0 sinon je ne pourrais pas utiliser les Collections.Generic tel que les listes fortement typées

[Mehdi Feki]

La méthode contains et l'interface IComparabale existent depuis le framework 1.0, avant que les listes génériques voient le jour dans Dot Net, d'où ma question.

D'abord cherche dans le forum Dot Net IComparable ; tu trouveras plein d'exemples.
Sinon y'a l'exemple de msdn CompareTo
à lequel tu dois surcharger la méthode equals , voici un exemple Override methods on comparable types

[dacamp]

Je sais que cela existe mais je ne le maitrisais déjà pas tres bien en 1.0.
J'utilise la méthode Compare pour trier ma liste typée au préalable afin d'optimiser (je l'espère) le futur dédoublonnage

Maintenant, je ne comprends pas pourquoi la méthode Contains me sort que deux objets personnes sont différents alors que tous les attributs de mon objet sont identiques ... je seche complet. Enfin, je vais creuser un peu plus le problème et je reviendrai pour donner le résultat de mes recherches

[dacamp]

Démonstration par l'exemple.

Distri est une classe contenant une liste d'attributs + getter et setter

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
 
 //test
            List<Distri> v_listeSansDoublon = new List<Distri>();
            List<Distri> v_listeAvecDoublon = new List<Distri>();
 
            Distri toto1 = new Distri();
            toto1.EAN17 = "2121";
            v_listeAvecDoublon.Add(toto1);
 
 
            Distri toto2 = new Distri();
            toto2.EAN17 = "2121";
            v_listeSansDoublon.Add(toto2);
 
            foreach (Distri v_distri in v_listeAvecDoublon)
                if (!v_listeSansDoublon.Contains(v_distri))
                    v_listeSansDoublon.Add(v_distri);

Le résultat de ce morceau de code m'indique qu'il passe dans le résultat du if. Il m'ajoute donc un 2ème élément à la liste v_listeSansDoublon.

[Mehdi Feki]

Maintenant, je ne comprends pas pourquoi la méthode Contains me sort que deux objets personnes sont différents alors que tous les attributs de mon objet sont identiques

Parce que la comparaison se fait par defaut sur les references, tu dois modifier ce comportement.

Pour ton probleme, montre comment tu as implementer Distri.

[dacamp]

Merci de ton aide, c'est bien cool
Voici ma classe Distri

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
using System;
using System.Collections.Generic;
using System.Text;
 
namespace InfertaceDistrirama
{
    class Distri
    {
 
        public Distri()
        { }
 
        private string m_codeOPE;
        private string m_numOPE;
        private string m_statutOP;
        private string m_blanc1;
        private string m_niveauOPE;
        private string m_codeClient;
        private string m_blanc2;
        private string m_EAN13;
        private string m_EAN17;
        private string m_dateDebAppro;
        private string m_dateFinAppro;
        private string m_dateDebComm;
        private string m_dateFinComm;
        private string m_semaine;
        private string m_annee;
        private string m_codeOS;
        private string m_codePR;
        private string m_prixForce;
        private string m_prixTarif;
        private string m_remise;
        private string m_mttRemise;
        private string m_tauxCGV;
        private string m_SRPTTC;
 
        #region Getter & Setter
 
        public string Blanc1
        {
            get { return m_blanc1; }
            set { m_blanc1 = value; }
        }
 
        public string Blanc2
        {
            get { return m_blanc2; }
            set { m_blanc2 = value; }
        }
 
        public string NiveauOPE
        {
            get { return m_niveauOPE; }
            set { m_niveauOPE = value; }
        }
 
        public string CodeClient
        {
            get { return m_codeClient; }
            set { m_codeClient = value; }
        }
 
        public string EAN13
        {
            get { return m_EAN13; }
            set { m_EAN13 = value; }
        }
 
        public string CodeOPE
        {
            get { return m_codeOPE; }
            set { m_codeOPE = value; }
        }
 
        public string NumOPE
        {
            get { return m_numOPE; }
            set { m_numOPE = value; }
        }
 
        public string StatutOP
        {
            get { return m_statutOP; }
            set { m_statutOP = value; }
        }
 
        public string SRPTTC
        {
            get { return m_SRPTTC; }
            set { m_SRPTTC = value; }
        }
 
        public string TauxCGV
        {
            get { return m_tauxCGV; }
            set { m_tauxCGV = value; }
        }
 
        public string MttRemise
        {
            get { return m_mttRemise; }
            set { m_mttRemise = value; }
        }
 
        public string Remise
        {
            get { return m_remise; }
            set { m_remise = value; }
        }
 
        public string PrixTarif
        {
            get { return m_prixTarif; }
            set { m_prixTarif = value; }
        }
        public string PrixForce
        {
            get { return m_prixForce; }
            set { m_prixForce = value; }
        }
 
        public string CodePR
        {
            get { return m_codePR; }
            set { m_codePR = value; }
        }
 
        public string CodeOS
        {
            get { return m_codeOS; }
            set { m_codeOS = value; }
        }
 
        public string Semaine
        {
            get { return m_semaine; }
            set { m_semaine = value; }
        }
 
        public string Annee
        {
            get { return m_annee; }
            set { m_annee = value; }
        }
 
        public string DateFinComm
        {
            get { return m_dateFinComm; }
            set { m_dateFinComm = value; }
        }
 
        public string DateDebComm
        {
            get { return m_dateDebComm; }
            set { m_dateDebComm = value; }
        }
 
        public string DateDebAppro
        {
            get { return m_dateDebAppro; }
            set { m_dateDebAppro = value; }
        }
 
        public string DateFinAppro
        {
            get { return m_dateFinAppro; }
            set { m_dateFinAppro = value; }
        }
 
        public string EAN17
        {
            get { return m_EAN17; }
            set { m_EAN17 = value; }
        }
 
 
 
        #endregion Getter & Setter
 
 
    }
}

[dacamp]

Je tente une idée : on doit modifier
la classe EqualityComparer ??

[Mehdi Feki]

Oui t'as raison, je suis parti sur une mauvaise piste : je pensais à la fonction de tri de la list.

en fait ta classe doit implementer l'interface IEquatable
Par exemple :

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 class Personne : IEquatable<Personne>
    {
        string _nom;
        string _prenom;
 
        public Personne(string n, string p)
        {
            _nom = n;
            _prenom = p;
        }
 
        public bool Equals(Personne other)
        {
            return _nom == other._nom && _prenom == other._prenom;
        }
 
    }