LINQ 排序。如何确定多个字段的相等性

Question

我正在使用 LINQ 对多个字段进行排序。但是如何确定列表中的两个或多个条目是否相等？也就是说，所有字段都是相等的，排序顺序不会因为相等而改变。

public List<SfpDb.ResultatViewRang> sortResMest(List<SfpDb.ResultatViewRang> resultat)
{
    return resultat
                    .OrderBy(p => p.statdsq)
                    .ThenBy(p => p.statdns)
                    .ThenBy(p => p.statdnf)
                    .ThenByDescending(p => p.totsum)
                    .ThenByDescending(p => p.totOmskyting)
                    .ThenByDescending(p => p.totinnertreff)
                    .ThenByDescending(p => p.sumr10)
                    .ThenByDescending(p => p.sumr9)
                    .ThenByDescending(p => p.sumr8)
                    .ThenByDescending(p => p.sumr7)
                    .ThenByDescending(p => p.sumr6)
                    .ThenByDescending(p => p.sumr5)
                    .ThenByDescending(p => p.sumr4)
                    .ThenByDescending(p => p.sumr3)
                    .ThenByDescending(p => p.sumr2)
                    .ThenByDescending(p => p.sumr1)
                    .ThenBy(p => p.perTreffRangStr)
                    .ThenBy(p => p.enavn, strCompareNo)
                    .ThenBy(p => p.fnavn, strCompareNo)
                    .ToList<SfpDb.ResultatViewRang>();
}

内容来自保存比赛结果的数据库，并根据比赛规则进行排序。排序用于确定竞争对手获得的位置。

根据规则，如果一个或多个竞争对手在比赛中具有相同的值（p.totsum，p.totOmskyting，......），他们将获得相同的位置。例如：
1. 吉姆·哈里斯，580、25、32，......
2. 汤姆·詹森，560、20、30，......
3. 让·约翰逊，523、23、26 岁，......
3. 罗伊·比曼，523、23、26，......
5. 道格·威尔逊，520、23、26，......

排序后的问题是，在这个例子中，我不确定如何识别位置 3 的两个人。

一般来说，具有以下类：

public class MigrObject
{
    public int first { get; set; }
    public int second { get; set; }
    public int third { get; set; }
}

它将使用排序

.OrderByDescending(p => p.first)
.ThenByDescending(p => p.second)
.ThenByDescending(p => p.third)

有以下记录：（第一、第二、第三）
580、25、32
560、30、30
523、23、26
523、23、26
523、23、26
520、23、26
518、40、30
518、40、30
430、14、16

您如何识别相等的记录？处理完记录后，应该有以下仓位/顺序：
1：580、25、32
2：560、30、30
3：523、23、26
3：523、23、26
3：523、23、26
6：520、23、26
7：518、40、30
7：518、40、30
9：430、14、16

根据国际规则，参与者将按照第一个字段（first）中的值进行排序。如果有平局，将比较第二列，所以我们按“第二”排序。如果还有平局，就会比较第三列，所以我们按“第三”排序。如果仍有平局，则运动员必须具有相同的排名，并且必须使用运动员的姓氏按拉丁字母顺序列出。

如果处理后的位置是 1,2,3,3,3,6,7 还是 1,2,3,3,3,4,5 不重要。 主要问题是在比较所有字段后知道是否有任何联系，以及涉及哪些记录。

我希望 LINQ 中有一些功能可以在所有比较字段相等时通知您。

Answer 1

请试试这个。 我已经测试过了。

public class Program
    {
        public class TestData
        {
            public int First { get; set; }
            public int Second { get; set; }
            public int Third { get; set; }
            public int Place { get; set; }
        }

        public static void Main(string[] args)
        {
            var data = new List<TestData>
            {
                new TestData {First = 580, Second = 25, Third = 32},
                new TestData {First = 560, Second = 30, Third = 30},
                new TestData {First = 523, Second = 23, Third = 26},
                new TestData {First = 523, Second = 23, Third = 26},
                new TestData {First = 523, Second = 23, Third = 26},
                new TestData {First = 520, Second = 23, Third = 26},
                new TestData {First = 518, Second = 40, Third = 30},
                new TestData {First = 518, Second = 40, Third = 30},
                new TestData {First = 430, Second = 14, Third = 16}
            };

            var sorted =
                (from d in data
                    orderby d.First descending, d.Second descending, d.Third descending 
                    group d by d.First.ToString() + d.Second + d.Third into gd
                    select gd.ToList())
                    .ToList();

            var result = new List<TestData>();
            var place = 1;
            foreach (var sd in sorted)
            {
                sd.ForEach(p => p.Place = place);
                result.AddRange(sd);
                place += sd.Count;
            }
        }
    }

Answer 2

尝试这样的事情：（为简单起见，我使用您的 MigrObject 示例）

Dictionary<MigrObject, int> orderedResult = new Dictionary<MigrObject, int>(); //reverse dictionary where int is the 'order' you want
foreach (var item in resultat) // assuming resultat is a List of MigrObject
{
    int order = 1;
    if(!orderedResult.Any(o => o.first == item.first && o.second == item.second && o.third == item.third)) // I don't use ContainsKey(item) because it may not work for custom defined classes as key
    {
        orderedResult.Add(item, order);
        count++;
    }
    else
        orderedResult.Add(item, order);
}

它可能看起来很复杂，但这里是解释：

-字典是颠倒的，因为我们可以为同一个键有多个值，但不能反过来

-从 1 开始订单，因为没有第 0 位（在您的示例中）

-检查字典是否包含每个项目的记录：如果没有，则添加它并将计数加1，如果是，则不增加计数（从而使2个重复项具有相同的顺序）

-假设resultat 列表已正确排序。

-当你有很多字段要比较时，这个方法可能会变得复杂，但是如果你有更好的比较方法，你可以修改它。

最后您可以遍历字典，每个项目的“位置/顺序”就是它的值，您可以将其添加到数组或您想要的任何数据类型。 （字典除外，因为键必须是唯一的）

Answer 3

尝试这样做：

var scores = new [] { 580, 560, 523, 523, 523, 520, 518, 518, 430, };

var results =
    scores
        .OrderByDescending(x => x) // just in case scores not in order
        .GroupBy(x => x)
        .Aggregate(
            new { Rank = 1, Results = new List<Tuple<int, int>>() },
            (a, gx) =>
            {
                a.Results.AddRange(gx.Select(x => Tuple.Create(a.Rank, x)));
                return new { Rank = a.Rank + gx.Count(), Results = a.Results };
            })
        .Results;

我得到以下结果：

您需要调整代码以适应您的输入。