trier une liste en c#

**hakoun** · 08/07/2016, 12h41

Bonjour,

Je viens vers vous, pour m'aider svp et merci par avance.

j'ai des données sur une liste que je veux retravailler...

soft _soft0 = new soft("test", "test", "test", "etest", "test", "ee123*85**$");
soft _soft1 = new soft("ee","ee","ee","ee","ee","ee123");
soft _soft2 = new soft("ee", "ee", "ee", "ee", "ee", "ee345");
soft _soft3 = new soft("ee", "ee", "ee", "ee", "ee", "ee678");
soft _soft4 = new soft("ee", "ee", "ee", "ee", "ee", "ee987");
soft _soft5 = new soft("ee", "ee", "ee", "ee", "ee", "ee654");
soft _soft6 = new soft("ee", "ee", "ee", "ee", "ee", "ee321");

List<filtre.soft> _list = new List<filtre.soft>() ;

_list.Add(_soft0);
_list.Add(_soft1);
_list.Add(_soft2);
_list.Add(_soft3);
_list.Add(_soft4);
_list.Add(_soft5);
_list.Add(_soft6);

Je veux faire un filtre sur _list pour supprimer les doublons et faire une concaténation sur le dernier champ :

En gros avoir que ça dans _list :

"test", "test", "test", "etest", "test", "ee123*85**$" //1 ligne
"ee","ee","ee","ee","ee","ee123, ee345, ee678, ee987, ee654, ee321 " //2 ligne

merci

Bien cordialement

**mermich** · 08/07/2016, 13h46

Salut,

il suffit de faire un group by puis un sort.

Pour le gorup by:

Code :

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

MaList.GroupBy(x => new { x.Column1, x.Column2 })

**hakoun** · 08/07/2016, 15h07

Merci pour l'info...

J'ai oublié de préciser que ma liste est dynamique, donc je ne connais pas son contenu à l'avance.
Quand les 5 colonnes sont identiques (la liste contient 6 colonnes), je veux afficher une seul ligne :
"ee","ee","ee","ee","ee","ee123, ee345, ee678, ee987, ee654, ee321 "

j'avoue que j'ai du mal à trouver le bon algorithme... merci pour votre aide !

Bien cordialement
Hakoun

**Romka** · 08/07/2016, 15h39

Salut,

bon il y a sûrement mieux, je t'avouerais que je suis pas un guru de l'algo, mais bon :

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
 
var listResult = new List<soft>();
 
            foreach (var item in _list)
            {
                if (listResult.Count == 0)
                {
                    listResult.Add(item);
                }
                else
                {
                    var lastResult = listResult[listResult.Count - 1];
                    var kept = false;
 
                    for (var i = 0; i < 5; i++)
                    {
                        if (lastResult[i] != item[i])
                        {
                            listResult.Add(item);
                            kept = true;
                            break;
                        }
                    }
 
                    if (!kept)
                    {
                        lastResult[5] += "," + item[5];
                    }
                }
            }

**François DORIN** · 17/07/2016, 00h56

Cela peut se faire assez simplement avec un GroupBy :

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
using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace SortAndConcat
{
    class Program
    {
        class Soft
        {
            public string _s1;
            public string _s2;
            public string _s3;
            public string _s4;
            public string _s5;
            public string _s6;
 
            public Soft(string s1, string s2, string s3, string s4, string s5, string s6)
            {
                _s1 = s1;
                _s2 = s2;
                _s3 = s3;
                _s4 = s4;
                _s5 = s5;
                _s6 = s6;
            }
 
            public Soft(Soft s)
            {
                _s1 = s._s1;
                _s2 = s._s2;
                _s3 = s._s3;
                _s4 = s._s4;
                _s5 = s._s5;
                _s6 = s._s6;
            }
        }
 
        static void Main(string[] args)
        {
            Soft _soft0 = new Soft("test", "test", "test", "etest", "test", "ee123*85**$");
            Soft _soft1 = new Soft("ee", "ee", "ee", "ee", "ee", "ee123");
            Soft _soft2 = new Soft("ee", "ee", "ee", "ee", "ee", "ee345");
            Soft _soft3 = new Soft("ee", "ee", "ee", "ee", "ee", "ee678");
            Soft _soft4 = new Soft("ee", "ee", "ee", "ee", "ee", "ee987");
            Soft _soft5 = new Soft("ee", "ee", "ee", "ee", "ee", "ee654");
            Soft _soft6 = new Soft("ee", "ee", "ee", "ee", "ee", "ee321");
 
            List<Soft> list = new List<Soft>();
 
            list.Add(_soft0);
            list.Add(_soft1);
            list.Add(_soft2);
            list.Add(_soft3);
            list.Add(_soft4);
            list.Add(_soft5);
            list.Add(_soft6);
 
            list = list.GroupBy(x => String.Format("{0}_{1}_{2}_{3}_{4}", x._s1, x._s2, x._s3, x._s4, x._s5), 
                                (string key, IEnumerable<Soft> softs) => new Soft(softs.First()) { _s6 = String.Join(", ", softs.Select(z => z._s6)) }).ToList();       
 
            foreach(Soft s in list)
            {
                string key = String.Format("{0}_{1}_{2}_{3}_{4}", s._s1, s._s2, s._s3, s._s4, s._s5);
                Console.WriteLine("{0} = {1}", key, s._s6);
            }
 
            Console.ReadLine();
        }
    }
}

