Multiple Inheritence in C#

Question

I do understand that there's no multiple inheritence in C#. However, I've run into a situation in which I really wish it existed. I am creating a custom class that requires me to inherit from CLR types and override a few methods. Unfortunately, I am creating several of these which are very similar. In the interest of DRY, I'd really want to move common functionality to a base class, but then I'd need to inherit from 2 classes. I can use interfaces (and infact I am using one right now) but this solves only half the problem as the method implementations still need to be repeated across several custom classes.

What's the purist way of achieving what I am trying to do?

EDIT:

Here's a generic code sample

public class CustomTypeOne : CLRType
{
   public override void Execute(HttpContext context)
   {
        //Some code that's similar across CustomTypeOne, CustomTypeTwo etc
   }

   public void DoStuff()
   {
       //Same for all CustomTypes and can be part of a base class
   }

   //More methods
}

public class CustomTypeTwo : CLRType
{
   public override void Execute(HttpContext context)
   {
        //Some code that's similar across CustomTypeOne, CustomTypeTwo etc
   }

   public void DoStuff()
   {
       //Same for all CustomTypes and can be part of a base class
   }

   //More methods

}

Answer 1

At times where I felt multiple inheritance would save the day, I realized that it really does make implementation and maintainability more challenging. MI effectively merges the public and protected namespace among the inherited classes, which can cause some ambiguity and complexity you don't need.

So, instead of an IS-A relationship, often I'm happier implementing a HAS-A relationship. The classes I would've inherited would instead be data members in the class.

Answer 2

Create your base class as a generic class, templated on the CLR type you need.

class BaseClass<T> where T : struct
{
   public override void Execute(HttpContext context) 
   { 
        //Some code that's similar across CustomTypeOne, CustomTypeTwo etc 
   } 

   public void DoStuff() 
   { 
       //Same for all CustomTypes and can be part of a base class 
   } 

}

public class CustomTypeOne : BaseClass<int>
{
}

public class CustomTypeTwo : BaseClass<long>
{
}

(it would be nice if your examples showed how you were using the CLR base types....)

Answer 3

Composition is the preferred alternative to inheritance. There are always exceptions and special cases, but if you can solve the problem with composition, you'll probably end up with more flexible code than if you used inheritance.

Answer 4

Generally you should prefer using composition to inheritance.

If each of these classes were members of a common base class this should avoid the problem.

Answer 5

Prefer composition over inheritance - write a wrapper that wraps both "base type" objects.

Answer 6

You could create a new object that contains the common functionality and use object composition instead of inheritence.

For example, use depency injection to inject your object that contains the common functionality into your objects.

Answer 7

There are a few ways to implement what you are talking about.

Assuming that you have a structure like like

MyTypeA : CLR_TypeA
{
    public override ToString()
    {
       //do some complicated stuff
    }
}
MyTypeB : CLR_TypeB
{
    public override ToString()
    {
       //do the same complicated stuff
    }
}

Then it makes sense to want to have a base class, but you can't. One method that other answers mentioned is composition. However in your case it might be possible to create another static class

public static class ToStringHelpers
{
    public static DoComplicatedStuff()
    {
       //do some pretty wild stuff.
    }
}

MyTypeA : CLR_TypeA
{
    public override ToString()
    {
       DoComplicatedStuff();
    }
}
MyTypeB : CLR_TypeB
{
    public override ToString()
    {
       DoComplicatedStuff();
    }
}

Then you have all of your disparate objects that need duplicate functionality call the helper method. The only advantage multiple inheritance would have in this case is that you wouldn't have to write "DoComplicatedStuff()" over and over, but copy/paste will clean up that problem pretty quick anyway.

EDIT

If you are inheriting from the same type, then you don't need MI for this

MyBaseType : CLRType
{
   public override void Execute(HttpContext context)
   {
       //Some code that's similar across CustomTypeOne, CustomTypeTwo etc
   }

   public void DoStuff()
   {
      //Same for all CustomTypes and can be part of a base class
   }

}

MyTypeA : MyBaseType
{
    public void MyTypeACustomMethod()
    { 
      //do class specific logic here
    }
}

MyTypeB : MyBaseType
{
    public void MyTypeBCustomMethod()
    { 
      //do class specific logic here
    }
}

Answer 8

If the common functionality is comprised of utility methods using the public interface of the class, you can use extension methods on the interface. If you need access to private state to implement these methods, you can compromise a bit by creating an internal interface that wraps the state, implementing it explicitly and then implementing internal extension methods on that interface. Your public interface extension methods can now access the internal interface in their implementation (though an explicit cast), essentially giving you shared internal methods.

public abstract class BaseClass { }

public interface IMyClass { }

internal interface IMyClassImpl { }

public class MyClass : BaseClass, IMyClass, IMyClassImpl
{
    //IMyClassImpl members should be implemented explicitly, so they are inaccessible to outside clients.
}

public static class MyClassExtensions
{
    public static void HelperMethod(this IMyClass instance)
    {
        //Do stuff...
        //Can access internal implementation as necessary
        var impl = (IMyClassImpl)instance;
        impl.InternalHelperMethod();
    }

    internal static void InternalHelperMethod(this IMyClassImpl instance)
    {

    }
}

Note that methods which use the internal state methods should probably have a runtime check that you're passing a class that supports the internal interface.

Answer 9

If your situation really does call for multiple inheritance then there is no pure way of doing it. But one trick I have used in the past is to use extension methods to mimic mixins.

Like the others I agree that it is preferrable to use composition if possible. Unfortunately there really are times (like implementing the MVVM pattern) where not having multiple inheritance is a hinderance. You may not have any other choice but to duplicate some code.