Why does IList<T> implement IEnumerable<T> and ICollection<T> while ICollection<T> itself implements IEnumerable<T> [duplicate]

Question

Why is IList defined like this?

public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable

public interface ICollection<T> : IEnumerable<T>, IEnumerable

public interface IEnumerable<T> : IEnumerable

Couldn't it just be

public interface IList<T> : ICollection<T>

So, to test I created these interfaces, just to be sure if that works!

public interface IOne
{
    string One();
}

public interface ITwo : IOne
{
    string Two();
}

public interface IThree : ITwo, IOne
{
    string Three();
}

While its perfectly fine, Resharper complains about "Redundant interfaces".

Any ideas why Microsoft went on with this implementation?

Ultraism

Where were you seeing the duplication? (What's your source for the source of IList<T>, so to speak?) – Zenaidazenana

@JonSkeet: Just pressed F12 / Go to definition on the IList<T>. It showed me the method signature from the assembly metadata. Just viewed it from there. – Ultraism

As an aside, it's helpful to only use backticks for things which are genuinely code. (I've edited the extra bits out of your post) – Zenaidazenana

Just in case you were wondering, I've deleted my answer as I believe it to be incorrect - I suspect that the code really was like that at the point at which it was compiled. I can't really speculate why... personal preference of whoever wrote the interface, I guess. – Zenaidazenana

See sources: IList<T> does not include IEnumerable<T> or IEnumerable in base interfaces list. Same goes for ICollection<T>, it does not include IEnumerable. – Epicure

Answer 1

Interface "inheritance" is one of the most misleading terms in software engineering. You didn't inherit squat, interfaces don't have any implementation so you can't inherit it either. You only inherit the demand to implement the methods.

Adding to that demand by repeating the interface declaration doesn't change anything, you already had the demand and adding an extra demand makes no difference whatsoever. So since it doesn't matter, Microsoft helpfully just repeats the interface so you can tell in one fell swoop what interfaces are implemented by, say, List. You don't have to drill down to the interface declaration to see that List implements IEnumerable as well. It is a self-documenting coding style, recommended.

Do beware of the other side of this medal, two distinct interfaces with the exact same method can be implemented with just a single method implementation. While that is often useful, sometimes that is not what you want. Say, ICowboy and IPainter, they both have a Draw() method. It should not do the same thing :) You then have to fall back to an explicit implementation to avoid the ambiguity.

Addressing the Resharper complaint, it isn't very helpful of course. Resharper tends to assume the worst from a programmer. But if you want to shut it up then you need to remove IOne from the IThree inheritance list, it is redundant. Same thing for the class that implements IThree, you'd also need to remove ITwo and IOne from the inheritance list. Or just turn off the warning.

Buke

good point => recommend self documenting style. – Pryce

Thanks @Hans. In addition, Eric Lippert explains this beautifully here http://blogs.msdn.com/b/ericlippert/archive/2011/04/04/so-many-interfaces.aspx#comments – Ultraism