So many interfaces!

Today, another question from StackOverflow, and again, presented as a dialogue as is my wont.

The MSDN documentation for List<T> says that the class is declared as

public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>,
IList, ICollection, IEnumerable

Does List<T> really implement all those interfaces?


Why so many interfaces?

Because when an interface like IList<T> inherits from an interface like IEnumerable<T> then implementers of the more derived interface are required to also implement the less derived interface. That's what interface inheritance means; if you fulfill the contract of the more derived type then you are required to also fulfill the contract of the less derived type.

So a class or struct is required to implement all the methods of all the interfaces in the transitive closure of its base interfaces?


Is a class (or struct) that implements a more-derived interface also required to state in its base type list that it is implementing all of those less-derived interfaces?


Is the class required to not state it?


So it's optional whether the less-derived implemented interfaces are stated in the base type list?



Almost always:

interface I1 {}
interface I2 : I1 {}
interface I3 : I2 {}

It is optional whether I3 states that it inherits from I1.

class B : I3 {}

Implementers of I3 are required to implement I2 and I1, but they are not required to state explicitly that they are doing so. It's optional.

class D : B {}

Derived classes are not required to re-state that they implement an interface from their base class, but are permitted to do so. (This case is special; see below for more details.)

class C<T> where T : I3
  public virtual void M<U>() where U : I3 {}

Type arguments corresponding to T and U are required to implement I2 and I1, but it is optional for the constraints on T or U to state that.

It is always optional to re-state any base interface in a partial class:

partial class E : I3 {}
partial class E {}

The second half of E is permitted to state that it implements I3 or I2 or I1, but not required to do so.

OK, I get it; it's optional. Why would anyone unnecessarily state a base interface?

Perhaps because they believe that doing so makes the code easier to understand and more self-documenting.

Or, perhaps the developer wrote the code as

interface I1 {}
interface I2 {}
interface I3 : I1, I2 {}

and the realized, oh, wait a minute, I2 should inherit from I1. Why should making that edit then require the developer to go back and change the declaration of I3 to not contain explicit mention of I1? I see no reason to force developers to remove redundant information.

Aside from being easier to read and understand, is there any technical difference between stating an interface explicitly in the base type list and leaving it unstated but implied?

Usually no, but there can be a subtle difference in one case. Suppose you have a derived class D whose base class B has implemented some interfaces. D automatically implements those interfaces via B. If you restate the interfaces in D's base class list then the C# compiler will do an interface reimplementation. The details are a bit subtle; if you are interested in how this works then I recommend a careful reading of section 13.4.6 of the C# 4 specification. Basically the idea is that the compiler "starts over" and figures out which methods implement which interfaces.

UPDATE: See this follow-up article for details of interface re-implementation.

Does the List<T> source code actually state all those interfaces?

No. The actual source code says

public class List<T> : IList<T>, System.Collections.IList

Why does MSDN have the full interface list but the real source code does not?

Because MSDN is documentation; it's supposed to give you as much information as you might want. It is much more clear for the documentation to be complete all in one place than to make you search through ten different pages to find out what the full interface set is.

Why do tools like Reflector or the object browser show the whole list?

Those tools do not have the source code. They only have metadata to work from. Since putting in the full list is optional, the tool has no idea whether the original source code contains the full list or not. It is better to err on the side of more information. Again, the tool is attempting to help you by showing you more information rather than hiding information you might need.

I noticed that IEnumerable<T> inherits from IEnumerable but IList<T> does not inherit from IList. What's up with that?

The same reason why IEnumerable<T> can be made covariant in T but IList<T> cannot. A sequence of integers can be treated as a sequence of objects, by boxing every integer as it comes out of the sequence. But a read-write list of integers cannot be treated as a read-write list of objects, because you can put a string into a read-write list of objects. An IEnumerable<T> can easily fulfill the contract of IEnumerable just by adding a boxing helper method. But IList<T> is not required to fulfill the whole contract of IList, so it does not inherit from it.

Why then does List<T> implement IList?

It is a bit odd, since List<T> for any type other than object does not fulfill the full contract of IList. It's probably to make it easier on people who are updating old C# 1.0 code to use generics; those people were probably already ensuring that only the right types got into their lists. And most of the time when you're passing an IList around, it is so the callee can get by-index access to the list, not so that it can add new items of arbitrary type.

Comments (29)
  1. Jeroen Frijters says:

    On a related note, why does the C# compiler emit the transitive closure of all implemented interfaces on the type?

    The desktop CLR doesn't require this (and neither does the CLI spec, AFAIK), but the Compact Framework does require it (at least I ran into some problems years ago, when my compiler didn't do this).

  2. David Gladfelter says:

    Kudos on an excellent post.  I personally find it very difficult to write about a deep topic in such a way as to guide others, piece by piece, to the insights I've earned, but that's exactly what you've done here.

  3. configurator says:

    @Jeroen: Why not? If some frameworks require it, why not emit it for all of them? It's more work not to emit it, isn't it?

  4. Olivier says:

    This post reminds me how much I wish all the now-confusing and useless classes like non-generic List could be removed, along with some obsolete features.

    I guess it must be really difficult to decide to abandon compatibility and simplify a programming language, since no language I know ever did after the very beginning. It could be well worth the cost, once every 5 or 10 years.

    The Silverlight version of the BCL does not have the non-generic collection types. That's usually how these things get eliminated; some "green field" new implementation without backwards compat burdens can get rid of the deadwood accumulated by the previous "legacy" version. — Eric

  5. tobi says:

    I wonder why old collections such as MatchCollection have not been upgraded to implement the new interfaces in addition to to old ones. This makes using them with linq unpleasant (necessitating .Cast<Match>()).

  6. Ihar Bury says:

    Actually, implementing IList interface doesn't require you to be able to store any object in your collection. Storing object of wrong type (or even wrong value) is allowed to throw NotSupportedException. (Though, that's not as good as compilation error of course.) So there's nothing wrong in implementing IList for any ordered collection with indexed access. And List<T> implementing IList allows us to use it anywhere IList is required.

    However deriving IList<T> from IList would require every class implementing IList<T> to also implement all IList members and having to do that for collections that are never passed in place of IList would be a real pain. Developers don't like doing useless work.

  7. Néstor Sánchez a. says:

    I agree with Olivier, these confusing and rarely useful legacy interoperation features should be deprecated and removed.

    Particularly the non-generics components and that array covariance inconsistency.

  8. Gabe says:

    ArrayList may be a "legacy" class, but if StackOverflow is any indication plenty of people still use it. I estimate that roughly 1% of C# questions on SO involve ArrayList or HashTable. And that's just "new" code — you can imagine that there are plenty of large codebases using those classes that have no need to refactor.

  9. Simon Buchan says:

    I sometimes find myself dealing with reflection and System.Object collections, and I can't figure out if I really want to go through the trouble of List<object>, when logically it is no more useful than ArrayList.

    I have nothing to say about transitive closures of interfaces.

  10. Ferdinand Swaters says:

    I am doing a Shameless Change of Subject, Skip this if you don't appreciate that.

    The interface is probably the language construct that helps most in structuring large software systems that are constantly under the forces of change. They can make software structured but flexible, and much more testable.

    At first glance interfaces are simple. An interface is a promise, i tell my new programmers when i train them, no more than a promise that a class is going to implement something. Simple as that.

    At the same time, interfaces are almost never fully understood. And interface inheritance is the culprit.

    An interface should consist of a minimal group of methods (op properties) that are needed to implement some responsibility. Since it is minimal, every user of that interface will use all the methods. This is important. Usercode should not depend on interface members they do not use.

    And interface inheritance will violate exactly that: You build a bigger interface, and soon you find that no usercode exists that uses all the members.

    To see why this is bad, you should give it a go: Take one of your classes and implement IDictionary<string, int> on it.

    You will find youself writing implementations for methods that you know you are never going to call. The nongeneric IEnumerable, for one.

    If this happens in .Net code, be sure that it is much worse in the jungle overhere.

    So why does this happen? First of all, interfaces should be written from the using code point of view. The callsite, i believe is the word. And sometimes  you want a variable for an object that can do IFoo and IBar. IRead and IWrite. ILoad and ISave. Makes perfect sense.

    Interface inheritance gives you an opportunity to combine IFoo and IBar into a new Interface IFooBar. It is all you have. So Interface Inheritance is you hammer, and therefor your problem must be a nail. Wham. Problem crushed. Not solved, chrushed.

    What was needed, was a variable that was IFoo and IBar at the same time. Interface Inheritance created a new interface that implements IFoo and IBar. That is not the same. As a result, for every usefull combination of interfaces, you get a new bigger interface. And for that to be usefull, all candidate implementing classes must now implement the bigger interface, even when that does not make sense. We'll someday end up having to implement IEverything on every class.

    Now if we only had a construct where you could say thay you had an IFooBar that is the combination of IFoo and IBar, and any instance of a class implementing IFoo and IBar (but not IFooBar) could be assigned to an IFooBar variable…..

  11. Patrick Huizinga says:

    > The Silverlight version of the BCL does not have the non-generic collection types.

    Eric, when I look at the mscorlib from Silverlight (v., there's still an ArrayList present and List(T) also still implements IList. What did I miss?

  12. Andrew Sklyarevsky says:

    This might be a little bit of off-topic, but as you are on the collection interfaces, the following point may also be interesting.

    We frequently discuss with colleagues the way the ReadOnlyCollection<T> is implemented in .NET Framework and how to work around it. As it implements ICollection<T>, it provides all the modification methods, such as Add and Remove, although they fail at runtime. Of course, there is the IsReadOnly property that is supposed to be called before doing a modification on an instance of ICollection<T>; however, it may be argued that it would actually be better to provide yet another interface between IEnumerable<T> and ICollection<T>, perhaps an ICollectionReader, which would have Count and IsReadOnly properties, but would not have all the collection-modification methods. Another interface, e.g. IListReader, would add an indexer to the mix.

    Furthermore, there is a discussion on the Internet about the non-nullable types (…/i-want-non-nullable-types-in-c-4 ). It would also be extremely useful to have readonly non-nullable arrays, for example:

    public void A(readonly string![] messages) {

         messages[0] = "2-1-2"; // compile-time error, the array is marked as readonly

         if (messages[0] == null) {

                  …. // compile-time warning — there will never be null as the type is set as string!



    public readonly string![] GetNames() {

        // the callers of this method will be sure that it never returns null and all objects inside of the collection are also

        // checked at compile-time to be different from null.


    These are just thoughts, as there is no doubt that there are myriads of special cases that would pose significant problems if changes like these were to be introduced in the language. However, the rationale behind these thoughts is simple – in the enterprise solutions there is a lot of database querying methods (a data access layer that abstracts the system from an ORM), which shall usually return and accept only readonly collections. IEnumerable is not enough as it is unclear at the runtime — whether the IEnumerable represents a fetched collection, or a deferred execution plan.

  13. Olivier says:

    Patrick, ArrayList and Hashtable are actually internal to mscorlib in Silverlight (probably to avoid rewriting a lot of existing code). It's an implementation detail, so I'm totally fine with it. IList is still here though (but non-generic List is not).

    The reduced framework provides a nice excuse for breaking compatibility, which is good. But what could justify doing the same one day for full C#/.Net ?

  14. Bill P. Godfrey says:

    I'd be surprised if the modern ArrayList isn't just a subclass or wrapper of List<object>. No need to separately implement two classes that do almost the same thing.

  15. Pop.Catalin says:

    I think what the CLR actually lacks is "final" interface implementations. A way to specify that reimplementing an interface is forbidden to inheritors. It would certainly reduce the number of security critical classes that need to be sealed.

  16. There are many cases where interface inheritance would make sense, if a "default implementation" facility existed for interface methods (as in 99% of cases the implementation would be exactly the same). IEnumerator/IEnumerator<T> is one such example.

  17. Shuggy says:


    Such a system exists:

    void Frob<T>(T t)

       Where T : IFoo, IBar



    Hey presto there's you variable containing something known to implement both (known to the compiler that is)

    Since I got generics I haven't found too many occasions when this wasn't sufficient. More constraints on non interface related mechanisms like operators and the like, that would be nice though…

  18. Ferdinand Swaters says:


    I'm not sure i understand what you are doing, an interface is quite the opposite of a Generic, after all.

    Lets try. I need a class with an IFoo/IBar field:

    public class C<T>  where T:IFoo, IBar


          public T f;


    I instantiate it…how?

       var myC = new C<what goes here?> ();

    and assign f

        if  (MyLuckyDay) {

             myC.f = new SomeClassWithFooAndBar();


        else {

             myC.f = new TotallyDifferentClassWithFooAndBar();


  19. Bryan says:

    @Ferdinand at least with generic methods you can avoid the ILoad and ISave problem some because you can define your method to act on types that implement multiple interfaces without defining a new interface.

    For example you can declare the following

           public T MyFunction<T>(T input) where T : ILoad<T>, ISave<T>


    Or maybe it is something more like

           public U MyFunction<T, U>(T input) where T : ILoad<U>, ISave<U>


  20. Bryan says:

    @Ferdinand Sorry I did not look at the second page first, but I do not think I quite understand the problem you are trying to solve.

  21. David Nelson says:

    @Bill P. Godfrey,

    ArrayList and List<T> are not related in any way, because neither one could inherit from the other. ArrayList existed prior to List<T>, and changing its parent class would be a breaking change; and implementing List<T> by deriving from ArrayList would require boxing all stored objects when T is a value type, which would counteract the benefit of storing a list of value types using generics.

  22. David Nelson says:

    "…most of the time when you're passing an IList around, it is so the callee can get by-index access to the list, not so that it can add new items of arbitrary type."

    Which is precisely why IList should have been broken up into read-only and write-only interfaces, which IList could implement. Similarly for ICollection and IDictionary, and their generic equivalents. Why this was not done for the generic versions when the problem with the non-generic versions was already well known has always puzzled me.

  23. Alex Davies says:

    Slightly off-topic, but IList<> is one of my saddest points with C#. Ever since "Immutability in C" I've been striving for immutability where I can, but IList throws a real spanner in the works.

    Why-oh-why does IList not inherit from an "IReadOnlyList"? Why has this never been patched in between C# revisions? So many of my classes have to throw "Read only list" exception, when all I really wanted was an IEnumerable with indexing access/count.

    Having an IReadOnlyList just adds *so* much information to a function – you can see at a glance that you can't modify what it returns, or conversely – that *it won't modify what you pass it*. Wrapping an IList in a ReadOnlyCollection is not the same – it just doesn't cut it.

    I suppose it could be opening the way for an IReadOnlyDictionary, etc – perhaps something Eric and Co are trying to avoid – but come on, the advantages of an IReadOnlyList would be more than worth it. Why am I forced to implement just half the interface?

    -sad face-

  24. Alex Davies says:

    Not to mention that IReadOnlyList<> would be able to be covariant – how useful would that be!

  25. Shuggy says:


    Interfaces and generics are orthogonal, you may use either to constrain the set of possible things which may reside in a variable (or value)

    I too don't understand what you're getting at because no matter what you use to constrain what can be in a variable the problem of what actually goes in it remains. The whole point of having interfaces is to allow you the freedom of what goes in it. (indeed the freedom for the implementer of a piece of code to never actually know)

  26. cui peng fei says:

    Hi Mr Lippert:

    Would it be OK if I translate this article and post it on my blog?

    Of course I will provide the original post address and author.



  27. Harry says:

    As a side question, why is it that most collection interfaces have not been split into "command" and "query" interfaces? For example IDictionary is a mix of both queries (read only) and commands (write and sometimes read). It makes readability of code a lot worse since you cannot specify that you only need the query part of the interface. It also means you have to use a ReadOnlyDictionary (or ReadOnlyCollection) who implement the entire interface incl the command part, which by definition are implemented as throwing e.g. NotImplementedException. It seems extremely redundant and not the least confusing.

  28. VirtualBlackFox says:

    For all people wanting and IReadOnlyList<> there is a similar  proposal on connect that could be voted for…/add-an-iindexable-t-accessible-by-index-interface (Even if the comment in the issue about Count being slow is false as long as the enumeration also implement ICollection)

  29. I sympathise with the comments of David Nelson and Alex Davies re: IReadOnlyList<T>. And very glad to see from VirtualBlackFox's linked Connect issue that something like that may make it into the BCL soon.

    On the other hand, there would still be no requirement on implementations of the read-only interface to genuinely be immutable. Nor could such a requirement be meaningfully retrofitted to IList<T>, as it would break all existing code that sneakily mutates the object's fields when implementing getters and other read-only methods. Of course to do so can sometimes be very useful: a lazy file-backed list that reads its content from a file the first time you access it, and then caches the list in memory thereafter. It's logically readonly, but technically (internally) it mutates its contents once.

    This is one of the gotchas of const-correctness in C++. The const modifier can easily be "casted away" in the internals of a class, and so all the static checking may be rendered pointless if you're trying to rely on it to ensure immutability. We need the safety of guaranteed immutability, but we need the power to bend the rules to achieve performance. If C# 6 (or 7) can reconcile these needs without collapsing under its own complexity it will be quite an achievement.

Comments are closed.

Skip to main content