En gros, j'appelle GroupBy avec 2 lambda :

Le premier permet de calculer une clé (ici, j'ai pris la concaténation des 5 premières colonnes) ;
Le second (et j'ai fais apparaitre les types des paramètres pour plus de clarté) calcule la valeur de la 6ème colonne comme étant la concaténation (String.Join) de la 6ème colonne de tous les éléments de la liste ayant la même clé (les 5 premières colonnes identiques).

Si j'exécute le programme ci-dessus, cela donne la sortie que tu souhaites :

Code :

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

1
2
test_test_test_etest_test = ee123*85**$
ee_ee_ee_ee_ee = ee123, ee345, ee678, ee987, ee654, ee321

**hakoun** · 18/07/2016, 16h15

Merci dorinf...
ça marche nikel.

Envoyé par dorinf

Cela peut se faire assez simplement avec un GroupBy :

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
using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace SortAndConcat
{
    class Program
    {
        class Soft
        {
            public string _s1;
            public string _s2;
            public string _s3;
            public string _s4;
            public string _s5;
            public string _s6;
 
            public Soft(string s1, string s2, string s3, string s4, string s5, string s6)
            {
                _s1 = s1;
                _s2 = s2;
                _s3 = s3;
                _s4 = s4;
                _s5 = s5;
                _s6 = s6;
            }
 
            public Soft(Soft s)
            {
                _s1 = s._s1;
                _s2 = s._s2;
                _s3 = s._s3;
                _s4 = s._s4;
                _s5 = s._s5;
                _s6 = s._s6;
            }
        }
 
        static void Main(string[] args)
        {
            Soft _soft0 = new Soft("test", "test", "test", "etest", "test", "ee123*85**$");
            Soft _soft1 = new Soft("ee", "ee", "ee", "ee", "ee", "ee123");
            Soft _soft2 = new Soft("ee", "ee", "ee", "ee", "ee", "ee345");
            Soft _soft3 = new Soft("ee", "ee", "ee", "ee", "ee", "ee678");
            Soft _soft4 = new Soft("ee", "ee", "ee", "ee", "ee", "ee987");
            Soft _soft5 = new Soft("ee", "ee", "ee", "ee", "ee", "ee654");
            Soft _soft6 = new Soft("ee", "ee", "ee", "ee", "ee", "ee321");
 
            List<Soft> list = new List<Soft>();
 
            list.Add(_soft0);
            list.Add(_soft1);
            list.Add(_soft2);
            list.Add(_soft3);
            list.Add(_soft4);
            list.Add(_soft5);
            list.Add(_soft6);
 
            list = list.GroupBy(x => String.Format("{0}_{1}_{2}_{3}_{4}", x._s1, x._s2, x._s3, x._s4, x._s5), 
                                (string key, IEnumerable<Soft> softs) => new Soft(softs.First()) { _s6 = String.Join(", ", softs.Select(z => z._s6)) }).ToList();       
 
            foreach(Soft s in list)
            {
                string key = String.Format("{0}_{1}_{2}_{3}_{4}", s._s1, s._s2, s._s3, s._s4, s._s5);
                Console.WriteLine("{0} = {1}", key, s._s6);
            }
 
            Console.ReadLine();
        }
    }
}

En gros, j'appelle GroupBy avec 2 lambda :

Le premier permet de calculer une clé (ici, j'ai pris la concaténation des 5 premières colonnes) ;
Le second (et j'ai fais apparaitre les types des paramètres pour plus de clarté) calcule la valeur de la 6ème colonne comme étant la concaténation (String.Join) de la 6ème colonne de tous les éléments de la liste ayant la même clé (les 5 premières colonnes identiques).

Si j'exécute le programme ci-dessus, cela donne la sortie que tu souhaites :

Code :

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

1
2
test_test_test_etest_test = ee123*85**$
ee_ee_ee_ee_ee = ee123, ee345, ee678, ee987, ee654, ee321

trier une liste en c#

Dotnet

Vue hybride

Discussions similaires

Partager

Partager