根据计算的属性索引排序列表

Question

我有以下课程。

 public class Header
    {
        public long CombinedIndex { get; private set; }
        public int Key { get; set; } //Unique
        public bool IsRequired { get; set; }// True or false
        public DateTime? AvailableDate { get; set; } // null or date value
        public int Index { get; set; } // a number and can be same among other Header 

        public void CalculateCombinedIndex()
        {
            CombinedIndex = Key + (IsRequired ? 0 : 1) + Index + (AvailableDate ?? DateTime.MaxValue).Ticks;
        }
    }

我预计大约 50,000 个实例 它在一个数组中。我需要按以下顺序对它们进行排序：

• 首先基于 IsRequired
• 然后索引
• 那么可用日期（日期值接近当前日期）
• 键（主键）

将所有这些属性值和 导出一个唯一的数字，然后只对该数字进行排序。 稍后，可以将 Header 的列表转换为字典 where 键是 CombinedIndex，我已经排序的数组可以查找 字典顺序我迭代了数组。如何高效和 承诺这一切看起来？

Answer 1

只要实现IComparable，就可以使用List.Sort()。

public class Header : IComparable
{
    public long CombinedIndex { get; private set; }
    public int Key { get; set; } //Unique
    public bool IsRequired { get; set; }// True or false
    public DateTime? AvailableDate { get; set; } // null or date value
    public int Index { get; set; } // a number and can be same among other Header 

    public void CalculateCombinedIndex()
    {
        CombinedIndex = Key + (IsRequired ? 0 : 1) + Index + (AvailableDate ?? DateTime.MaxValue).Ticks;
    }

    public int CompareTo(object obj)
    {
        if (obj == null) return 1;

        Header otherHeader = obj as Header;
        if (otherHeader != null)
        {
            if (this.IsRequired && !otherHeader.IsRequired)
                return 1;
            if (!this.IsRequired && otherHeader.IsRequired)
                return -1;
            if (this.Index > otherHeader.Index)
                return 1;
            if (this.Index < otherHeader.Index)
                return -1;
            //// ....
            return 0;
        }
        else
            throw new ArgumentException("Object is not a Temperature");
    }
}

Answer 2

我会用 LINQ 来做：

var ordered = list
    .OrderByDescending(x => x.IsRequired)
    .ThenBy(x => x.Index)
    .ThenBy(x=> x.AvailableDate)
    .ThenBy(x=> x.Key);

只有在平局的情况下才会使用下一个条件。所以不需要创建一个组合索引，这使得更改顺序逻辑非常困难，而且似乎无论如何都被破坏了。

Answer 3

如果您需要根据给定类型的投影键执行比较操作，我发现拥有一个可以从Func<TSource, TKey> 委托创建IComparer<TSource> 实例的KeyComparer 类会很有帮助。这特别适用于 C# 7 中引入的新元组语法。以下是生成的语法示例：

// Create an IComparer<Header> instance based on your combined key.
var comparer = KeyComparer.Create((Header h) => (h.IsRequired, h.Index, h.AvailableDate, h.Key));

List<Header> headers = ...

// Sort the list using the combined key.
headers.Sort(comparer);

// Convert to a dictionary keyed by the combined key.
var dict = headers.ToDictionary(comparer.KeySelector);

这是该类的示例实现。 （更详细的解释见my blog post。）

public static class KeyComparer
{
    public static KeyComparer<TSource, TKey> Create<TSource, TKey>(
        Func<TSource, TKey> keySelector,
        IComparer<TKey> innerComparer = null)
    {
        return new KeyComparer<TSource, TKey>(keySelector, innerComparer);
    }
}

public class KeyComparer<TSource, TKey> : Comparer<TSource>
{
    protected internal KeyComparer(
        Func<TSource, TKey> keySelector,
        IComparer<TKey> innerComparer = null)
    {
        KeySelector = keySelector ?? throw new ArgumentNullException(nameof(keySelector));
        InnerComparer = innerComparer ?? Comparer<TKey>.Default;
    }

    public Func<TSource, TKey> KeySelector { get; }
    public IComparer<TKey> InnerComparer { get; }

    public override int Compare(TSource x, TSource y)
    {
        if (object.ReferenceEquals(x, y))
            return 0;
        if (x == null)
            return -1;
        if (y == null)
            return 1;

        TKey xKey = KeySelector(x);
        TKey yKey = KeySelector(y);
        return InnerComparer.Compare(xKey, yKey);
    }
}