Question

我目前正在深入阅读Jon Skeet的C＃第二版，我想到了以下问题：

在以下示例中，编译器如何在list.Sort(Comparison<T>)和list.Sort(MyComparison<T>)之间进行选择：

// MyComparison has the same signature as Comparison<in T>
public delegate int MyComparison<in T>(T x, T y);

public class MyList<T> : List<T>
{
    // Sort is like Sort(Comparison<T>) except it takes a MyComparison<T> in parameter
    public int Sort(MyComparison<T> comparison)
    {
        Console.WriteLine("Sort MyComparison<T>");
        return -1;
    }
}

MyList<Product> list = new MyList<Product>();

list.Sort((product1, product2) => product1.Name.CompareTo(product2.Name));

// Equivalent to
list.Sort(new MyComparison<Product>((product1, product2) => product1.Name.CompareTo(product2.Name)));

// But not equivalent to...
list.Sort(new Comparison<Product>((product1, product2) => product1.Name.CompareTo(product2.Name)));

提前致谢

Answer 1

它选择那个，因为它在子类中并且更喜欢那些。

例如：

public class MyList<T> : List<T>
{
    public int Sort2(MyComparison<T> comparison)
    {
    }
    public int Sort2(Comparison<T> comparison)
    {
    }
}

在这种情况下，它不再理解了：

list.Sort2((product1, product2) => product1.Name.CompareTo(product2.Name));

你得到一个“呼叫是暧昧的”错误。

Answer 2

如果重载解析遇到适用的方法，它将优先使用该方法，而不是基类中声明的任何方法。所以在这种情况下，对于前两次调用，就好像List<T>.Sort甚至不存在一样。

第三次调用不适用，因此会找到List<T>.Sort。

如果您在Sort内为MyList声明了另一次重载（但是Comparison<T>而不是MyComparison<T>）那么方法调用将是不明确的

有关详细信息，请参阅我的overload resolution article。

PS希望你喜欢这本书：）

Lambda委托解决方案

2 个答案: