对包含字典的对象列表进行排序

Question

这是我的对象：

public class A
{
public string Name { get; set; }    
public Dictionary<int, List<int>> Years { get; set; }
}

字典包含年份列表和月份列表。我希望先按年然后按月对 A 列表 进行排序。

每个 A 上的字典样本：

{2015,new List(){3,4,5,6}}
{2016,new List(){2,8,9,10}}

如果我有多年，那么它可以排序如下： 2015 然后 2015， 2016 然后 2016

我未能实现 IComparable 或使用任何现有的扩展方法，如 OrderBy 或 Sort。谢谢！

Answer 1

我将 IComparable 添加到您的 A 类（当然您可以提取并作为委托传递......）

fiddlerlink

注意： 为简单起见，我假设列表已排序。否则在您的场景中的适当位置添加您的排序:)

基本上返回第一个不等于年或月的比较。 您可以通过 MyListOfAs.Sort() 调用它；

public class A:IComparable<A>
{
    public string Name { get; set; }
    public Dictionary<int, List<int>> Years { get; set; }

    private int complists(List<int> a, List<int> b)
    {
        var iret = (from i in Enumerable.Range(0, Math.Min(a.Count, b.Count))
                     where a[i].CompareTo(b[i]) != 0
                     select a[i] > b[i] ? 1 : -1).FirstOrDefault();

        return iret;
    }
    public int CompareTo(A other)
    {
        var mykeys = this.Years.Keys.ToList();
        var otherkeys = other.Years.Keys.ToList();

        var iret = (from i in Enumerable.Range(0, Math.Min(mykeys.Count, otherkeys.Count))
                     let yearDiff = mykeys[i].CompareTo(otherkeys[i])
                     let monthDiff = complists(this.Years[mykeys[0]], other.Years[otherkeys[0]])
                     where yearDiff != 0 || monthDiff != 0
                     select yearDiff != 0 ? yearDiff : monthDiff).FirstOrDefault();

        return iret != 0 ? iret : mykeys.Count > otherkeys.Count ? 1 : mykeys.Count < otherkeys.Count ? -1 : 0;
    }    }

Answer 2

我认为应该这样做：listOfA.OrderBy(a => a.Years.Min(y => y.Key + y.Value.Min() / 13d))

例如，如果字典中最小的年份和月份是 2000 年 1 月，则其值为 2000 + 1/13 = 2000.0769

那么剩下的就是从每个字典中选择最小值，然后按那个值排序。

注意 13 的值也可以是 20，如果您出于某种原因想要更好的数字，但 12/x 的最大部分必须小于 1 才能适当地给予年份更多的重要性，所以x必须大于12。这假设月份的范围是1到12（含）。

---

示例 I/O：

var listOfA = new List<A>
              {
                  new A
                  {
                      Name = "a1",
                      Years = new Dictionary<int, List<int>>
                              {
                                  {2015, new List<int> {3, 4, 5, 6}},
                                  {2016, new List<int> {2, 8, 9, 10}}
                              }
                  },
                  new A
                  {
                      Name = "a2",
                      Years = new Dictionary<int, List<int>>
                              {
                                  {2013, new List<int> {3, 4, 5, 6}},
                                  {2014, new List<int> {2, 8, 9, 10}}
                              }
                  },
                  new A
                  {
                      Name = "a3",
                      Years = new Dictionary<int, List<int>>
                              {
                                  {2015, new List<int> {3, 4, 5, 6}},
                                  {2014, new List<int> {2, 8, 9, 10}}
                              }
                  },
                  new A
                  {
                      Name = "a4",
                      Years = new Dictionary<int, List<int>>
                              {
                                  {2014, new List<int> {1, 4, 5, 6}},
                                  {2017, new List<int> {2, 8, 9, 10}}
                              }
                  }
              };

// listOfA is now {a1, a2, a3, a4}
listOfA = listOfA.OrderBy(a => a.Years.Min(y => y.Key + y.Value.Min() / 13d)).ToList();
// listOfA is now {a2, a4, a3, a1}