Multiple Inheritance in C

Question

Since multiple inheritance is bad  it makes the source more complicated  C  does not provide such a pattern directly  But sometimes it would be helpful to have this ability  For instance I m able to implement the missing multiple inheritance pattern using interfaces and three classes like that  public interface IFirst   void FirstMethod      public interface ISecond   void SecondMethod       public class First IFirst         public void FirstMethod     Console WriteLine  quot First quot          public class Second ISecond         public void SecondMethod     Console WriteLine  quot Second quot          public class FirstAndSecond  IFirst  ISecond       First first   new First        Second second   new Second        public void FirstMethod     first FirstMethod          public void SecondMethod     second SecondMethod         Every time I add a method to one of the interfaces I need to change the class FirstAndSecond as well  Is there a way to inject multiple existing classes into one new class like it is possible in C    Maybe there is a solution using some kind of code generation  Or it may look like this  imaginary c  syntax   public class FirstAndSecond  IFirst from First  ISecond from Second      So that there won t be a need to update the class FirstAndSecond when I modify one of the interfaces   EDIT Maybe it would be better to consider a practical example  You have an existing class  e g  a text based TCP client based on ITextTcpClient  which you do already use at different locations inside your project   Now you feel the need to create a component of your class to be easy accessible for windows forms developers  As far as I know you currently have two ways to do this   Write a new class that is inherited from components and implements the interface of the TextTcpClient class using an instance of the class itself as shown with FirstAndSecond   Write a new class that inherits from TextTcpClient and somehow implements IComponent  haven t actually tried this yet     In both cases you need to do work per method and not per class  Since you know that we will need all the methods of TextTcpClient and Component it would be the easiest solution to just combine those two into one class  To avoid conflicts this may be done by code generation where the result could be altered afterwards but typing this by hand is a pure pain in the ass

User · Answer

With C  8 now you practically have multiple inheritance via default implementation of interface members   interface ILogger       void Log LogLevel level  string message       void Log Exception ex    gt  Log LogLevel Error  ex ToString        New overload    class ConsoleLogger   ILogger       public void Log LogLevel level  string message                 Log Exception  gets default implementation

User · Answer

Multiple inheritance is one of those things that generally causes more problems than it solves   In C   it fits the pattern of giving you enough rope to hang yourself  but Java and C  have chosen to go the safer route of not giving you the option   The biggest problem is what to do if you inherit multiple classes that have a method with the same signature that the inheritee doesn t implement   Which class s method should it choose   Or should that not compile   There is generally another way to implement most things that doesn t rely on multiple inheritance

User · Answer

Multiple inheritance is one of those things that generally causes more problems than it solves   In C   it fits the pattern of giving you enough rope to hang yourself  but Java and C  have chosen to go the safer route of not giving you the option   The biggest problem is what to do if you inherit multiple classes that have a method with the same signature that the inheritee doesn t implement   Which class s method should it choose   Or should that not compile   There is generally another way to implement most things that doesn t rely on multiple inheritance

User · Answer

I created a C  post-compiler that enables this kind of thing   using NRoles   public interface IFirst   void FirstMethod      public interface ISecond   void SecondMethod       public class RFirst   IFirst  Role     public void FirstMethod     Console WriteLine  First         public class RSecond   ISecond  Role     public void SecondMethod     Console WriteLine  Second         public class FirstAndSecond   Does lt RFirst gt   Does lt RSecond gt        You can run the post-compiler as a Visual Studio post-build-event      C  some path nroles-v0 1 0-bin nutate exe    TargetPath     In the same assembly you use it like this   var fas   new FirstAndSecond    fas As lt RFirst gt    FirstMethod    fas As lt RSecond gt    SecondMethod      In another assembly you use it like this   var fas   new FirstAndSecond    fas FirstMethod    fas SecondMethod

User · Answer

You could have one abstract base class that implements both IFirst and ISecond  and then inherit from just that base

User · Answer

With C  8 now you practically have multiple inheritance via default implementation of interface members   interface ILogger       void Log LogLevel level  string message       void Log Exception ex    gt  Log LogLevel Error  ex ToString        New overload    class ConsoleLogger   ILogger       public void Log LogLevel level  string message                 Log Exception  gets default implementation

