Question: I'm implementing a set of classes and corresponding interfaces where I want each class to have a set of common properties and a set of specialised properties that are specific only to that class. So, I'm considering defining interfaces along the lines of:

```
interface ICommon {...}  // Members common to all widgets
interface IWidget1 {...} // specialized members of widget type 1
interface IWidget2 {...} // specialized members of widget type 2

```

I am trying to choose between having the inheritance in the interfaces, or in the class. So, specifically, I can either do it like this:

```
interface IWidget1 : ICommon {...}
interface IWidget2 : ICommon {...}
class Widget1 : IWidget1 {...}
class Widget2 : IWidget2 {...}

```

...or like this...

```
class Widget1: ICommon, IWidget1 {...}
class Widget2: ICommon, IWidget2 {...}

```

Is there any compelling reason to go one way or the other?

Update: Would it affect the answer if the classes must be COM-visible?

Answer: 
Use Liskov Substitution Principle to help yourself to an answer. 

If IWidget1 can be substituted for all clients working in terms of ICommon1, then you could inherit IWidget1 from ICommon1.
If not go with the class implementing multiple interfaces.
The inheritence is dependent on the attribute/behaviour of the class or interface. If the behaviours in `IWidget1` and `IWidget2` include all of the behaviours in `ICommon`, then you can surely inherit like `IWidget1 : ICommon` and `IWidget2 : ICommon` and there is no issue regarding `ComVisible`. This is simply OOPS concept.