有没有办法指定范围？

Question

考虑这个代码示例：

public abstract class Parent
{
    public int val;
    public Parent()
    {
        val = 0;
    }
    public virtual void foo()
    {
        inc();
    }

    public virtual void inc()
    {
        val = val + 10;
    }
}

public class Child : Parent
{
    public override void foo()
    {
        base.foo();
    }

    public override void inc()
    {
        val++;
    }
}

static void Main(string[] args)
{
    Parent p = new Child();
    Console.WriteLine("p.val = " + p.val);  //Output: p.val = 0
    p.foo();
    Console.WriteLine("P.val = " + p.val);  //Output: p.val = 1
}

我假设父类的 inc() 没有被调用，因为 {this} 指针实际上指向子对象，因此子对象的版本inc() 将从父对象的函数 foo() 中调用。有没有办法强制父函数 foo() 始终调用父函数 inc() 就像在 C++ 中使用 :: 运算符一样？

Answer 1

不，非虚拟调用虚拟方法的唯一方法是使用 base.Foo。当然，您可以在 Parent 中编写一个非虚拟方法，并让 Parent.foo() 调用该方法以及默认方法Parent.inc() 的实现。

Answer 2

你这个问题想太多了。

• 如果您想要非虚拟调度，那么首先不要将方法设为虚拟。

• 如果您想要虚拟和非虚拟调度，那么创建两个方法，一个虚拟和一个静态

例如：

class Base
{
    protected static void NonVirtualFoo(Base b)
    {
        // Whatever
    }
    public virtual void Foo()
    {
        Base.NonVirtualFoo(this);
    }
}

class Derived : Base
{
    protected new static void NonVirtualFoo(Derived d)
    {
        // Whatever
    }
    public override void Foo()
    {
        Derived.NonVirtualFoo(this);
        Base.NonVirtualFoo(this);
    }
}

为工作使用正确的工具。如果您想要虚拟调度，则调用虚拟方法。如果您想要静态调度，则调用静态方法。不要试图对虚拟方法进行锤子攻击并使其静态分派；这违背了该工具的全部目的。

Answer 3

Child 实例将调用它自己的类型实现。

foo() 调用 base.foo() 和 base.foo() 调用 inc()，其中本例 inc() 来自 Child，因为实例是 Child 类型，并且将使用此实现。

Answer 4

嗯，实际上是可能的正如这里所说的：

这确实有效：

public abstract class Parent
{
    public int val;

    public Parent()
    {
        val = 0;
    }

    public virtual void foo()
    {
        MethodInfo method = typeof(Parent).GetMethod("inc");
        DynamicMethod dm = new DynamicMethod("BaseInc", null, new Type[] { typeof(Parent) }, typeof(Parent));
        ILGenerator gen = dm.GetILGenerator();
        gen.Emit(OpCodes.Ldarg_1);
        gen.Emit(OpCodes.Call, method);
        gen.Emit(OpCodes.Ret);

        var BaseInc = (Action<Parent>)dm.CreateDelegate(typeof(Action<Parent>));
        BaseInc(this);
    }

    public virtual void inc()
    {
        val = val + 10;
    }
}

但这只是一个概念证明< /em>：这可怕并且完全破坏了多态性。

我认为你没有正当理由写这篇文章。