User · Answer

Since the question of multiple inheritance  MI  pops up from time to time  I d like to add an approach which addresses some problems with the composition pattern   I build upon the IFirst  ISecond First  Second  FirstAndSecond approach  as it was presented in the question  I reduce sample code to IFirst  since the pattern stays the same regardless of the number of interfaces   MI base classes   Lets assume  that with MI First and Second would both derive from the same base class BaseClass  using only public interface elements from BaseClass  This can be expressed  by adding a container reference to BaseClass in the First and Second implementation   class First   IFirst     private BaseClass ContainerInstance    First BaseClass container    ContainerInstance   container      public void FirstMethod     Console WriteLine  First    ContainerInstance DoStuff               Things become more complicated  when protected interface elements from BaseClass are referenced or when First and Second would be abstract classes in MI  requiring their subclasses to implement some abstract parts   class BaseClass     protected void DoStuff       abstract class First   IFirst     public void FirstMethod     DoStuff    DoSubClassStuff        protected abstract void DoStuff       base class reference in MI   protected abstract void DoSubClassStuff       sub class responsibility     C  allows nested classes to access protected private elements of their containing classes  so this can be used to link the abstract bits from the First implementation   class FirstAndSecond   BaseClass  IFirst  ISecond        link interface   private class PartFirst   First       private FirstAndSecond ContainerInstance      public PartFirst FirstAndSecond container          ContainerInstance   container               forwarded references to emulate access as it would be with MI     protected override void DoStuff     ContainerInstance DoStuff          protected override void DoSubClassStuff     ContainerInstance DoSubClassStuff            private IFirst partFirstInstance     composition object   public FirstMethod     partFirstInstance FirstMethod         forwarded implementation   public FirstAndSecond         partFirstInstance   new PartFirst this      composition in constructor          same stuff for Second              implementation of DoSubClassStuff   private void DoSubClassStuff     Console WriteLine  Private method accessed          There is quite some boilerplate involved  but if the actual implementation of FirstMethod and SecondMethod are sufficiently complex and the amount of accessed private protected methods is moderate  then this pattern may help to overcome lacking multiple inheritance

User · Answer

In my own implementation I found that using classes interfaces for MI  although  good form   tended to be a massive over complication since you need to set up all that multiple inheritance for only a few necessary function calls  and in my case  needed to be done literally dozens of times redundantly   Instead it was easier to simply make static  functions that call functions that call functions  in different modular varieties as a sort of OOP replacement  The solution I was working on was the  spell system  for a RPG where effects need to heavily mix-and-match function calling to give an extreme variety of spells without re-writing code  much like the example seems to indicate    Most of the functions can now be static because I don t necessarily need an instance for spell logic  whereas class inheritance can t even use virtual or abstract keywords while static  Interfaces can t use them at all   Coding seems way faster and cleaner this way IMO  If you re just doing functions  and don t need inherited properties  use functions

User · Answer

You could have one abstract base class that implements both IFirst and ISecond  and then inherit from just that base

User · Answer

If X inherits from Y  that has two somewhat orthogonal effects    Y will provide default functionality for X  so the code for X only has to include stuff which is different from Y  Almost anyplace a Y would be expected  an X may be used instead    Although inheritance provides for both features  it is not hard to imagine circumstances where either could be of use without the other   No  net language I know of has a direct way of implementing the first without the second  though one could obtain such functionality by defining a base class which is never used directly  and having one or more classes that inherit directly from it without adding anything new  such classes could share all their code  but would not be substitutable for each other    Any CLR-compliant language  however  will allow the use of interfaces which provide the second feature of interfaces  substitutability  without the first  member reuse

User · Answer

You could have one abstract base class that implements both IFirst and ISecond  and then inherit from just that base

User · Answer

Since multiple inheritance is bad  it makes the source more complicated  C  does not provide such a pattern directly  But sometimes it would be helpful to have this ability    C  and the  net CLR have not implemented MI because they have not concluded how it would inter-operate between C   VB net and the other languages yet  not because  it would make source more complex   MI is a useful concept  the un-answered questions are ones like -  What do you do when you have multiple common base classes in the different superclasses   Perl is the only language I ve ever worked with where MI works and works well   Net may well introduce it one day but not yet  the CLR does already support MI but as I ve said  there are no language constructs for it beyond that yet   Until then you are stuck with Proxy objects and multiple Interfaces instead

