Implement Multiple Inheritance in C#

Atul Sharma

5 years ago

Author
Recent Posts

An extrovert by nature, Atul has been sharing his opinions and views on various social network platforms. He always had been thinking about having his own platform and here it is. Creative and tech-savvy Atul has a good sense of humor and when he is not programming or writing blogs or traveling, you can find him cooking, Netflixing or sleeping.

Multiple Inheritance – Why is it not allowed?

Considering the above hypothetical class diagram, We want to have a class Child which inherits Parent classes ParentA and ParentB. Both classes have the same methods MethodA and MethodB.

Now, when we instantiate the Class Child then calling MethodA will confuse compiler that from which class MethodA should be called.

Implement Multiple Inheritance

But, in our real life, we can get into the situation when we need to implement multiple inheritance so let us see the workarounds to achieve this.

Approach #1

In this approach, We make a wrapper class ParentWrapper and have methods from both of the classes. This is a way to combine the classes.

Here is code implementation of the approach –

  class ParentA
    {
        public void MethodA()
        {
            Console.WriteLine("MethodA from ParentA called");
        }
        public void MethodB()
        {
            Console.WriteLine("MethodB from ParentA called");
        }
    }

    class ParentB
    {
        public void MethodA()
        {
            Console.WriteLine("MethodA from ParentB called");
        }
        public void MethodB()
        {
            Console.WriteLine("MethodB from ParentB called");
        }
    }

    class ParentWrapper
    {
        ParentA objA = new ParentA();
        ParentB objB = new ParentB();
        public void ParentWrapperAMethodA()
        {
            objA.MethodA();
        }
        public void ParentWrapperAMethodB()
        {
            objA.MethodB();
        }
        public void ParentWrapperBMethodA()
        {
            objB.MethodA();
        }
        public void ParentWrapperBMethodB()
        {
            objB.MethodB();
        }
    }

    class Child : ParentWrapper
    {

    }

This is how we can call them –

            Child objChild = new Child();
            objChild.ParentWrapperAMethodA();
            objChild.ParentWrapperBMethodB();

Approach #2

In previous Approach, we see that combining both of the classes could be a big headache and here we have second approach to implement the same –

In this approach, we have class ParentB implemented an Interface IParentB (@Line#17). We need to make sure that interface IParentB has all methods defined in ParentB class (From Line# 19-22). Now, our class Child will inherit Class ParentA and implement Interface IParentB (@Line#32). Since class Child is implementing IParentB interface so we will have to Implement all the methods of this in Child class and we can have it referencing ParentB (From Line#35-38).

Code implementation of this approach will be like this

   class ParentA
    {
        public void MethodX()
        {
            Console.WriteLine("MethodX from ParentA called");
        }
        public void MethodY()
        {
            Console.WriteLine("MethodY from ParentA called");
        }
        public void MethodZ()
        {
            Console.WriteLine("MethodZ from ParentA called");
        }
    }

    class ParentB : IParentB
    {
        public void MethodA()
        {
            Console.WriteLine("MethodA from ParentB called");
        }
      
    }

    interface IParentB
    {
        void MethodA();
      
    }

    class Child : ParentA, IParentB
    {
        ParentB objParentB = new ParentB();
        public void MethodA()
        {
            objParentB.MethodA();
        }
    }

And here we can call it

            Child objChild2 = new Child();
            objChild2.MethodX();
            objChild2.MethodA();

Output

In both of the scenario, we see this output –

When to use which approach?

Approach #1,

It will be good when the class size is small and it doesn’t have too many methods.
We are just provided classes and can NOT make modify them at all.
All constituent classes have the same method name.

Approach # 2,

This approach is best suited when at least one class could be modified.
When One class has a smaller number of methods than another class.
When methods are different in all classes.

See also Let’s be Lazy with C# Lazy 😴😴

I hope, with this, I could explain the reason for not having Multiple inheritance, if extremely needed ways to implement this and best evaluation of best approach in both of the scenario.

Source Code is available here for experiment.