C# Virtual 和 Override 的内部工作原理

Question

C# 虚拟和重写机制如何在内部工作的话题已经在程序员中讨论得死去活来了……但是在 google 上半小时后，我找不到以下问题的答案（见下文）：

使用简单的代码：

公共类基类 
  { 
    公共虚拟 SayNo() { 返回“NO!!!”;   } 
  } 

  公共类SecondClass：BaseClass 
  { 
    公共覆盖 SayNo() { 返回“否”;   } 
  } 

  公开课 三等： 二等 
  { 
    公共覆盖 SayNo() { 返回“不...”;   } 
  } 

  班级计划 
  { 
    静态无效Main() 
    { 
       ThirdClass ThirdClass = new ThirdClass(); 
       字符串 a =thirdclass.SayNo();   // 这将返回“否...” 

       // 问题：  
       // 有没有办法不使用“new”关键字和/或“hide” 
       // mechansim（即不修改上面的3个类），我们能以某种方式返回吗 
       // 来自 SecondClass 甚至 BaseClass 的字符串仅使用  
       // 变量“第三”？ 

       // 我知道下面的几行不会让我说“不！！！” 
       基类 bc = (基类)第三类; 
       字符串 b = bc.SayNo();   // 这给了我“不...”，但是我如何得到“不！！！”？ 
    } 
  } 
  

我认为我无法仅使用最派生的实例来访问基类或中间派生类的方法（不修改 3 个类的方法签名）。 但我想确认并巩固我的理解......

谢谢。

Answer 1

C# 无法做到这一点，但在 IL 中使用 call 而不是 callvirt 实际上可以做到这一点。 因此，您可以使用 Reflection.Emit 来解决 C# 的限制 与 DynamicMethod< 结合使用/代码>。

这是一个非常简单的示例来说明其工作原理。 如果您确实打算使用它，请将其包装在一个不错的函数中，努力使其能够与不同的委托类型一起使用。

delegate string SayNoDelegate(BaseClass instance);

static void Main() {
    BaseClass target = new SecondClass();

    var method_args = new Type[] { typeof(BaseClass) };
    var pull = new DynamicMethod("pull", typeof(string), method_args);
    var method = typeof(BaseClass).GetMethod("SayNo", new Type[] {});
    var ilgen = pull.GetILGenerator();
    ilgen.Emit(OpCodes.Ldarg_0);
    ilgen.EmitCall(OpCodes.Call, method, null);
    ilgen.Emit(OpCodes.Ret);

    var call = (SayNoDelegate)pull.CreateDelegate(typeof(SayNoDelegate));
    Console.WriteLine("callvirt, in C#: {0}", target.SayNo());
    Console.WriteLine("call, in IL: {0}", call(target));
}

印刷：

callvirt, in C#: No.
call, in IL: NO!!!

Answer 2

如果不修改你的样本并折扣反思，没有办法。 虚拟系统的目的是强制调用派生类，无论如何，CLR 都擅长它的工作。

不过，有几种方法可以解决这个问题。

选项 1：您可以将以下方法添加到 ThirdClass

public void SayNoBase() {
  base.SayNo();
}

这将强制调用 SecondClass.SayNo

选项 2：这里的主要问题是您想要非虚拟地调用虚拟方法。 C# 仅提供一种通过 base 修饰符实现此目的的方法。 这使得不可能以非虚拟方式调用您自己的类中的方法。 您可以通过将其分解为第二种方法和代理来解决此问题。

public overrides void SayNo() {
  SayNoHelper();
}

public void SayNoHelper() {
  Console.WriteLine("No");
}

Answer 3

当然...

   BaseClass bc = new BaseClass();
   string b = bc.SayNo(); 

“虚拟”意味着将执行的实现是基于底层对象的实际类型，而不是它所填充的变量的类型...所以如果实际的object 是 ThirdClass，这就是您将获得的实现，无论您将其转换为什么。 如果您想要上面描述的行为，请不要使方法虚拟......

如果您想知道“有什么意义？” 这是为了“多态性”； 这样您就可以将集合或方法参数声明为某种基类型，并包含/传递派生类型的混合，但在代码中，即使每个对象都分配给声明为基类型，对于每一个，为任何虚拟方法调用执行的实际实现将是在类定义中为每个对象的实际类型定义的实现...

Answer 4

在 C# 中使用 base 仅适用于直接基数。 您无法访问基地成员。