User · Answer

Consider just using composition instead of trying to simulate Multiple Inheritance  You can use Interfaces to define what classes make up the composition  eg  ISteerable implies a property of type SteeringWheel  IBrakable implies a property of type BrakePedal  etc   Once you ve done that  you could use the Extension Methods feature added to C  3 0 to further simplify calling methods on those implied properties  eg   public interface ISteerable   SteeringWheel wheel   get  set       public interface IBrakable   BrakePedal brake   get  set       public class Vehicle   ISteerable  IBrakable       public SteeringWheel wheel   get  set         public BrakePedal brake   get  set         public Vehicle     wheel   new SteeringWheel    brake   new BrakePedal         public static class SteeringExtensions       public static void SteerLeft this ISteerable vehicle                vehicle wheel SteerLeft             public static class BrakeExtensions       public static void Stop this IBrakable vehicle                vehicle brake ApplyUntilStop              public class Main       Vehicle myCar   new Vehicle         public void main                 myCar SteerLeft            myCar Stop

User · Answer

If you can live with the restriction that the methods of IFirst and ISecond must only interact with the contract of IFirst and ISecond  like in your example     you can do what you ask with extension methods   In practice  this is rarely the case   public interface IFirst    public interface ISecond     public class FirstAndSecond   IFirst  ISecond      public static MultipleInheritenceExtensions     public static void First this IFirst theFirst          Console WriteLine  First           public static void Second this ISecond theSecond          Console WriteLine  Second                 public void Test       FirstAndSecond fas   new FirstAndSecond      fas First      fas Second        So the basic idea is that you define the required implementation in the interfaces    this required stuff should support the flexible implementation in the extension methods   Anytime you need to  add methods to the interface  instead you add an extension method

User · Answer

You could have one abstract base class that implements both IFirst and ISecond  and then inherit from just that base

User · Answer

Consider just using composition instead of trying to simulate Multiple Inheritance  You can use Interfaces to define what classes make up the composition  eg  ISteerable implies a property of type SteeringWheel  IBrakable implies a property of type BrakePedal  etc   Once you ve done that  you could use the Extension Methods feature added to C  3 0 to further simplify calling methods on those implied properties  eg   public interface ISteerable   SteeringWheel wheel   get  set       public interface IBrakable   BrakePedal brake   get  set       public class Vehicle   ISteerable  IBrakable       public SteeringWheel wheel   get  set         public BrakePedal brake   get  set         public Vehicle     wheel   new SteeringWheel    brake   new BrakePedal         public static class SteeringExtensions       public static void SteerLeft this ISteerable vehicle                vehicle wheel SteerLeft             public static class BrakeExtensions       public static void Stop this IBrakable vehicle                vehicle brake ApplyUntilStop              public class Main       Vehicle myCar   new Vehicle         public void main                 myCar SteerLeft            myCar Stop

User · Answer

i know i know even though its not allowed and so on  sometime u actualy need it so for the those   class a    class b   a    class c   b      like in my case i wanted to do this     class b   Form  yep the windows forms      class c   b     cause half of the function were identical and with interface u must rewrite them all

User · Answer

Yes using Interface is a hassle because anytime we add a method in the class we have to add the signature in the interface  Also  what if we already have a class with a bunch of methods but no Interface for it  we have to manually create Interface for all the classes that we want to inherit from  And the worst thing is  we have to implement all methods in the Interfaces in the child class if the child class is to inherit from the multiple interface   By following Facade design pattern we can simulate inheriting from multiple classes using accessors  Declare the classes as properties with  get set   inside the class that need to inherit and all public properties and methods are from that class  and in the constructor of the child class instantiate the parent classes   For example    namespace OOP         class Program                 static void Main string   args                          Child somechild   new Child                 somechild DoHomeWork                 somechild CheckingAround                 Console ReadLine                            public class Father                  public Father                public void Work                           Console WriteLine  working                           public void Moonlight                           Console WriteLine  moonlighting                                public class Mother                  public Mother                public void Cook                           Console WriteLine  cooking                           public void Clean                           Console WriteLine  cleaning                                public class Child                  public Father MyFather   get  set             public Mother MyMother   get  set              public Child                           MyFather   new Father                 MyMother   new Mother                         public void GoToSchool                           Console WriteLine  go to school                           public void DoHomeWork                           Console WriteLine  doing homework                           public void CheckingAround                           MyFather Work                 MyMother Cook                             with this structure class Child will have access to all methods and properties of Class Father and Mother  simulating multiple inheritance  inheriting an instance of the parent classes  Not quite the same but it is practical

