有状态 IComparer是否存在合理的场景？

Question

我从未编写过带有默认构造函数的有状态 IComparer。 我在 Reflector 中检查过的所有标准库实现也是无状态的。 因此，我想假设我可以像这样自由地缓存 IComparer：

PriorityQueue<TPriority, TComparer> where TComparer : IComparer<TPriority>, new()
{
    private static TComparer _comparer = new TComparer();

    public PriorityQueue() {...}
    ...
}

而不是

PriorityQueue<TPriority>
{
    private IComparer<TPriority> _comparer;

    public PriorityQueue(IComparer<TPriority> comparer) { 
        _comparer = comparer;
        ...
    }

    ...
}

所以这里的问题是：您曾经写过/见过 IComparer< /code> 这会崩溃吗？ 如果是，有多常见？

编辑：在这种情况下，我真的不希望第二个版本的开销是因为数据结构是持久的。 它被实现为一棵树，其中节点没有父/根引用。 因此，它不会是每个队列对比较器的一个引用，而是每个节点对比较器的一个引用！ 我最初的设计只是使用 IComparable 并建议编写一个包装器结构体进行自定义比较。

Answer 1

那么，拥有静态比较器意味着您不能对不同队列进行不同的比较； 这可能是一个问题...有时人们确实需要自定义比较； 例如，如果他们不控制类型。 我的默认方法是：

PriorityQueue<TPriority>
{
    private IComparer<TPriority> _comparer;

    public PriorityQueue(IComparer<TPriority> comparer) { 
        _comparer = comparer;
        ...
    }

    public PriorityQueue() : this(Comparer<T>.Default) {}
}

重新状态比较器； 是的，我已经写了几个 - 特别是用于编写 LINQ 风格的投影比较器...例如，类似：

public static class ProjectionComparer<TSource>
{
    public static IComparer<TSource> CompareBy<TValue>(
        Func<TSource, TValue> selector)
    {
        return CompareBy<TValue>(selector, Comparer<TValue>.Default);
    }
    public static IComparer<TSource> CompareBy<TValue>(
        Func<TSource, TValue> selector,
        IComparer<TValue> comparer)
    {
        return new ProjectionComparerItem<TValue>(
            selector, Comparer<TValue>.Default);
    }
    class ProjectionComparerItem<TValue> : IComparer<TSource>
    {
        private readonly IComparer<TValue> comparer;
        private readonly Func<TSource, TValue> selector;
        public ProjectionComparerItem(
            Func<TSource, TValue> selector,
            IComparer<TValue> comparer)
        {
            this.selector = selector;
            this.comparer = comparer;
        }
        public int Compare(TSource x, TSource y)
        {
            // TODO: some null stuff...
            return comparer.Compare(selector(x), selector(y));
        }
    }
}

允许：

IComparer<Customer> comparer = ProjectionComparer<Customer>
          .CompareBy(cust => cust.Name);

实例“按名称排序”比较。

Answer 2

是的，我有，但我认为这相当罕见。

在极少数情况下，您希望实现依赖于其他数据的比较。 例如，我们有一些空间例程，我们在其中提供一个轴，作为 IComparer 的一部分用于比较。

话虽这么说，只需使用单独的比较器类就可以很容易地解决这个问题，并且从很多方面来说这可能是更好的设计。 不过，您对确实需要存在的 IComparer 实现施加了限制，因此我会记录您的理由。

我个人的偏好是使 IComparer 非静态，并提供两个构造函数 - 一个采用外部实例，另一个创建默认比较器。 每个队列都有一个比较器的额外开销，但这非常小（如果没有状态，则接近 0，因为它只是对“空”对象的单个对象引用）。

Answer 3

另一种可能的方法：

private class PriorityQueueImpl<TPriority, TComparer> where TComparer : IComparer<TPriority> {
    // all methods accept a TComparer
    // generic in TComparer to avoid boxing for struct TComparers and permit inlining for sealed TComparers
}

public struct PriorityQueue<TPriority, TComparer> where TComparer : IComparer<TPriority> {
    private readonly PriorityQueueImpl<TPriority, TComparer> _impl;
    private readonly TComparer _comparer;

    // methods delegate to _impl
}

至少在某些情况下我可能会采用它。