方法重载和多态性

Question

class Program
    {
        static void Main(string[] args)
        {
            List<A> myList = new List<A> {new A(), new B(), new C()};

            foreach (var a in myList)
            {
                Render(a);
            }

            Console.ReadKey();
        }

        private static void Render(A o)
        {
            Console.Write("A");
        }

        private static void Render(B b)
        {
            Console.Write("B");
        }

        private static void Render(C c)
        {
            Console.Write("C");
        }
    }

    class A
    {

    }

    class B : A
    {

    }

    class C : A
    {

    }

输出为： AAA

是否可以以某种方式使用方法重载，以便输出为： ABC？

Answer 1

如果您使用的是 C# 4，则可以使用动态类型：

foreach (dynamic a in myList)
{
    Render(a);
}

在静态类型中，重载决策在编译时执行，而不是在执行时执行。

对于在决策时选择的实现，您要么必须使用覆盖而不是重载，要么使用上面的动态类型。

Answer 2

以下应该可以解决问题，我们可以在使用该类型中的类型时控制行为：

class A
{
    public virtual void Render()
    {
        Console.WriteLine("A");
    }
}

class B : A
{
    public override void Render()
    {
        Console.WriteLine("B");
    }
}

class C : A
{
    public override void Render()
    {
        Console.WriteLine("C");
    }
}

static void Main(string[] args)
{
    var myList = new List<A> { new A(), new B(), new C() };
    foreach (var a in myList)
    {
        a.Render();
    }
    Console.ReadKey();
}

如果您希望类型的定义行为添加到其父级的行为中，则在之后调用基类中实现的方法执行你自己的逻辑，例如：

class B : A
{
    public override void Render()
    {
        Console.WriteLine("B");
        base.Render();
    }
}

Answer 3

实现此目的的另一种方法是使用访问者模式：它允许您实现类似的目标 使用双向方法调用系统的多态性：

interface IRenderable
{
    AcceptForRender(Program renderer);
}

class Program
{
    static void Main(string[] args)
    {
        var p = new Program();
        var myList = new List<IRenderable> {new A(), new B(), new C()};

        foreach (var a in myList)
        {
            a.AcceptForRender(p);
        }

        Console.ReadKey();
    }

    public void Render(A o)
    {
        Console.Write("A");
    }

    public void Render(B b)
    {
        Console.Write("B");
    }

    public void Render(C c)
    {
        Console.Write("C");
    }
}

class A : IRenderable
{
    public void AcceptForRender(Program renderer)
    {
        renderer.Render(this);
    }
}

class B : IRenderable
{
    public void AcceptForRender(Program renderer)
    {
        renderer.Render(this);
    }
}

class C : IRenderable
{
    public void AcceptForRender(Program renderer)
    {
        renderer.Render(this);
    }
}

这种方法的优点是可以有效地实现多态性（每种类型通过传递强类型的 this 内部渲染），同时保留不属于您的类型本身的逻辑（例如，视觉渲染逻辑）。

Answer 4

使 ABC 派生自基（抽象）类，在该类中定义方法 Render 并在每个 ABC 中正确重写。不要先调用 Render(a)，然后再调用 a.Render()，这才是多态性的工作方式。