trier une liste en c#

Version imprimable

08/07/2016, 12h41
hakoun

trier une liste en c#

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
08/07/2016, 13h46
mermich

Salut,

il suffit de faire un group by puis un sort.

Pour le gorup by:

Code:

MaList.GroupBy(x => new { x.Column1, x.Column2 })
08/07/2016, 15h07
hakoun

Trier une liste en C#

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

Salut,

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

Code:

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];
                    }
                }
            }

Cela peut se faire assez simplement avec un GroupBy :

Code:

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:

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#

Merci dorinf...
ça marche nikel.;););)

Citation:

Envoyé par dorinf

Cela peut se faire assez simplement avec un GroupBy :

Code:

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:

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