Call base class member functions from subclass members

public class A
{
    ...
    public virtual void PrintMe() { /* do A */ }
}

public class B : A
{
    ...
    public override void PrintMe() { /* do B *开发者_运维技巧/ }
}

public class C : B
{
    ...
    public override void PrintMe() { /* do C */ }

    private void Fun()
    {
        // call C::PrintMe - part one
        PrintMe();

        // call B::PrintMe - part two
        base.PrintMe();

        // call A::PrintMe - part three
        ???
    }
}

1. Is the code of part two correct?

2. How to call A::PrintMe inside C::Fun?

---

Your question 1 will work as expected, it will do B.PrintMe()

Your question 2 is not quite so simple. There is no implicit or explicit way to execute A.PrintMe().

The only way I can think to achieve your goal is with the addition of a protected method on A which can be called from C.

public class A
{
    protected void BasePrintMe() { Console.WriteLine("A"); }
    public virtual void PrintMe() { BasePrintMe(); }
}

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

public class C : B
{
    public override void PrintMe() { Console.WriteLine("C"); }

    public void FunA()
    {
        // call C::PrintMe - part one
        PrintMe();

        // call B::PrintMe - part two
        base.PrintMe();

        // call A
        this.BasePrintMe();

    }

}

output:

C
B
A

---

If you want this desired functionality, you can call base.PrintMe() in your B class.

public class B : A
{
    public override void PrintMe()
    { 
     /* do B */
     base.PrintMe();
    }
}

Otherwise, you can't call the implementation from class A without resorting to something hackish.

---

You could add a method to each class that would do a base.PrintMe(). In A, this method would do nothing as it has no base class.

   public class A
   {
      public virtual void PrintMe()
      {
         Debug.WriteLine( "PrintMe: A" );
      }

      public virtual void PrintMyBase()
      {
      }
   }

   public class B : A
   {
      public override void PrintMe()
      {
         Debug.WriteLine( "PrintMe: B" );
      }

      public override void PrintMyBase()
      {
         base.PrintMe();
      }
   }

   public class C : B
   {
      public override void PrintMe()
      {
         Debug.WriteLine( "PrintMe: C" );
      }

      public override void PrintMyBase()
      {
         base.PrintMe();
      }

      private void Fun()
      {
         // call C::PrintMe - part one
         PrintMe();

         // call B::PrintMe - part two
         PrintMyBase();

         // call A::PrintMe - part three
         base.PrintMyBase();
      }
   }

The befit here is that no class has to know anything more than it's base class and we can control what's exposed down the inheritance chain.

Hope this helps

---

There's no language-supported way of doing this, which is a handy hint to suggest that you shouldn't do it.

If you find yourself needing this in real-world code then you should really try to re-think your design.

Anyway, to answer the question, you can do this using reflection and some custom IL-generation, like so:

private void Fun()
{
    // call C::PrintMe - part one
    PrintMe();

    // call B::PrintMe - part two
    base.PrintMe();

    // call A::PrintMe - part three
    MethodInfo mi = this.GetType().GetMethod("PrintMe").GetBaseDefinition();

    var dm = new DynamicMethod("dm", null, new[] { typeof(object) }, this.GetType());

    ILGenerator il = dm.GetILGenerator();
    il.Emit(OpCodes.Ldarg_0);
    il.Emit(OpCodes.Call, mi);    // use call rather than callvirt
    il.Emit(OpCodes.Ret);

    var action = (Action<object>)dm.CreateDelegate(typeof(Action<object>));
    action(this);
}