User · Answer

In my own implementation I found that using classes interfaces for MI  although  good form   tended to be a massive over complication since you need to set up all that multiple inheritance for only a few necessary function calls  and in my case  needed to be done literally dozens of times redundantly   Instead it was easier to simply make static  functions that call functions that call functions  in different modular varieties as a sort of OOP replacement  The solution I was working on was the  spell system  for a RPG where effects need to heavily mix-and-match function calling to give an extreme variety of spells without re-writing code  much like the example seems to indicate    Most of the functions can now be static because I don t necessarily need an instance for spell logic  whereas class inheritance can t even use virtual or abstract keywords while static  Interfaces can t use them at all   Coding seems way faster and cleaner this way IMO  If you re just doing functions  and don t need inherited properties  use functions

User · Answer

Multiple inheritance is one of those things that generally causes more problems than it solves   In C   it fits the pattern of giving you enough rope to hang yourself  but Java and C  have chosen to go the safer route of not giving you the option   The biggest problem is what to do if you inherit multiple classes that have a method with the same signature that the inheritee doesn t implement   Which class s method should it choose   Or should that not compile   There is generally another way to implement most things that doesn t rely on multiple inheritance

User · Answer

If you can live with the restriction that the methods of IFirst and ISecond must only interact with the contract of IFirst and ISecond  like in your example     you can do what you ask with extension methods   In practice  this is rarely the case   public interface IFirst    public interface ISecond     public class FirstAndSecond   IFirst  ISecond      public static MultipleInheritenceExtensions     public static void First this IFirst theFirst          Console WriteLine  First           public static void Second this ISecond theSecond          Console WriteLine  Second                 public void Test       FirstAndSecond fas   new FirstAndSecond      fas First      fas Second        So the basic idea is that you define the required implementation in the interfaces    this required stuff should support the flexible implementation in the extension methods   Anytime you need to  add methods to the interface  instead you add an extension method

User · Answer

Consider just using composition instead of trying to simulate Multiple Inheritance  You can use Interfaces to define what classes make up the composition  eg  ISteerable implies a property of type SteeringWheel  IBrakable implies a property of type BrakePedal  etc   Once you ve done that  you could use the Extension Methods feature added to C  3 0 to further simplify calling methods on those implied properties  eg   public interface ISteerable   SteeringWheel wheel   get  set       public interface IBrakable   BrakePedal brake   get  set       public class Vehicle   ISteerable  IBrakable       public SteeringWheel wheel   get  set         public BrakePedal brake   get  set         public Vehicle     wheel   new SteeringWheel    brake   new BrakePedal         public static class SteeringExtensions       public static void SteerLeft this ISteerable vehicle                vehicle wheel SteerLeft             public static class BrakeExtensions       public static void Stop this IBrakable vehicle                vehicle brake ApplyUntilStop              public class Main       Vehicle myCar   new Vehicle         public void main                 myCar SteerLeft            myCar Stop

User · Answer

Multiple inheritance is one of those things that generally causes more problems than it solves   In C   it fits the pattern of giving you enough rope to hang yourself  but Java and C  have chosen to go the safer route of not giving you the option   The biggest problem is what to do if you inherit multiple classes that have a method with the same signature that the inheritee doesn t implement   Which class s method should it choose   Or should that not compile   There is generally another way to implement most things that doesn t rely on multiple inheritance

User · Answer

