在泛型方法中，为什么泛型重载优于具有父类型的实现方法？

Question

假设我创建了一个通用方法，并实现了一些类型，如下面的代码所示。 我还有两个对象，一个

Foo

和一个

Bar

，其中

Bar

继承自

Foo

.

然后我实现

Foo

的泛型方法。

如果我用

Bar

调用方法，为什么它没有命中方法的

Foo

重载？

我测试了下面的代码，这就是它返回的内容。我更感兴趣的是为什么会这样。

我的问题是因为我想以同样的方式处理

Bet

和

Bar

，所以方法的主体是一样的。虽然，如果不复制代码或创建另一种方法来分配到正确的代码，我看不出如何做到这一点。

public class Foo 
{
}

public class Bar : Foo
{
}

public class Bet : Foo
{
}

public static string Test<T>(T generic)
{
    Console.WriteLine("T - generic overload");
    return "Generic overload";
}

public static string Test(Foo foos)
{
    Console.WriteLine("Foo - Foo overload");
    return "Foo overload";
}

void Main()
{
    Bar bar = new Bar();
    Foo foo = new Foo();

    Test(bar);
    Test(foo);
}

Returns:
T - generic overload
Foo - Foo overload

Answer 1

代码与问题不符。首先，

object

不是

int

的父级。值类型必须装箱才能转换为

object

。即使对于引用类型，假设 A 是 B 的父级，

List<A>

是not

List<B>

的父级。

List<A>

创建了一个与

List<B>

没有继承关系的新类型。

实际证明问题的例子是：

class A    {    }

class B:A  {    }

static string Test<T>(T generic)
{
    Console.WriteLine("T - generic overload");
    return "Generic overload";
}

static string Test(A a)
{
    Console.WriteLine("A - A overload");
    return "A overload";
}

static string Test(object o)
{
    Console.WriteLine("object - objectoverload");
    return "object overload";
}


void Main()
{
    var b =new B() ;
    var a=new A() ;

    Test(b);
    Test(a);
}

输出将是：

T - generic overload
A - A overload

泛型重载为

B

创建了一个精确匹配，这意味着它比

Test(A)

更适合