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

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

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);
}

---

代码与问题不匹配。首先，

对象

不是

int

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

对象

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

List

也不是

List

的父级<代码>列表创建一个与

列表

没有继承关系的新类型

---

实际证明这一问题的一个例子是：

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

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

测试（a）

代码与问题不匹配更适合。首先，

对象

不是

int

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

对象

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

List

也不是

List

的父级<代码>列表创建一个与

列表

没有继承关系的新类型

---

实际证明这一问题的一个例子是：

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

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

测试（a）

更适合，因为泛型方法创建了一个具有精确类型的新方法，因此它比具有父类型的方法更匹配为什么它会命中

列表

<代码>列表和

列表

不兼容。尝试

List a=newlist（）int

和

object

是一个糟糕的例子<代码>对象不是

int

的父类型。即使它是，

列表

不是

列表

的父类型，它也是一个不同类型的整体。一个实际演示问题的示例将是两个接受类型a和B的方法，其中B继承自a:

测试（T通用）

和

测试（a）

。即使这样，也会选择泛型方法，因为它与类型完全匹配。感谢各位，为误导性代码道歉-我修改了它以匹配问题，因为泛型方法创建了一个具有精确类型的新方法，因此它比具有父类型的方法更匹配为什么它会命中

列表

<代码>列表和

列表

不兼容。尝试

List a=newlist（）int

和

object

是一个糟糕的例子<代码>对象不是

int

的父类型。即使它是，

列表

不是

列表

的父类型，它也是一个不同类型的整体。一个实际演示问题的示例将是两个接受类型a和B的方法，其中B继承自a:

测试（T通用）

和

测试（a）

。即使这样，也会选择泛型方法，因为它与类型完全匹配。感谢各位，为误导性代码道歉-我修改了它以匹配问题