Consider just using composition instead of trying to simulate Multiple Inheritance  You can use Interfaces to define what classes make up the composition  eg  ISteerable implies a property of type SteeringWheel  IBrakable implies a property of type BrakePedal  etc   Once you ve done that  you could use the Extension Methods feature added to C  3 0 to further simplify calling methods on those implied properties  eg   public interface ISteerable   SteeringWheel wheel   get  set       public interface IBrakable   BrakePedal brake   get  set       public class Vehicle   ISteerable  IBrakable       public SteeringWheel wheel   get  set         public BrakePedal brake   get  set         public Vehicle     wheel   new SteeringWheel    brake   new BrakePedal         public static class SteeringExtensions       public static void SteerLeft this ISteerable vehicle                vehicle wheel SteerLeft             public static class BrakeExtensions       public static void Stop this IBrakable vehicle                vehicle brake ApplyUntilStop              public class Main       Vehicle myCar   new Vehicle         public void main                 myCar SteerLeft            myCar Stop

User · Answer

i know i know even though its not allowed and so on  sometime u actualy need it so for the those   class a    class b   a    class c   b      like in my case i wanted to do this     class b   Form  yep the windows forms      class c   b     cause half of the function were identical and with interface u must rewrite them all

User · Answer

If you can live with the restriction that the methods of IFirst and ISecond must only interact with the contract of IFirst and ISecond  like in your example     you can do what you ask with extension methods   In practice  this is rarely the case   public interface IFirst    public interface ISecond     public class FirstAndSecond   IFirst  ISecond      public static MultipleInheritenceExtensions     public static void First this IFirst theFirst          Console WriteLine  First           public static void Second this ISecond theSecond          Console WriteLine  Second                 public void Test       FirstAndSecond fas   new FirstAndSecond      fas First      fas Second        So the basic idea is that you define the required implementation in the interfaces    this required stuff should support the flexible implementation in the extension methods   Anytime you need to  add methods to the interface  instead you add an extension method

User · Answer

We all seem to be heading down the interface path with this  but the obvious other possibility  here  is to do what OOP is supposed to do  and build up your inheritance tree     isn t this what class design is all about    class Program       static void Main string   args                human me   new human            me legs   2          me lfType    Human           me name    Paul           Console WriteLine me name            public abstract class lifeform       public string lfType   get  set       public abstract class mammal   lifeform        public int legs   get  set       public class human   mammal       public string name   get  set        This structure provides reusable blocks of code and  surely  is how OOP code should be written   If this particular approach doesn t quite fit the bill the we simply create new classes based on the required objects     class Program       static void Main string   args                fish shark   new fish            shark size    large           shark lfType    Fish           shark name    Jaws           Console WriteLine shark name           human me   new human            me legs   2          me lfType    Human           me name    Paul           Console WriteLine me name            public abstract class lifeform       public string lfType   get  set       public abstract class mammal   lifeform        public int legs   get  set       public class human   mammal       public string name   get  set       public class aquatic   lifeform       public string size   get  set       public class fish   aquatic       public string name   get  set

User · Answer

Yes using Interface is a hassle because anytime we add a method in the class we have to add the signature in the interface  Also  what if we already have a class with a bunch of methods but no Interface for it  we have to manually create Interface for all the classes that we want to inherit from  And the worst thing is  we have to implement all methods in the Interfaces in the child class if the child class is to inherit from the multiple interface   By following Facade design pattern we can simulate inheriting from multiple classes using accessors  Declare the classes as properties with  get set   inside the class that need to inherit and all public properties and methods are from that class  and in the constructor of the child class instantiate the parent classes   For example    namespace OOP         class Program                 static void Main string   args                          Child somechild   new Child                 somechild DoHomeWork                 somechild CheckingAround                 Console ReadLine                            public class Father                  public Father                public void Work                           Console WriteLine  working                           public void Moonlight                           Console WriteLine  moonlighting                                public class Mother                  public Mother                public void Cook                           Console WriteLine  cooking                           public void Clean                           Console WriteLine  cleaning                                public class Child                  public Father MyFather   get  set             public Mother MyMother   get  set              public Child                           MyFather   new Father                 MyMother   new Mother                         public void GoToSchool                           Console WriteLine  go to school                           public void DoHomeWork                           Console WriteLine  doing homework                           public void CheckingAround                           MyFather Work                 MyMother Cook                             with this structure class Child will have access to all methods and properties of Class Father and Mother  simulating multiple inheritance  inheriting an instance of the parent classes  Not quite the same but it is practical

