为什么泛型 + 接口 + 阴影方法不能一起工作？

Question

在 C# 中，混合泛型、接口和影子方法（C# 中的 new 关键字）似乎并不像预期的那样工作（在我看来）。 标记为新（阴影）的显式方法表现为覆盖方法！

这是一个用例：

创建一个C# winforms项目，去掉生成的Form1.cs 并用此代码替换 Program.cs：

using System;
using System.Text;
using System.Windows.Forms;

namespace GenericWithShadowedMethImplInterface
{

    static class Program
    {
        [STAThread]
        static void Main()
        {
            Application.Run(new ChildForm());
        }
    }

    public interface IStepByStep_UI_Initialization
    {
        void FillControls();
        void DefineBindings();
        // etc...
    }

    public class BaseForm : Form, IStepByStep_UI_Initialization
    {
        public StringBuilder Log = new StringBuilder();

        public BaseForm()
        {
            this.InstallSmartLoading();
            Shown += (sender, args) => MessageBox.Show(Log.ToString());
        }

        public void FillControls()
        {
            Log.AppendLine("BaseObject.FillControls");
        }

        public void DefineBindings()
        {
            Log.AppendLine("BaseObject.DefineBinding");
        }
    }

    public class ChildForm : BaseForm, IStepByStep_UI_Initialization
    {
        public ChildForm()
        {
            this.InstallSmartLoading();
        }
        // Shadowing is really what i want
        public new void FillControls()
        {
            Log.AppendLine("ChildObject.FillControls");
        }

        // Shadowing is really what i want
        public new void DefineBindings()
        {
            Log.AppendLine("ChildObject.DefineBinding");
        }
    }

    public static class StepByStepInitializer
    {
        public static void InstallSmartLoading<TForm>(this TForm form)
            where TForm : Form, IStepByStep_UI_Initialization
        {
            // i Use lambda to keep knowing what form type really is (BaseForm or ChildForm)
            form.Load += (_, __) =>
            {
                // I would expect the these two lines of code here...
                // Why these calls are treated as polymorphic calls ?
                form.FillControls(); // always call ChildForm.FillControls even if typeof(TForm) == typeof(BaseForm)
                form.DefineBindings();

                // ... behaves likes this (not generic) code :
                //if (typeof(TForm) == typeof(BaseForm))
                //{
                //    (form as BaseForm).FillControls();
                //    (form as BaseForm).DefineBindings();
                //}
                //else if (typeof(TForm) == typeof(ChildForm))
                //{
                //    (form as ChildForm).FillControls();
                //    (form as ChildForm).DefineBindings();
                //}
            };
        }

    }
}

运行它...

你应该看到：

ChildObject.FillControls ChildObject.DefineBindings ChildObject.FillControls ChildObject.DefineBindings

现在，如果您在 InstallSmartLoading 中注释两行代码并取消注释其他代码行，然后再次运行该项目，您应该会看到：

BaseObject.FillControls BaseObject.DefineBindings ChildObject.FillControls ChildObject.DefineBindings

所以我的问题很简单：为什么您注释的两行代码的行为与您未注释的代码不同？在初始化 ChildForm 之前，我需要完全初始化我的 baseBaseForm。这是泛型的限制吗？ :((( 有解决办法吗

• TForm 表示真正的 Form 类型...
• 方法未标记为虚拟/覆盖，我明确使用 new 关键字
• 编译器不应该显示警告？

提前谢谢...

Answer 1

你有约束

where TForm : IStepByStep_UI_Initialization

（约束的其他部分现在不相关），那么你有一个变量（实际参数）

TForm form

你做的：

form.FillControls(); // always call ChildForm.FillControls even if typeof(TForm) == typeof(BaseForm)

（您对问题的评论）。

之所以能编译，是因为你有这个接口约束。

注意ChildForm重新实现接口IStepByStep_UI_Initialization已经被BaseForm实现了。

所以你的调用真的相当于

((IStepByStep_UI_Initialization)form).FillControls();

并且TForm 是什么变得无关紧要。重要的是实例如何实现接口。

尝试以下方法：

• 停止重新实现接口，只在BaseForm实现，或
• 将接口约束更改为基类约束where TForm : BaseForm

加深你的理解。

---

这是一个没有泛型、没有委托和事件、没有 Win Forms 的相关示例：

interface ICanTalk
{
  void Talk();
}

class Animal : ICanTalk
{
  public void Talk()
  {
    Console.WriteLine("I am animal");
  }
}
class Dog : Animal, ICanTalk // note: re-implements
{
  public new void Talk() // note: method hiding "new" is always evil
  {
    Console.WriteLine("Wroof!");
  }
}

static class Test
{
  internal static void Run()
  {
    object x = new Dog();

    ((Animal)x).Talk();   // I am animal
    ((Dog)x).Talk();      // Wroof!
    ((ICanTalk)x).Talk(); // Wroof!
  }
}

请注意，将上面的object x = ... 更改为Animal x 或Dog x 是不相关的，这意味着它不会改变调用的方法。