按多重顺序对组的LINQ查询

Question

我有以下数据结构：

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

我试图返回一个数据集，该数据集给我相同的磁场强度及其类型的和它们的类型，但是在每种类型的中，只有顶部按计数的降序排列，所以对于上面的(顺序)

值： 4456 类型：低计数：3

值： 1000 类型：高计数：2

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

注意到，由于4456有一个更大的计数，4421在2的计数中是如何不存在的？

我想我走得很近，但并不是很近：

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();

更新

根据Douglas提出的建议，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;
                        }
                    }

Answer 1

我保留了LINQ查询的第一部分，它给出了不同大小类型对的分组(以及它们的计数)：

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()                                         
    };

然后，我正在编写另一个LINQ，它接受第一个查询产生的所有分组，并对每个分组g1检查不存在任何具有相同类型和较大计数的其他分组g2。这将确保只返回类型数量最多的分组。对于领带(同一类型的多个分组具有相同的最大计数)，将返回所有顶级分组。

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

编辑：为了返回每种类型的单个结果，即使是在领带的情况下，我们也可以在query2过滤器中添加另一个条件，这样，如果两个组具有相同的Type和相同的Count，那么就会选择具有较大Value (原名为Magnitude)的组。如果您希望选择一个Value较小的>，只需将最后一个>替换为一个<即可。

这种方法将使您的查询结果具有确定性(而不是任意地依赖于，例如，在原始列表中首先发生的分组)。

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