[List<String>] Supprimer les doublons [FAQ]

**Ticoche** · 03/01/2008, 19h29

Bonjour,

J'ai une List<String> avec des éléments, dont certain sont des doublons, et en sortie j'aimerai récuperer une liste sans les doublons.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
            List<String> locale = new List<string>();
            locale.Add("toto");
            locale.Add("123");
            locale.Add("toto");
            locale.Add("toto");
            locale.Add("123");
            locale.Add("toto");
            locale.Add("toto");
            locale.Add("bidule[]***");
            locale.Add("tobidule[]***to");
            locale.Add("bidule[]***");
 
            locale.Sort();

Ce qui est délicat si je supprime un élément dans la collection alors que je la parcours, je risque d'avoir un OutOfBoundException.

Ne dois-on pas faire l'opération en utilisant une autre liste tampon ?

Merci beaucoup

Voici ce que j'ai fais, et qui ne fonctionne pas correctement :

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
 
            List<String> copie = new List<string>();
            int i = 0;
            foreach (String s in locale)
            {
                try
                {
                    if (locale[i] != locale[++i + 1])
                    {
                        copie.Add(locale[i]);
                    }
                }
                catch (Exception e) { }
 
            }

Il faut que je gére mieux l'index pour ne pas creer une Exception, et j'obtiens encore 1 doubon avec cette méthode... l'algorithme n'est pas bon !

**Bluedeep** · 03/01/2008, 19h55

J'ai une classe avec pas mal de méthodes statiques pour manipuler les collections et tableaux (union, intersection, extraction, concatenation de tableau unidimensionel en multidimensionels, etc ...) et dedans une méthode qui doit te convenir :

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
   /// <summary>
        /// Eliminate duplicate entries in a list 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <returns></returns>
        public static List<T> EnsureUnicity<T>(ICollection<T> list)
        {
            List<T> newList = new List<T>();
            foreach (T item in list)
            {
                if (newList.Contains(item) == false)
                {
                    newList.Add(item);
                }
            }
            return newList;
        }

**SirJulio** · 03/01/2008, 19h55

Salut,

> C# 3

Code :

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

IEnumerable<string> listeSansDoublon = locale.Distinct();

> C# 2

il faut en effet jouer sur deux listes, triant au fur et à mesure.

Bon courage. =)

**Ticoche** · 03/01/2008, 20h53

Merci, ça devrait beaucoup m'aider...

A l'origine du problème, un champs en Base de Données de type "Text" sur lequel on ne peux pas faire de DISTINCT.

