Accessing base class function from secondarily derived functions

Question

I seriously hope my title is clear enough. If it's not I'm happy to have better suggestions.

The situation is thus (variable types are just examples):

    public abstract class A
    {
      public virtual string X(string arg)
      {
        return "blarg";
      }
    }

    public class CommonProperties : A
    {
      public string foof { get; set;} = "widget";
      public string yay { get; set; }

      public override string X(string arg)
      {
        return base.X(arg);
      }
    }

    public class B : CommonProperties
    {
      public string UniqueProperty1 { get; set; }

      public override string X(string arg)
      {
        return base.X(arg);
      }
    }

    public class C : CommonProperties
    {
      public string UniqueProperty2 { get; set; }

      public override string X(string arg)
      {
        return base.X(arg);
      }
    }

class D : A
{
  public override string X(string arg)
      {
        return base.X(arg);
      }
    }
}

I'm generalizing my problem. This is not my actual code.

The problem is that C# does not allow multiple inheritance for abstract classes, interfaces don't allow for default code (yet) nor do they allow for default initializers.

I'd like CommonProperties to be derived from the abstract class and the classes derived from it (classes B and C) to be able to directly access the original abstract class's implementation of the X function rather than the overriding CommonProperties implementation of it. I've tried doing base.base.X(arg) but that didn't work. The next best way would be to have classes B and C derived from both class A and class CommonProperties but C# doesn't allow this. Making class A an interface won't work because I have a large number of classes derived from it and that would mean I'd have to copy the needed code into every. single. one. I can't make CommonProperties an interface because of that restriction on default values. I could move the common properties into their derived classes but that defeats code reuse (I may need to add additional properties over time and that would mean updating would be slower and more prone to error, etc.)

I can't wait until C# 8.0 (theoretically) having a default implementation of functions. If I can get B and C to directly access the hidden A.X() function that is hidden by the CommonProperties.X() function that would be a good workaround. I suspect that latter solution is possible with reflection (in fact in my project the A class is doing just that so the topic isn't difficult for me), but I'd like to know if there was a more direct method.

Edit: Adding one more class to clarify the issue better. I forgot that CommonProperties was supposed to inherit from A and also show that other classes directly inherit from A.

Answer 1

You need to add a non virtual method to class A that calls the A.X implementation. The method name includes the class name, I used double underscore to separate method name and class name.

public abstract class A
{
  public virtual string X(string arg)
  {
    return "blarg";
  }
  public string X__A(string arg)
  {
    return X(arg);
  }
}

public class CommonProperties : A
{
  public string foof { get; set;} = "widget";
  public string yay { get; set; }

  public override string X(string arg)
  {
    return "comarg";
  }
}

public class B : CommonProperties
{
  public string UniqueProperty1 { get; set; }

  public override string X(string arg)
  {
    return X__A(arg);
  }
}