为什么这个泛型在编译时没有解决？

Question

我有以下代码。我希望它打印出来：

A
B
C
DONE

而是打印

P
P
P
DONE

为什么？

更新
我不是在寻求解决方案。我想知道为什么会这样。我认为泛型是在编译时解决的。据我所知，它应该能够在编译时将这些解析为正确的方法，但显然不是，我不明白为什么。我正在寻找原因的解释，而不是解决方案。

代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication50
{
    class Parent
    {
        public string FieldName { get; set; }
        public string Id { get; set; }
    }

    class ChildA : Parent
    {
        public string FieldValue { get; set; }
    }

    class ChildB : Parent
    {
        public DateTime? Start { get; set; }
        public DateTime? End { get; set; }
    }

    class ChildC : Parent
    {
        public ICollection<string> Values { get; set; }
    }
    class Program
    {
        void Validate<T>(Parent item) where T : Parent
        {
            if (item is T)
                Validate(item as T);
        }
        void Validate(ChildA filter)
        {
            Console.WriteLine("A");
        }

        void Validate(ChildB filter)
        {
            Console.WriteLine("B");
        }

        void Validate(ChildC filter)
        {
            Console.WriteLine("C");
        }

        void Validate(Parent filter)
        {
            Console.WriteLine("P");
            // do nothing placeholder so the code will compile
        }

        ArgumentException Fail(Parent filter, string message)
        {
            return new ArgumentException(message, filter.FieldName);
        }

        void Run()
        {
            var list = new List<Parent> {
                new ChildA(), new ChildB(), new ChildC() };
            Validate<ChildA>(list[0]);
            Validate<ChildB>(list[1]);
            Validate<ChildC>(list[2]);
        }
        public static void Main()
        {
            new Program().Run();
            Console.WriteLine();
            Console.WriteLine("DONE");
            Console.ReadLine();
        }
    }
}

Answer 1

泛型是一个运行时概念。这是它们与 C++ 模板的主要区别，后者是一个编译时概念。

在方法Validate<T> 中，T 在编译时总是未知，即使调用者明确指定。 唯一 Validate<T> 知道T 是它来自Parent。

更具体地说，泛型不能用于生成代码。您正在尝试的将在 C++ 下工作，因为当 C++ 看到对 Validate<ClassA> 的调用时，它实际上会重新编译 Validate<T>，因此模板成为一种代码生成。在C#下，Validate<T>只编译一次，所以泛型不能作为一种代码生成。

在 C++ 下，对 Validate<ClassA> 的调用将在编译时实例化模板。

在 C# 下，对 Validate<ClassA> 的调用将在运行时实例化泛型方法。

Answer 2

重载解析是在编译时执行的，而不是在运行时。

通常的解决方案是在这里使用简单的虚拟调度：

class Parent
{
    public virtual  void Validate() { Console.WriteLine("P"); }
}

class ChildA : Parent
{
    public override void Validate() { Console.WriteLine("A"); }
}

class ChildB : Parent
{
    public override void Validate() { Console.WriteLine("B"); }
}

void Run()
{
    var list = new List<Parent> { new ChildA(), new ChildB() };
    list[0].Validate(); // prints "A"
    list[1].Validate(); // prints "B"
}

Answer 3

该项目将始终被验证为父类型。

泛型背后的想法是你没有特定于类型的代码。因此它的“泛型”部分。

您仅限于类的一个分支，在这种情况下是 Parent 以及从它派生的所有东西。这意味着代码应该像传入的对象是 Parent 类型一样执行。

正如 dtb 所说，访问者模式可以应用在这里。

另一个想法是简单地有一个接口，它定义了每个类必须支持的 Validate() 方法。我认为这将是一条更好的路线。

Answer 4

假设您可以使用 C# 4.0，您可以通过使用“动态”关键字来消除 C# 编译器将执行的静态重载解析。只需将您的验证功能更改为：

    void Validate<T>(Parent item) where T : Parent
    {
        dynamic dyn = item;
        if (item is T)
            Validate(dyn);
    }

输出将是：

C:\tmp>temp.exe
A
B
C

DONE

我刚刚从@juharr 的 Eric Lippert 博客链接中了解到这一点。阅读有关dynamic type on msdn 的更多信息。