Home » c# » Why array implements IList?

Why array implements IList?

Posted by: admin November 18, 2017 Leave a comment


See the definition of System.Array class

public abstract class Array : IList, ...

Theoretically, I should be able to write this bit and be happy

int[] list = new int[] {};
IList iList = (IList)list;

I also should be able to call any method from the iList

 ilist.Add(1); //exception here

My question is not why I get an exception, but rather why Array implements IList?


Because an array allows fast access by index, and IList/IList<T> is are the only collection interfaces that support this. So perhaps your real question is “Why is there no interface for constant collections with indexers?” And to that I have no answer.

There are no readonly interfaces for collections either. And I’m missing those even more than a constant sized with indexers interface.

IMO there should be several more (generic) collection interfaces depending on the features of a collection. And the names should have been different too, List for something with an indexer is really stupid IMO.

  • Just Enumeration IEnumerable<T>
  • Readonly but no indexer (.Count, .Contains,…)
  • Resizable but no indexer, i.e. set like (Add, Remove,…) current ICollection<T>
  • Readonly with indexer (indexer, indexof,…)
  • Constant size with indexer (indexer with a setter)
  • Variable size with indexer (Insert,…) current IList<T>

I think the current collection interfaces are bad design. But since they have properties telling you which methods are valid(and this is part of the contract of these methods) it doesn’t break the substitution principle.


The remarks section of the documentation for IList says

IList is a descendant of the
ICollection interface and is the base
interface of all non-generic lists.
IList implementations fall into three
categories: read-only, fixed-size, and
. A read-only IList
cannot be modified. A fixed-size IList
does not allow the addition or removal
of elements, but it allows the
modification of existing elements. A
variable-size IList allows the
addition, removal, and modification of

Obviously arrays fall into the fixed-size category, so by the defition of the interface it makes sense.


Because not all ILists are mutable (see IList.IsFixedSize and IList.IsReadOnly), and arrays certainly behave like fixed-size lists.

If your question is really “why does it implement a non-generic interface”, then the answer is that these were around before generics came along.


It’s a legacy that we have from the times when it wasn’t clear how do deal with read only collections and whether or not Array is read only. There are IsFixedSize and IsReadOnly flags in the IList interface. IsReadOnly flag means that collection can’t be changed at all and IsFixedSize means that collection does allow modification, but not adding or removal of items.

At the time of .Net 4.5 it was clear that some “intermediate” interfaces are required to work with read only collections, so IReadOnlyCollection<T> and IReadOnlyList<T> were introduces.

Here is a great blog post describing the details: Read only collections in .NET


Definition of IList interface is “Represents a non-generic collection of objects that can be individually accessed by index.”. Array completely satisfies this definition, so must implement the interface.
Exception when calling Add() method is “System.NotSupportedException: Collection was of a fixed size” and occurred because array can not increase its capacity dynamically. Its capacity is defined during creation of array object.

Leave a Reply

Your email address will not be published. Required fields are marked *