[LINQ] Groupby , count et orderby

Bonjour,

J'ai un petit problème pour faire une requête LINQ.

J'ai des joueurs qui ont fait des "Choix". Je souhaite retenir le "choix" que les joueurs ont le plus choisis. En cas d'égalité, on regarde le choix du joueurs ayant le plus petit score, parmis les joueurs qui ont fait le choix qui a une égalité.
Or je n'arrive pas à faire ça. J'arrive juste à trier sur le choix le plus grand. Je n'arrive pas regarder sur une seconde propriété.

Dans cet exemple:
- 2 joueurs ont fait le choix 1 (joueur 1 score 30, joueur 2 score 20)
- 2 joueurs ont fait le choix 2 (joueur 3 score 100, joueur 4 score 10)
- 1 joueur a fait le choix 3 (joueur 5 score 0)

Comme il y a une égalité entre le choix 1 et le choix 2.
On départage en fonction du score des joueurs qui ont choisis le score 1 ou 2. C'est donc le choix du joueur 4 qui est pris. Soit le choix 2

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
using System;
using System.Collections.Generic;
using System.Linq;
 
namespace ConsoleApplication1
{
    public class PlayerChoice
    {
        public Player Player { get; set; }
        public Choice Choice { get; set; }
    }
 
    public class Player
    {
        public int Score { get; set; }
    }
 
    public class Choice
    {
    }
 
    class Program
    {
        static void Main(string[] args)
        {
 
            var list = new List<PlayerChoice>();
 
            var c1 = new Choice();
            var c2 = new Choice();
            var c3 = new Choice();
 
            var p1 = new Player { Score = 30 };
            var p2 = new Player { Score = 20 };
            var p3 = new Player { Score = 100 };
            var p4 = new Player { Score = 10 };
            var p5 = new Player { Score = 0 };
 
            list.Add(new PlayerChoice { Choice = c1, Player = p1 });
            list.Add(new PlayerChoice { Choice = c1, Player = p2 });
            list.Add(new PlayerChoice { Choice = c2, Player = p3 });
            list.Add(new PlayerChoice { Choice = c2, Player = p4 });
            list.Add(new PlayerChoice { Choice = c3, Player = p5 });
 
           //Il n'y a pas de tri si il y a égalité pour départager sur le score
            var elt = list.GroupBy(x => x.Choice).OrderByDescending(x => x.Count()).First().Key;
            Console.ReadLine();
        }
    }
}

Merci pour votre aider apporté

Il y a peut-etre plus simple mais ça devrait donner ce que tu veux :
Code:

1 2 var elt = list.GroupBy(x => x.Choice).Select(d => new {Choice = d.Key, NumberOfChoice = d.Count(),Min = d.Min( x => x.Player.Score)}).OrderByDescending(d => d.NumberOfChoice).ThenBy(d => d.Min);
Le 1er élément de la collection est le choix le plus choisi, avec le score minimum.

Merci.

Et pour trouver le choix du joueur qui a le score le plus petit ?
Dois je faire un selectmany sur le player ?

J'ai modifié la query linq, comme ça tu as le joueur :

Code:

1
2
3
4
5
6
 
 
var elt = list.GroupBy(x => x.Choice).Select(d => new {Choice = d.Key, NumberOfChoice = d.Count(),MinPlayer = d.OrderBy(x => x.Player.Score).First().Player}).OrderByDescending(d => d.NumberOfChoice).ThenBy(d => d.MinPlayer.Score);
 
// Pour avoir le joueur
var player = elt.First();

Merci