Ma solution : Je récupère la colonne que j'ajoute à une Table de mon DataSet, puis je créé une liste (List<String>) à partir de la table, ensuite (c'est là que vous m'avez aider) je supprime les doublons, et enfin j'ajoute cette Liste à mon DataSet (en supprimant l'ancienne).

D'ailleur, si vous avez des proposition pour faire quelque chose de moins lourd, en sachant que non-trier la liste avec les doublons comprends + de 30.000 lignes !

Je penses que je peux faire un DataReader pour la liste temporaire à la place ?

Dans tous les cas, comment ajouter une List<String> dans une nouvelle Table d'un DataSet ?!?

Merci beaucoup Bluedeep pour ta methode, je suis même interressé par ta class si ça te dérange pas ?

**Bluedeep** · 04/01/2008, 08h18

Envoyé par Ticoche

Merci beaucoup Bluedeep pour ta methode, je suis même interressé par ta class si ça te dérange pas ?

en voilà un bout (le reste contient du code métier, donc, cette partie c'est pas possible sans "purgation préalable", si j'ai 10mn à perdre lundi)

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
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
 
        /// <summary>
        /// Returns true if a collection contains items
        /// </summary>
        /// <param name="collection"></param>
        /// <returns></returns>
        public static bool HasContent(ICollection collection)
        {
            return (collection != null && collection.Count > 0);
        }
 
 
        /// <summary>
        /// Returns true if a collection contains items
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <returns></returns>
        private static bool HasContent<T>(ICollection<T> collection)
        {
            return (collection != null && collection.Count > 0);
        }
 
        /// <summary>
        /// Extract an array of objects from a given type from an array
        /// </summary>
        /// <returns></returns>
        public static T[] ExtractObjects<T>(object[] objectsArray) where T : class
        {
            T[] adjustedSizeArray = null;
            if (objectsArray != null && objectsArray.Length > 0)
            {
                int cObjects = 0;
                // Extract data.
                T[] typedObjects = new T[objectsArray.Length];
                for (int i = 0; i < objectsArray.Length; i++)
                {
                    if (objectsArray[i] is T)
                    {
                        typedObjects[cObjects] = (T)objectsArray[i];
                        cObjects++;
                    }
                }
                if (cObjects > 0)
                {
                    adjustedSizeArray = new T[cObjects];
                    Array.Copy(typedObjects, adjustedSizeArray, cObjects);
                }
            }
            return adjustedSizeArray;
        }
 
 
 
        /// <summary>
        /// Return the smallest not empty collection in a list of collection
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listOfList"></param>
        /// <returns></returns>
        public static ICollection<T> GetSmallest<T>(ICollection<ICollection<T>> listOfList)
        {
            int min = -1;
            ICollection<T> collMin = null;
            foreach (ICollection<T> coll in listOfList)
            {
                if (HasContent(coll))
                {
                    if (min <= 0)
                    {
                        min = coll.Count;
                        collMin = coll;
                    }
                    else if (coll.Count < min)
                    {
                        collMin = coll;
                        min = coll.Count;
                    }
                }
            }
            return collMin;
        }
 
        /// <summary>
        /// Return the intersection of two collection
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list1"></param>
        /// <param name="list2"></param>
        /// <returns></returns>
        public static List<T> Intersection<T>(ICollection<T> list1, ICollection<T> list2) where T : class
        {
            List<T> newList = new List<T>();
            if (HasContent<T>(list1) && HasContent<T>(list2))
            {
                foreach (T t in list1)
                {
                    if (list2.Contains(t) && (newList.Contains(t) == false))
                    {
                        newList.Add(t);
                    }
                }
            }
            return newList;
        }
 
 
        /*
                /// <summary>
                /// Return the intersection of a list of collection
                /// </summary>
                /// <typeparam name="T"></typeparam>
                /// <param name="listOfList"></param>
                /// <returns></returns>
                public static List<T> Intersection<T>(ICollection<ICollection<T>> listOfList) 
                {
                    List<T> list = new List<T>();
                    if (listOfList == null || listOfList.Count == 0)
                    {
                        return list;
                    }
                    IEnumerator<ICollection<T>> iEnumerator = listOfList.GetEnumerator();
                    iEnumerator.MoveNext();
                    ICollection<T> coll1 = iEnumerator.Current;
                    if (listOfList.Count == 1)
                    {
                        list.AddRange(coll1);
                    }
                    else
                    {
                        while (iEnumerator.MoveNext())
                        {
                            ICollection<T> coll2 = iEnumerator.Current;
                            list = Intersection<T>(coll1, coll2);
                            coll1 = list;
                        }
                    }
                    return list;
                }
         */
 
        public static List<T> Intersection<T>(ICollection<ICollection<T>> collections)
        {
            List<T> result = new List<T>();
 
            foreach (ICollection<T> collection in collections)
            {
                foreach (T item in collection)
                {
                    // Stop here if item has been processed yet.
                    if (result.Contains(item))
                    {
                        break;
                    }
 
                    // Try to find collection that doesn't own the item.
                    bool itemBelongToIntersection = true;
                    foreach (ICollection<T> collection2 in collections)
                    {
                        if (collection2.Contains(item) == false)
                        {
                            itemBelongToIntersection = false;
                            break;
                        }
                    }
 
                    // Item is excluded from result if not present in at least one collection.
                    if (itemBelongToIntersection)
                    {
                        result.Add(item);
                    }
                }
            }
 
            return result;
        }
 
 
 
        /// <summary>
        /// Union of two collection without duplicate entries
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list1"></param>
        /// <param name="list2"></param>
        /// <returns></returns>
        public static List<T> Union<T>(ICollection<T> list1, ICollection<T> list2) where T : class
        {
            List<T> newList = new List<T>();
            if (HasContent<T>(list1))
            {
                newList.AddRange(list1);
            }
            if (HasContent<T>(list2))
            {
                newList.AddRange(list2);
            }
            return EnsureUnicity<T>(newList);
        }
 
 
 
        /// <summary>
        /// Eliminate duplicate entries in a list 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <returns></returns>
        public static List<T> EnsureUnicity<T>(ICollection<T> list)
        {
            List<T> newList = new List<T>();
            foreach (T item in list)
            {
                if (newList.Contains(item) == false)
                {
                    newList.Add(item);
                }
            }
            return newList;
        }
 
 
        /// <summary>
        /// Eliminate Duplicate Entry in an array
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array"></param>
        /// <returns></returns>
        public static T[] EnsureUnicity<T>(T[] array) where T : class
        {
            return EnsureUnicity<T>(ToList<T>(array)).ToArray();
        }
 
        /// <summary>
        /// Converts a collection to an array
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <returns></returns>
        public static T[] ToArray<T>(ICollection<T> list) where T : class
        {
            if (list == null)
                return null;
            T[] array = new T[list.Count];
            int index = 0;
            foreach (T t in list)
            {
                array[index++] = t;
            }
            return array;
        }
 
        /// <summary>
        /// Convert an array to a list
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array"></param>
        /// <returns></returns>
        public static List<T> ToList<T>(T[] array) where T : class
        {
            if (array == null)
                return null;
            List<T> newList = new List<T>();
            if (array.GetLength(0) > 0)
            {
                newList.AddRange(array);
            }
            return newList;
        }
 
 
        /// <summary>
        /// Convert a ReadOnlyCollection to a List
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <returns></returns>
        public static List<T> ToList<T>(ReadOnlyCollection<T> list) where T : class
        {
            if (list == null)
                return null;
            List<T> newList = new List<T>();
            if (list.Count > 0)
            {
                newList.AddRange(list);
            }
            return newList;
        }
 
        /// <summary>
        /// Array to ReadOnlyCollection
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array"></param>
        /// <returns></returns>
        public static ReadOnlyCollection<T> ToReadOnlyCollection<T>(T[] array) where T : class
        {
            return ToList<T>(array).AsReadOnly();
        }
 
        /// <summary>
        /// extract a two column array from a n columns one
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array"></param>
        /// <param name="indiceX"></param>
        /// <param name="indiceY"></param>
        /// <returns></returns>
        public static T[,] Slice<T>(T[,] array, int indiceX, int indiceY)
        {
            int arrayLength = array.GetLength(0);
            T[,] outArray = new T[arrayLength, 2];
            for (int i = 0; i < arrayLength; i++)
            {
                outArray[i, 0] = array[i, indiceX];
                outArray[i, 1] = array[i, indiceY];
            }
            return outArray;
        }
 
        /// <summary>
        /// concat two columns to make a bidimensional array
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array1"></param>
        /// <param name="array2"></param>
        /// <returns></returns> 
        public static T[,] Concat<T>(T[] array1, T[] array2)
        {
            T[,] outArray = new T[array1.Length, array2.Length];
            for (int i = 0; i < Math.Max(array1.Length, array2.Length); i++)
            {
                if (i < array1.Length)
                    outArray[i, 0] = array1[i];
                if (i < array2.Length)
                    outArray[i, 1] = array2[i];
            }
            return outArray;
        }
 
        /// <summary>
        /// add a column to a bidimensional array
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array1"></param>
        /// <param name="array2"></param>
        /// <returns></returns>
        public static T[,] Concat<T>(T[,] array1, T[] array2)
        {
            int xMax = Math.Max(array1.GetLength(0), array2.Length);
            int yMax = array1.GetLength(1) + 1;
            T[,] outArray = new T[xMax, yMax];
            for (int x = 0; x < xMax; x++)
            {
                if (x < array1.GetLength(0))
                {
                    for (int y = 0; y < array1.GetLength(1); y++)
                    {
                        outArray[x, y] = array1[x, y];
                    }
                }
                outArray[x, yMax] = array2[x];
            }
            return outArray;
        }
 
        /// <summary>
        /// Check if two arrays have the same content
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array1"></param>
        /// <param name="array2"></param>
        /// <returns></returns>
        public static bool Equals<T>(T[] array1, T[] array2)
        {
            if (array1 == array2)
            {
                return true;
            }
            if (array1 == null || array2 == null || (array1.Length != array2.Length))
            {
                return false;
            }
            for (int i = 0; i < array1.Length; i++)
            {
                if (array1[i].Equals(array2[i]) == false)
                {
                    return false;
                }
            }
            return true;
        }
 
        /// <summary>
        /// Check if objects in a collection have identical type
        /// </summary>
        /// <returns>objects' type if collection is homogeneous or default(Type) otherwise</returns>
        public static Type GetTypeIfHomogeneous(ICollection iCollection)
        {
            if (iCollection == null)
            {
                throw new ArgumentNullException();
            }
            Type objectsType = default(Type);
            if (iCollection.Count > 0)
            {
                object[] objectsArray = new object[iCollection.Count];
                iCollection.CopyTo(objectsArray, 0);
                if (objectsArray != null && objectsArray.Length > 0)
                {
                    if (objectsArray[0] != null)
                    {
                        objectsType = objectsArray[0].GetType();
                        for (int i = 1; i < objectsArray.Length; i++)
                        {
                            if (objectsArray[i].GetType() != objectsType)
                            {
                                return default(Type);
                            }
                        }
                    }
                }
            }
            return objectsType;
        }
 
        /// <summary>
        /// Check if objects in a collection are all of the same given type
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="iCollection"></param>
        /// <returns></returns>
        public static bool CheckContentForTypeHomogeneity<T>(ICollection iCollection) where T : class
        {
            bool homogeneous = true;
            if (iCollection == null)
            {
                throw new ArgumentNullException();
            }
            if (iCollection.Count > 0)
            {
                object[] objectsArray = new object[iCollection.Count];
                iCollection.CopyTo(objectsArray, 0);
                for (int i = 0; i < objectsArray.Length; i++)
                {
                    if (objectsArray[i] is T == false)
                    {
                        homogeneous = false;
                        break;
                    }
                }
            }
            return homogeneous;
        }
 
        /// <summary>
        /// Convert an array from one type to another - returns a null array if conversion failed
        /// </summary>
        /// <typeparam name="O"></typeparam>
        /// <typeparam name="E"></typeparam>
        /// <param name="entry"></param>
        /// <returns></returns>
        public static O[] Convert<O, E>(E[] entry)
            where O : class
            where E : class
        {
            return Convert<O, E>(entry, false);
        }
 
        /// <summary>
        /// Convert an array from one type to another - 
        /// </summary>
        /// <typeparam name="O"></typeparam>
        /// <typeparam name="E"></typeparam>
        /// <param name="entry"></param>
        /// <param name="continueOnError">if true, array is returned with null items on failed conversions</param>
        /// <returns></returns>
        public static O[] Convert<O, E>(E[] entry, bool continueOnError)
            where O : class
            where E : class
        {
            if (entry == null)
            {
                return null;
            }
            O[] outArray = new O[entry.Length];
            for (int i = 0; i < entry.Length; i++)
            {
                outArray[i] = entry[i] as O;
                if (outArray[i] == null && entry[i] != null  && continueOnError == false)
                {
                    return null;
                }
            }
            return outArray;
        }