针对通用接口还是作为通用约束创建扩展方法？

Question

我不确定这两个签名是否有任何实际区别：

public static class MyCustomExtensions
{
    public static bool IsFoo(this IComparable<T> value, T other)
        where T : IComparable<T>
    {
        // ...
    }

    public static bool IsFoo(this T value, T other)
        where T : IComparable<T>
    {
        // ...
    }
}

---

我认为这些功能实际上几乎相同，但是我不太确定...我在这里俯瞰什么？

Answer 1

就在这里。

第一个签名将匹配可以与T比较的任何类型，而不仅仅是T值。 因此，第一个签名可以使用任何实现IComparable<int>类型，而不仅仅是int 。

例：

void Main()
{
    10.IsFoo(20).Dump();
    new Dummy().IsFoo(20).Dump();

    IComparable<int> x = 10;
    x.IsFoo(20).Dump();

    IComparable<int> y = new Dummy();
    y.IsFoo(20).Dump();
}

public class Dummy : IComparable<int>
{
    public int CompareTo(int other)
    {
        return 0;
    }
}

public static class Extensions
{
    public static bool IsFoo<T>(this IComparable<T> value, T other)
        where T : IComparable<T>
    {
        Debug.WriteLine("1");
        return false;
    }

    public static bool IsFoo<T>(this T value, T other)
        where T : IComparable<T>
    {
        Debug.WriteLine("2");
        return false;
    }
}

将输出：

2
False
1
False
1
False
1
False

我用LINQPad进行了测试。

Answer 2

如果我们稍微重写一下以使用IList而不是IComparable ，那不是同一问题吗？

在那种情况下，很明显IsFoo1与IsFoo2完全不同。
因为IsFoo1接受本质上为IList<IList<T>>第一个参数
而IsFoo2接受IList<T>第一个参数

public static class MyCustomExtensions
{
    public static bool IsFoo1(IList<T> value, T other)
        where T : IList<T>
    {
        // ...
    }

    public static bool IsFoo2(T value, T other)
        where T : IList<T>
    {
        // ...
    }
}

所以不，它们根本不一样。

Answer 3

它们并不相同。 在第一个中，您将IComparable<T>传递给第一个，而不是第二个，因此您的实际类型将是<IComparable<IComparable<T>>和IComparable<T> 。

根据Lee的反馈进行编辑：以下内容看起来相同，但是尽管两者都需要值和其他内容才能实现IComparable，但第二个要求它们也可以分配给T。

public static bool IsFoo<T>(IComparable<T> value, IComparable<T> other)
{
    // ...
}

public static bool IsFoo<T>(T value, T other)
    where T : IComparable<T>
{
    // ...
}

Answer 4

区别非常明显。 注意，您必须在方法（泛型方法）或包含类（泛型类，扩展方法无法使用）中定义T 下面我将两种方法称为1和2：

public static bool IsFoo1<T>(this IComparable<T> value, T other)
    where T : IComparable<T>
{
    return true;
}

public static bool IsFoo2<T>(this T value, T other)
    where T : IComparable<T>
{
    return true;
}

根据T是值类型还是引用类型而有所不同。 您可以通过where T : struct, IComparable<T>或where T : class, IComparable<T>约束where T : struct, IComparable<T>进行限制。

通常具有任何类型T ：某些疯狂的类型X可能会被声明为IComparable<Y> ，其中Y与X不同（且不相关）。

使用值类型：

使用IFoo1 ，第一个参数value将被装箱，而IFoo2 value将不被装箱。 值类型是密封的，并且对数不适用于值类型，因此在这种情况下，这是最重要的区别。

使用参考类型：

对于引用类型T ，装箱不是问题。 但请注意， IComparable<>在其类型参数中是反变的（“ in ”）。 如果某些非密封类实现IComparable<>则这一点很重要。 我使用了这两类：

class C : IComparable<C>
{
    public int CompareTo(C other)
    {
        return 0;
    }
}
class D : C
{
}

有了它们，就可以进行以下调用，其中一些调用是由于继承和/或相反的原因：

        // IsFoo1

        new C().IsFoo1<C>(new C());
        new C().IsFoo1<C>(new D());
        new D().IsFoo1<C>(new C());
        new D().IsFoo1<C>(new D());

        new C().IsFoo1<D>(new D());
        new D().IsFoo1<D>(new D());

        // IsFoo2

        new C().IsFoo2<C>(new C());
        new C().IsFoo2<C>(new D());
        new D().IsFoo2<C>(new C());
        new D().IsFoo2<C>(new D());

        //new C().IsFoo2<D>(new D()); // ILLEGAL
        new D().IsFoo2<D>(new D());

当然，在许多情况下，通用参数<C>可以省略，因为可以推断出该参数，但为清楚起见，在此将其包括在内。