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

假设我创建了一个泛型方法，并实现了一些类型，如下面的代码所示。 我也有两个对象，一个Foo and a Bar, where Bar继承自Foo.

然后我实现通用方法Foo.

如果我用以下方式调用该方法Bar，为什么它没有击中Foo方法的重载？

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

提出我的问题是因为我想处理Bet and Bar同样的方式，所以方法的主体将是相同的。尽管如此，我不知道如何在不复制代码或创建另一种分派到正确方法的方法的情况下执行此操作。

public class Foo 
{
}

public class Bar : Foo
{
}

public class Bet : Foo
{
}

public static void Test(Foo foos)
{
    Console.WriteLine("You hit Test(Foo)");
}

public static void Test<T>(T generic)
{
    Console.WriteLine("You hit Test<T>");
}

void Main()
{
    Foo foo = new Foo();
    Bar bar = new Bar();
    Bet bet = new Bet();
    
    Test(foo);  // Prints "You hit Test(Foo)", as expected 
    Test(bar);  // Prints "You hit Test<T>", I expexted "You hit Test(Foo)"
    Test(bet);  // Prints "You hit Test<T>", I expexted "You hit Test(Foo)"
}

代码与问题不符。首先，object不是 的父级int。值类型必须装箱才能转换为object。即使使用引用类型，假设 A 是 B 的父级，List<A> is 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)