User · Answer

I created a C  post-compiler that enables this kind of thing   using NRoles   public interface IFirst   void FirstMethod      public interface ISecond   void SecondMethod       public class RFirst   IFirst  Role     public void FirstMethod     Console WriteLine  First         public class RSecond   ISecond  Role     public void SecondMethod     Console WriteLine  Second         public class FirstAndSecond   Does lt RFirst gt   Does lt RSecond gt        You can run the post-compiler as a Visual Studio post-build-event      C  some path nroles-v0 1 0-bin nutate exe    TargetPath     In the same assembly you use it like this   var fas   new FirstAndSecond    fas As lt RFirst gt    FirstMethod    fas As lt RSecond gt    SecondMethod      In another assembly you use it like this   var fas   new FirstAndSecond    fas FirstMethod    fas SecondMethod

User · Answer

This is along the lines of Lawrence Wenham s answer  but depending on your use case  it may or may not be an improvement -- you don t need the setters   public interface IPerson     int GetAge      string GetName       public interface IGetPerson     IPerson GetPerson       public static class IGetPersonAdditions     public static int GetAgeViaPerson this IGetPerson getPerson       I prefer to have the  ViaPerson  in the name in case the object has another Age property      IPerson person   getPerson GetPersion        return person GetAge          public static string GetNameViaPerson this IGetPerson getPerson        return getPerson GetPerson   GetName           public class Person  IPerson  IGetPerson     private int Age  get set     private string Name  get set     public IPerson GetPerson         return this        public int GetAge      return Age      public string GetName     return Name        Now any object that knows how to get a person can implement IGetPerson  and it will automatically have the GetAgeViaPerson   and GetNameViaPerson   methods  From this point  basically all Person code goes into IGetPerson  not into IPerson  other than new ivars  which have to go into both   And in using such code  you don t have to be concerned about whether or not your IGetPerson object is itself actually an IPerson

User · Answer

If you can live with the restriction that the methods of IFirst and ISecond must only interact with the contract of IFirst and ISecond  like in your example     you can do what you ask with extension methods   In practice  this is rarely the case   public interface IFirst    public interface ISecond     public class FirstAndSecond   IFirst  ISecond      public static MultipleInheritenceExtensions     public static void First this IFirst theFirst          Console WriteLine  First           public static void Second this ISecond theSecond          Console WriteLine  Second                 public void Test       FirstAndSecond fas   new FirstAndSecond      fas First      fas Second        So the basic idea is that you define the required implementation in the interfaces    this required stuff should support the flexible implementation in the extension methods   Anytime you need to  add methods to the interface  instead you add an extension method

User · Answer

If X inherits from Y  that has two somewhat orthogonal effects    Y will provide default functionality for X  so the code for X only has to include stuff which is different from Y  Almost anyplace a Y would be expected  an X may be used instead    Although inheritance provides for both features  it is not hard to imagine circumstances where either could be of use without the other   No  net language I know of has a direct way of implementing the first without the second  though one could obtain such functionality by defining a base class which is never used directly  and having one or more classes that inherit directly from it without adding anything new  such classes could share all their code  but would not be substitutable for each other    Any CLR-compliant language  however  will allow the use of interfaces which provide the second feature of interfaces  substitutability  without the first  member reuse

User · Answer

We all seem to be heading down the interface path with this  but the obvious other possibility  here  is to do what OOP is supposed to do  and build up your inheritance tree     isn t this what class design is all about    class Program       static void Main string   args                human me   new human            me legs   2          me lfType    Human           me name    Paul           Console WriteLine me name            public abstract class lifeform       public string lfType   get  set       public abstract class mammal   lifeform        public int legs   get  set       public class human   mammal       public string name   get  set        This structure provides reusable blocks of code and  surely  is how OOP code should be written   If this particular approach doesn t quite fit the bill the we simply create new classes based on the required objects     class Program       static void Main string   args                fish shark   new fish            shark size    large           shark lfType    Fish           shark name    Jaws           Console WriteLine shark name           human me   new human            me legs   2          me lfType    Human           me name    Paul           Console WriteLine me name            public abstract class lifeform       public string lfType   get  set       public abstract class mammal   lifeform        public int legs   get  set       public class human   mammal       public string name   get  set       public class aquatic   lifeform       public string size   get  set       public class fish   aquatic       public string name   get  set

