Interface + Extension (mixin) vs Base Class

Question

Is an interface + extension methods (mixin) preferable to an abstract class?

If your answer is "it depends", what does it depend upon?

I see two possible advantages to the interface + extension approach.

• Interfaces are multiply inheritable and classes are not.
• You can use extension methods to extend interfaces in a non-breaking way. (Clients that implement your interface will gain your new base implementation but still be able to override it.)

I have not yet thought of a downside to this approach. There may be a glaringly simple reason that the interface + extension approach will fail.

Two helpful articles on this topic are

• Create Mixins with Interfaces and Extension Methods
• Abstract Base Classes Have Versioning Problems Too

Answer 1

Downside of extension methods: clients pre-C#3/VB9 won't be able to use it as easily.

That's about it as far as I'm concerned - I think the interface-based approach is significantly nicer. You can then mock out your dependencies nicely, and everything is basically less tightly coupled. I'm not a huge fan of class inheritance unless it's really about specialization :)

EDIT: I've just thought of one other benefit which might be relevant. It's possible that some of the concrete implementations could provide more optimized versions of some of the general methods.

Enumerable.Count is a good example of this - it explicitly checks whether the sequence implements IList or not, because if it does it can call Count on the list instead of iterating through the whole sequence. If IEnumerable<T> had been an abstract class with a virtual Count() method, it could have been overridden in List<T> rather than there being a single implementation which knows about IList explicitly. I'm not saying this is always relevant, nor that IEnumerable<T> should have been an abstract class (definitely not!) - just pointing it out as a small possible disadvantage. That's where polymorphism really would be appropriate, by specializing existing behaviour (admittedly in a way which only affects performance instead of the result).

Answer 2

Interfaces tend to make code a little cleaner I feel it's a little easier to test. When you add Extensions your adding even more flexibility while keeping clean testable code.

For me abstract classes have always seemed clunky, using interfaces I can have an object factory that returns an object that is specific to what I'm trying to accomplish (separation of concerns).

Just making something up A have the interface called Math that has add, subtract, divide and multiply and then I have a class called IntMAth that implements Math that is optimized for integer math, and I have another class called FloatMath the implements Math that is optimized for Floating Math, and I have a generalMath that implements Math that handles everything else.

When I need to Add some floats I could call my factory MathFactory.getMath(typeof(float)) and it has some logic to know that if the type I'm passing in is a float then it returns the FloatMath class.

This way all of my classes are smaller and more maintainable, the code that calls the classes is smaller, etc.

Answer 3

IMHO, this is the wrong question.

You should use everything for what it is designed for.

• Extension methods are not members. They are syntactically looking like members, so you can find them easier.
• Extension methods can only use the public (or internal) interface. Many other classes could do the same. So extension methods are not a real encapsulation in an oo way.

• They are static methods and can not be overridden and not be mocked in a unit test. Is is a non-OO language feature and the caller is statically bound to it.

• Abstract base classes are really often misused to "reuse code" (instead of a real inheritance). This applies to inheritance in general.

The question should be: "When should I use Interfaces, extension methods or base classes?"

• use interfaces whenever you need a contract (and this happens all the time).
• Use (abstract) base classes when you have a situation for real inheritance (you could write a book about how to judged that, so I just leave it like this). An interface is mostly also implemented at the same time.
• use extension methods for logic that should not be actually a member of the type, because it is not the responsibility of the type to implement it - but you want to make it easy to find and and it feels natural to call it like a member.

Edit:

Or the question should be: "How do I write reusable functionality that does not belong to a base class?"

• write an interface that exposes the functionality
• write a reusable library class that implements the functionality
• write a class that implements the interface and reuses the functionality by aggregating the reusable class.

In general I would say, extension methods are the wrong place for business logic, except of special cases or special design decisions.

Base classes are only in rare cases the right decision. In doubt, it is not. In no-doubt, you should think again about it.