看来其他人抢先一步，给出了在伊利诺伊州可以做到的答案。

但是，我认为我生成代码的方式有一些优点，所以无论如何我都会发布它。

我所做的不同之处是使用表达式树，它使您能够使用 C# 编译器进行重载解析和泛型参数替换。

这些东西很复杂，如果你能控制的话，你不想自己复制它。
在您的情况下，代码将像这样工作：

var del = 
    CreateNonVirtualCall<Program, BaseClass, Action<ThirdClass>>
    (
        x=>x.SayNo()
    );

您可能希望将委托存储在只读静态字段中，这样您只需编译一次。

您需要指定 3 个通用参数：

1. 所有者类型 - 如果您不使用“CreateNonVirtualCall”，这是您将调用代码的类。

2. 基类 - 这是您要从其进行非虚拟调用的类

3. 委托类型进行非虚拟调用的类。 这应该表示使用“this”参数的额外参数调用的方法的签名。 可以消除这个问题，但需要在代码生成方法中进行更多工作。

该方法采用单个参数，即表示调用的 lambda。 它必须是一个电话，而且只是一个电话。 如果你想扩展代码生成，你可以支持更复杂的东西。

为了简单起见，lambda 主体仅限于能够访问 lambda 参数，并且只能将它们直接传递给函数。 如果您扩展方法主体中的代码生成以支持所有表达式类型，则可以删除此限制。 但这需要一些工作。 您可以对返回的委托执行任何您想要的操作，因此限制并不是太大。

需要注意的是，这段代码并不完美。 它可以使用更多的验证，并且由于表达式树的限制，它不适用于“ref”或“out”参数。

我确实在示例案例中使用 void 方法、返回值的方法和泛型方法对其进行了测试，并且它有效。 不过，我确信您会发现一些不起作用的边缘情况。

无论如何，这是 IL Gen 代码：

public static TDelegate CreateNonVirtCall<TOwner, TBase, TDelegate>(Expression<TDelegate> call) where TDelegate : class
{
    if (! typeof(Delegate).IsAssignableFrom(typeof(TDelegate)))
    {
        throw new InvalidOperationException("TDelegate must be a delegate type.");
    }

    var body = call.Body as MethodCallExpression;

    if (body.NodeType != ExpressionType.Call || body == null)
    {
        throw new ArgumentException("Expected a call expression", "call");
    }

    foreach (var arg in body.Arguments)
    {
        if (arg.NodeType != ExpressionType.Parameter)
        {
            //to support non lambda parameter arguments, you need to add support for compiling all expression types.
            throw new ArgumentException("Expected a constant or parameter argument", "call");
        }
    }

    if (body.Object != null && body.Object.NodeType != ExpressionType.Parameter)
    {
        //to support a non constant base, you have to implement support for compiling all expression types.
        throw new ArgumentException("Expected a constant base expression", "call");
    }

    var paramMap = new Dictionary<string, int>();
    int index = 0;

    foreach (var item in call.Parameters)
    {
        paramMap.Add(item.Name, index++);
    }

    Type[] parameterTypes;


    parameterTypes = call.Parameters.Select(p => p.Type).ToArray();

    var m = 
        new DynamicMethod
        (
            "$something_unique", 
            body.Type, 
            parameterTypes,
            typeof(TOwner)
        );

    var builder = m.GetILGenerator();
    var callTarget = body.Method;

    if (body.Object != null)
    {
        var paramIndex = paramMap[((ParameterExpression)body.Object).Name];
        builder.Emit(OpCodes.Ldarg, paramIndex);
    }

    foreach (var item in body.Arguments)
    {
        var param = (ParameterExpression)item;

        builder.Emit(OpCodes.Ldarg, paramMap[param.Name]);
    }

    builder.EmitCall(OpCodes.Call, FindBaseMethod(typeof(TBase), callTarget), null);

    if (body.Type != typeof(void))
    {
        builder.Emit(OpCodes.Ret);
    }

    var obj = (object) m.CreateDelegate(typeof (TDelegate));
    return obj as TDelegate;
}

Answer 5

您无法访问覆盖的基本方法。 无论您如何转换对象，始终使用实例中的最后一个覆盖。

Answer 6

如果它支持一个字段，您可以使用反射拉出该字段。

即使您使用 typeof(BaseClass) 的反射来获取 methodinfo，您仍然最终会执行被重写的方法