Question

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

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<T>这会破坏它？如果是的话，它有多常见？

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

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<T>实现进行了限制，因此我会记录您的理由。

我个人的偏好是使IComparer<T>非静态，并提供两个构造函数 - 一个接受外部实例，另一个创建默认比较器。你有一个比较器每个队列的额外开销，但这是非常小的（如果没有状态，则接近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
}

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

对于有状态IComparer <t>？</t>是否存在合理的情况

3 个答案: