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: 
You should choose interface inheritance if and only if a type implementing IWidget1 *must* also implement ICommon. In either case, the class is going to implement both IWidget1 and ICommon separately. The only difference is that if you make IWidget1 "derive" from ICommon you enforce the fact that an IWidget1 must also be an ICommon.

A good example is IEnumerable and ICollection. Every ICollection is guaranteed to be IEnumerable, so ICollection derives from IEnumerable. If it was legal or made sense to be a collection but not be enumerable, then implementers of ICollection wouldn't have to implement IEnumerable also.

Whichever you choose will not affect COM visibility. .NET will still export the interfaces separately if I recall correctly.
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.