C# LINQ查询到按多个和顺序分组

我有以下数据结构：

public class Difference
{
    public Difference() { }
    public Differential Type { get; set; }
    public int Magnitude { get; set; }
}
public enum Differential
{
    low,
    middle,
    high
}

我可能有以下数据：

Magnitude      Type
4456           low
4456           low
4423           low
4421           low
1000           high
1000           high
1001           high
1560           middle
4456           low
4421           low

我试图返回一个数据集，该数据集为我提供了相同maginitude及其类型的数量计数，但每种类型中的顶部都是按计数降序排列的，因此对于上述（按顺序排列）

值：4456类型：Low计数：3

值：1000类型：High计数：2

值：1560类型：中间计数：1

注意到4421在计数为2时不在那里，因为4456的计数更大

我想我已经很接近了，但还不是很接近：

var query = (from value in differences
             group value by new {value.Magnitude, value.Type} into groupjoin
             select new
             {
                 Value = groupjoin.Key.Magnitude,
                 Type = groupjoin.Key.Type,
                 Count = groupjoin.Count()                                         
             })
            .OrderByDescending(v => v.Count)
            .ThenByDescending(v => v.Value).ThenByDescending(v => v.Type).ToList();

更新

根据道格拉斯在下面提出的建议，ive通过以下方式实现了它。如果可能的话，我不太关心是否有关系，我只想返回第一个（）关系（对于每种类型）。我只能通过循环执行以下操作：

var query = (from value in differences
                                 /*where value.type == Differential.low*/
                                 group value by new {value.Magnitude, value.Type} into groupjoin
                                 select new
                                 {
                                     Value = groupjoin.Key.Magnitude,
                                     Type = groupjoin.Key.Type,
                                     Count = groupjoin.Count()                                         
                                 });

                    var query2 = query.Where(g1 => !query.Any(g2 =>
                                    g2.Type == g1.Type &&
                                    g2.Count > g1.Count));

                    int highest = 0;
                    int lowest = 0;
                    int middle = 0;
                    foreach (var item in query2)
                    {
                        if (item.Type == Differential.high && item.Count > highest) 
                        {
                            oresult.numberOfHighHits = item.Count;
                            oresult.highTimeMagnitude = item.Value;
                        }
                        if (item.Type == Differential.low && item.Count > lowest)
                        {
                            oresult.numberOfLowHits = item.Count;
                            oresult.lowTimeMagnitude = item.Value;
                        }
                        if (item.Type == Differential.middle && item.Count > middle)
                        {
                            oresult.numberOfMiddleHits = item.Count;
                            oresult.middleTimeMagnitude = item.Value;
                        }
                    }

---

我保留了LINQ查询的第一部分，它给出了不同数量级类型对的分组（及其计数）：

然后，我正在编写另一个LINQ，它接受第一个查询生成的所有分组，并且对于每个分组

g1

，检查是否不存在任何其他具有相同类型和更大计数的分组

g2

。这将确保只返回其类型计数最大的分组。在联系的情况下（相同类型的多个分组具有相同的最大计数），将返回所有顶级分组

var query2 = query.Where(g1 => 
    !query.Any(g2 => 
        g2.Type == g1.Type && 
        g2.Count > g1.Count));

---

编辑：要为每种类型返回一个结果，即使是在有联系的情况下，我们也可以在

查询2

过滤器中添加另一个条件，这样，如果两个分组具有相同的

类型

和相同的

计数

，则具有较大

值的分组（最初命名为
幅值
）他被选中了。如果您希望选择
值较小的
，只需将最后一个
替换为
，最好有一个代码来构建示例数据。我懒得把你的数据复制/粘贴到我的
列表=
谢谢道格拉斯，效果很好！我已经在我的初始帖子中添加了更新。你能帮忙吗？
var query2 = query.Where(g1 => 
    !query.Any(g2 => 
        g2.Type == g1.Type && 
        g2.Count > g1.Count));

var query2 = query.Where(g1 => 
    !query.Any(g2 => 
        g2.Type == g1.Type && 
        (g2.Count > g1.Count || (g2.Count == g1.Count && g2.Value > g1.Value))));