从子类中调用基类的扩展方法

Question

Why in a child class, i can not call the extention method defined for the derived class by calling the base class directly ( i get a compile error that the base class does not contain a definition for the extention method). But instead, i can call the extention method without any compile errors when i call it directly from the child intance. Below is the code for my question :

using System;
using System.Reflection;

    public class Program
    {
      public static void Main()
      {
         Child child = new Child();
         child.TestMethod();
      }
    }

   // Derived class
   public class Mother
   {

   }

   // Child class
   public class Child : Mother
   {
     public Child() : base()
     {
     }

     public void TestMethod()
     {
       this.ExtentionMethod(3);// Ok: no compile errors
       base.ExtentionMethod(3);// Ko: Compilation error (line 27, col 8): 'Mother' does not contain a definition for 'ExtentionMethod'
     }
}

public static class Extender
{
   public static void ExtentionMethod(this Mother mother, int i)
   {
     Console.WriteLine($"Mother extention method {i}");
   }

}

Answer 1

When you call an extension method, the compiler looks at the type of the reference on the left and finds the most appropriate method. So when you call this.ExtentionMethod , the type of this is used to find the best method.

So in your case, the compiler will look for an extension with a Child first parameter. Since there is not one, it will then find the one with a Mother first parameter (since a Child "is-a" Mother ).

Using base does not do a cast - it is used to access members of the base class. Since extension methods are not "members", base does not do what you expect it to do.

An alternative might be to cast this to the base class instead:

((Mother)this).ExtentionMethod(3);

Although I would note that you don't have a different extension method for the derived class, so with what you posted there would be no difference between this.ExtensionMethod and ((Mother)this).ExtensionBethod . The same method (with the same input values) are going to be called.

Answer 2

This an extension to D Stanley's answer .

If you had extension methods on both Mother , and Child , like this:

public static class Extender
{
    public static void ExtentionMethod(this Mother mother, int i)
    {
        Console.WriteLine($"Mother extention method {i}");
    }

    public static void ExtentionMethod(this Child child, int i)
    {
        Console.WriteLine($"Child extention method {i}");
    }
}

Then there is a distinction between calling it from the sub-class vs the base-class.

From inside Child

this.ExtentionMethod(3);

Will call the Child version.

---

((Mother)this).ExtentionMethod(3);

Will call the Mother version.

---

public void TestMethod()
{
    this.ExtentionMethod(3);
    ((Mother)this).ExtentionMethod(3);
}

Would produce the following output with both extension methods from above:

child extention method 3
Mother extention method 3

Answer 3

The other answers offer very good explanations why you have problems, I'd like to make sure you know the fastest way out of that mess:

public void TestMethod()
{
   this.ExtentionMethod(3); 
   Extender.ExtentionMethod((Mother)this, 3);
}

If your compiler does not recognize the extension method, just remove that syntactical sugar. You can still call it just like a regular, public static method and pass the parameters just as if the this keyword for exension methods never existed. It's not either or, you can still go the old way.