User · Answer

Since the question of multiple inheritance  MI  pops up from time to time  I d like to add an approach which addresses some problems with the composition pattern   I build upon the IFirst  ISecond First  Second  FirstAndSecond approach  as it was presented in the question  I reduce sample code to IFirst  since the pattern stays the same regardless of the number of interfaces   MI base classes   Lets assume  that with MI First and Second would both derive from the same base class BaseClass  using only public interface elements from BaseClass  This can be expressed  by adding a container reference to BaseClass in the First and Second implementation   class First   IFirst     private BaseClass ContainerInstance    First BaseClass container    ContainerInstance   container      public void FirstMethod     Console WriteLine  First    ContainerInstance DoStuff               Things become more complicated  when protected interface elements from BaseClass are referenced or when First and Second would be abstract classes in MI  requiring their subclasses to implement some abstract parts   class BaseClass     protected void DoStuff       abstract class First   IFirst     public void FirstMethod     DoStuff    DoSubClassStuff        protected abstract void DoStuff       base class reference in MI   protected abstract void DoSubClassStuff       sub class responsibility     C  allows nested classes to access protected private elements of their containing classes  so this can be used to link the abstract bits from the First implementation   class FirstAndSecond   BaseClass  IFirst  ISecond        link interface   private class PartFirst   First       private FirstAndSecond ContainerInstance      public PartFirst FirstAndSecond container          ContainerInstance   container               forwarded references to emulate access as it would be with MI     protected override void DoStuff     ContainerInstance DoStuff          protected override void DoSubClassStuff     ContainerInstance DoSubClassStuff            private IFirst partFirstInstance     composition object   public FirstMethod     partFirstInstance FirstMethod         forwarded implementation   public FirstAndSecond         partFirstInstance   new PartFirst this      composition in constructor          same stuff for Second              implementation of DoSubClassStuff   private void DoSubClassStuff     Console WriteLine  Private method accessed          There is quite some boilerplate involved  but if the actual implementation of FirstMethod and SecondMethod are sufficiently complex and the amount of accessed private protected methods is moderate  then this pattern may help to overcome lacking multiple inheritance

User · Answer

This is along the lines of Lawrence Wenham s answer  but depending on your use case  it may or may not be an improvement -- you don t need the setters   public interface IPerson     int GetAge      string GetName       public interface IGetPerson     IPerson GetPerson       public static class IGetPersonAdditions     public static int GetAgeViaPerson this IGetPerson getPerson       I prefer to have the  ViaPerson  in the name in case the object has another Age property      IPerson person   getPerson GetPersion        return person GetAge          public static string GetNameViaPerson this IGetPerson getPerson        return getPerson GetPerson   GetName           public class Person  IPerson  IGetPerson     private int Age  get set     private string Name  get set     public IPerson GetPerson         return this        public int GetAge      return Age      public string GetName     return Name        Now any object that knows how to get a person can implement IGetPerson  and it will automatically have the GetAgeViaPerson   and GetNameViaPerson   methods  From this point  basically all Person code goes into IGetPerson  not into IPerson  other than new ivars  which have to go into both   And in using such code  you don t have to be concerned about whether or not your IGetPerson object is itself actually an IPerson

User · Answer

Since multiple inheritance is bad  it makes the source more complicated  C  does not provide such a pattern directly  But sometimes it would be helpful to have this ability    C  and the  net CLR have not implemented MI because they have not concluded how it would inter-operate between C   VB net and the other languages yet  not because  it would make source more complex   MI is a useful concept  the un-answered questions are ones like -  What do you do when you have multiple common base classes in the different superclasses   Perl is the only language I ve ever worked with where MI works and works well   Net may well introduce it one day but not yet  the CLR does already support MI but as I ve said  there are no language constructs for it beyond that yet   Until then you are stuck with Proxy objects and multiple Interfaces instead

[c#] Multiple Inheritance in C#

Examples related to c#

Examples related to interface

Examples related to multiple-inheritance