Do interfaces derive from System.Object? C# spec says yes, Eric says no, reality says no

It really depends on the definition of "derives". Surprisingly, the C# specification does not have a single canonical definition for this term. Fortunately the actual behavior of code is still specified unambiguously. But it does mean some questions are hard to answer without going into hair-splitting!

• Are interfaces a subtype of System.Object? Yes.

• Does interfaces inherit from System.Object? No.

The common definition of subtype is that if type A is a subtype of type B, then a value of type A can be used anywhere a value of type B is expected. A fullfills the contract of B.

By this definition, all interfaces in C# are subtypes System.Object since an interface instance is also an instance of System.Object.

For example you can do this:

 IComparable x = new String();
 Console.Write(x is Object); // writes "true"

and this:

IComparable x = new String();
object y = x; // implicit cast from interface to System.Object

and:

IComparable x = new String();
var y = x.ToString(); // method inherited from System.Object

So it walks like a duck and quacks like a duck!

But Eric Lippert says...

In the quote Lippert is using "derived" to refer to inheritance. All class types inherit (directly or indirectly) members from System.Object - but interfaces does not. Interfaces only inherit from other interfaces. So by this definition, interfaces clearly does not derive from System.Object.

But note that this is not a disagreement about how the language actually works, it is purely a difference in the terminology used to describe it.

The two definitions are usually equivalent in C#, but your question is one of the edge cases where it makes a difference.

But reality says...

Reflection is a language-independent .net API which uses the CLI terminology. This cannot be transferred directly to C# since C# is not formally depending on the CLI. (For example in CLR value types are considered different types than boxed value types, and only boxed value types are considered objects. This is not a distinction C# makes.)

But anyway, the BaseType property is specified like this:

The Type from which the current Type directly inherits, or null if the current Type represents the Object class or an interface.

Note that this completely sidesteps the issue! It doesn't state whether interfaces can have a base type or not, just that it will always return null regardless. So it doesn't really answer the question.

Bottom line

In the end, what matters is the observable behavior of the language. The intention of the language designers is clear from a larger quote:

C#’s type system is unified such that a value of any type can be treated as an object. Every type in C# directly or indirectly derives from the object class type, and object is the ultimate base class of all types. Values of reference types are treated as objects simply by viewing the values as type object. Values of value types are treated as objects by performing boxing and unboxing operations (§9.3.12).

The important point is that interfaces can always be treated as objects. Whether they "actually" derive from object is purely a philosophical discussion then.