Comparer les elements dans une liste

Version imprimable

Salut everyone,
J'ai une structure à sérialiser en une fichier XML :

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
[XmlRoot("NXRoutes")]
    public class NXRoutes
    {
        [XmlElement("NXRoute")]
        public List<NXRoute> NXRoute { get; set; }
    }
 
    public class NXRoute
    {
        [XmlAttribute("ID")]
        public string ID { get; set; }
        [XmlAttribute("OriginSignal")]
        public string OriginSignal { get; set; }
        [XmlAttribute("DestinationSignal")]
        public string DestinationSignal { get; set; }
        [XmlElement("Path")]
        public List<Path> Path { get; set; }
    }
 
    public class Path
    {
        [XmlAttribute("Nbr_R")]
        public int R_count { get; set; }
        [XmlAttribute("ID")]
        public string ID { get; set; }
        [XmlAttribute("Preferred")]
        public string Preferred { get; set; }
        [XmlAttribute("SnowPlan")]
        public string SnowPlan { get; set; }
        [XmlText]
        public string PathInnerText { get; set; }
    }

j'ai une List<NXRoute> NXRouteList
chaque element NXRoute de ma liste contient à son tour une liste : List<Path>
chaque element Path contient un attribut de type entier appelé "R_Count"

Dans chaque "NXRoute" je souhaite comparer les elements de la liste "Path" entre eux en se basant sur la valeur de l'attribut "R_Count"
==> Par exemple pour le path qui a la plus petite valeur dans son attribut "R_Count" je ferais un calcul / et pour les autres je fairais un autre calcul

comment comparer donc ces path entre eux en se basant sur l'attribut "R_Count" le plus petit ?

Hello,

Voici comment faire, avec un mélange de boucle et de LINQ pour que ça soit lisible :
Code:

1 2 3 4 5 6 7 8 9 for (int i = 0; i < NXRoute.Count; i++) { Path path = NXRoute[i].Path.OrderBy(p => p.R_count).FirstOrDefault(); if (path != null) // Si il y a une concordance { // Fais ce que tu veux avec 'path' ici } }
Pour chaque Route dans la liste, on va chercher le Path qui possède le R_count le plus bas.

Evidemment, c'est mieux si tu gères le fait qu'il est possible d'avoir plusieurs Path avec unR_count minimal égal. Comme ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 for (int i = 0; i < NXRoute.Count; i++) { Path[] paths = NXRoute[i].Path.OrderBy(p => p.R_count).ToArray(); if (paths != null) // Si il y a une concordance { foreach (Path path in paths) { // Fais ce que tu veux avec 'path' ici } } }
Si tu t'en fiches qu'il soit possible qu'il y en à plusieurs, utilise le premier code. Il prendra le premier venu.

C'est juste un exemple basé sur ce que tu as dit, si tu veux prendre en compte d'autres paramètres, dis le nous. Tu peux aussi te renseigner sur LINQ, qui te permet de faire des requêtes dans tes listes, à la SQL, afin de t'éviter des lignes de code pour rien.

Citation:

Envoyé par PixelJuice

Code:

1
2
3
4
5
6
7
8
9
10
11
12
            for (int i = 0; i < NXRoute.Count; i++)
            {
                Path[] paths = NXRoute[i].Path.OrderBy(p => p.R_count).ToArray();
 
                if (paths != null) // Si il y a une concordance
                {
                    foreach (Path path in paths)
                    {
                        // Fais ce que tu veux avec 'path' ici
                    }
                }
            }

Petite correction sur le deuxième extrait de code (ligne 3) :

Code:

Path[] paths = NXRoute[i].Path.GroupBy(p => p.R_count).OrderBy(g => g.Key).FirstOrDefault()?.ToArray();

Sinon les Path sont bien ordonnés par R_count, mais tous sont pris au lieu de n'avoir que les premiers.