What's the difference between an abstract class and an interface?

Suppose we have two methods M1() and M2() in an interface. An abstract class also has just the same two abstract methods. If any class implemented this interface or inherited from the abstract class, it will have to implement both the methods in it.

So to me, it seems that an interface or an abstract class behaves the same for my scenario. So, can anyone highlight the difference between these two in this specific case and suggest whether to use an abstract class or an interface here?

There are technical differences between Abstract Classes and Interfaces, that being an Abstract Class can contain implementation of methods, fields, constructors, etc, while an Interface only contains method and property prototypes. A class can implement multiple interfaces, but it can only inherit one class (abstract or otherwise).

However, in my opinion, the most important difference between Interfaces and Abstract Classes is the semantic difference.

An Interface defines what something can do (how it behaves), and an Abstract Class defines what something is.

Take for example IEnumerable, the semantic meaning behind this is that anything that implements IEnumerable is enumerable, it doesn't mean that it's an enumeration, but that it can behave like one (can be enumerated).

Contrast that with a washing machine example, anything that inherits it is a type of washing machine. Anything that inherits it would be a type of washing machine, a top loader, or side loader, etc.

Instead, if you had an interface called ICanWash, which could contain a method called Wash. You could have various things implement ICanWash, be it a Person, an abstract washing machine class, etc, where the actual implementation does not matter, just you need to know that the behavior is that it can wash things.

In summary, classes define what something is, interfaces define what something can do.

From MSDN:

> By using interfaces, you can, for example, include behavior from > multiple sources in a class. That capability is important in C# > because the language doesn't support multiple inheritance of classes

So, use interface if you want that any class can inherit that methods.

From same MSDN page:

> In addition, you must use an interface if you want to simulate > inheritance for structs, because they can't actually inherit from > another struct or class.

Interface allows a class to inherit/implement more than one interface, while in C# you can only inherit from one class.

Multiple inheritance, basically.

Abstract class not only holds abstract methods, it may also hold other fields and methods with implemntation. In c# you can not inherit from multipule classes, but you can implement multipule interfaces. So the short answer is: whenever possible use interfaces and not abstract classes. In your example it is possibe- and therfor recomended to use an interface.

Two quick thoughts on differences between interfaces and abstract classes:

1. Abstract classes desired if future expansion is likely, as an abstract class can be expanded, but an interface would have to be enhanced by addition of another interface, I2.
2. Single (implementation) inheritance means chooses abstract classes careully, to most closely reflect the true basic nature. Interfaces can easly be added to an implemntation, but an abstract class can only be added if there is not one already.