IList<int> arr = new int[10];
 arr.Add(5);

IList<int> arr = new int[10];
if (!arr.IsReadOnly)
{
    arr.Add(5);
}

public interface IEnumerable<T>
{
    IEnumerator<T> GetEnumerator();
}

public interface ICollection<T> : IEnumerable<T>
{
    bool Contains(T item);
    bool CopyTo(T[] array, int arrayIndex);

    int Count {get;}
}

// Это ничего, что Clear Вместе с Add/Remove или ещё делить?
// Где обоснованная граница? Бывает же, что Add/Remove можно, а Clear - нельзя.
// А ещё бывает, что можно Add, но нельзя Remove.
public interface IMutableCollection<T> : ICollection<T>
{
    void Clear();
    void Add(T item);
    bool Remove(T item);
}

// Опять таки, всегда ли делать доступным IndexOf?
// Метод весьма сомнительный, в колелкции с неуникальными элементами вводит в заблуждение,
// лучше уж IList<int> IndicesOf(T item), но такой метод плох в коллекции с уникальными элементами.
public interface IList<T> : ICollection<T>
{
    int IndexOf(T item);

    T this[int index] { get; }
}

public interface IMutableAddRemoveList<T> : IList<T>, IMutableCollection<T>
{
    int Insert(int index, T item);
    bool RemoveAt(int index);
}

public interface IMutableModifyList<T> : IList<T>
{
    // Это полностью новое свойство, нельзя доопределить сеттер.
    T this[int index] { get; set; }
}

////////////////////////////////////////////////////////////////////////////////

// Реализация по умолчанию, как List<T>
public class MutableAddRemoveList<T> : IMutableAddRemoveList<T>
{
...
}

// Реализация по умолчанию, как List<T>
public class MutableModifyList<T> : IMutableModifyList<T>
{
...
}

// Реализация по умолчанию, как List<T>
// Copy+Paste их двух предыдущих классов.
public class MutableList<T> : IMutableAddRemoveList<T>, IMutableModifyList<T>
{
...
}

interface IEnumerable<T> : IEnumerable
{
...
}

class Array<T> : IEnumerable<T>
{
...
}

  interface IReadonlyCollection<T> : IEnumerable<T>
  {
  ...
  T[] ToArray();  // заместо CopyTo
  ...
  } 


  interface ICollection<T> : IReadonlyCollection<T>
  {
  ...
  } 

  interface IList<T> : ICollection<T>
  {
   ...
   ...
  }

class ReadOnlyCollection<T> : IReadonlyCollection<T> // и никаких IList
{
  T[] _items;
  
  ...
  public ReadOnlyCollection(IEnumerable<T> items)
  {
      // нынешняя ReadonlyCollection этого не делает и приходится вызывать Enumerable.ToList() самому или следить за геморроем
      Copy(items); 
  }
  ...
}

I>Он имеет ввиду книгу, в которой Рихтер выступил в основном комментатором и в которой авторы не раз посыпали голову пеплом из за дизайна первых версий дотнета

We also decided that arrays will return true from IsReadOnly, but will actually allow setting values using the indexer (which we are trying to fix in RTM as it does not work today).

interface IList<T>
{
  члены для чтения данных
}
interface IMutableList<T> : IList<T>
{
  члены для изменения данных
}

ICollection<T>.Add Method
Adds an item to the ICollection<T>.

Exceptions:
NotSupportedException
The ICollection<T> is read-only.

А>IList<int> arr = new int[10];
А>arr.Add(5);

override void M1() {
  throw new NotSupportedException();
}

override void M2() {
  throw new NotImplementedException();
}

QL>IList<int> arr = new int[10];
QL>if (!arr.IsReadOnly)
QL>{
QL>    arr.Add(5);
QL>}
QL>

public bool get_IsReadOnly()
{
    return false;
}

interface A
{
    bool IsReadonly { get; }
}

class B : A
{
    public bool IsReadonly
    {
        get { return false; }
    }

    bool A.IsReadonly
    {
        get { return true; }
    }
}

[ComVisible(true)]
public interface IList : ICollection, IEnumerable
{
    // Methods
    int Add(object value);
    void Clear();
    bool Contains(object value);
    int IndexOf(object value);
    void Insert(int index, object value);
    void Remove(object value);
    void RemoveAt(int index);

    // Properties
    bool IsFixedSize { get; }
    bool IsReadOnly { get; }
    object this[int index] { get; set; }
}

var arr = new [] {1, 2};

((IList<int>)arr).IsReadOnly.Dump(); // True
((IList)arr).IsReadOnly.Dump();      // False

S>var arr = new [] {1, 2};

S>((IList<int>)arr).IsReadOnly.Dump(); // True
S>((IList)arr).IsReadOnly.Dump();      // False
S>

dynamic ad = arr;
bool r = ad.IsReadOnly;
r.Dump(); // False

S>dynamic ad = arr;
S>bool r = ad.IsReadOnly;
S>r.Dump(); // False
S>

With the new dynamic keyword in C# 4.0, a method call on a dynamic object is resolved at runtime. Is is therefore impossible to access the explicitly implemented member on a dynamic object.

void SetValueIfCan(IList<T> list, int index, T value)
{
    // как узнать, можно ли вызывать сеттер?
    list[0] = value;
}

_FR>Ну ёлки-палки. Неужели так сложно погуглить и почитать о том, что означают свойства базовых интерфейсов коллекций И как можно о чём-то говорить, не имея таких примитивных знаний?

A collection that is read-only does not allow the addition, removal, or modification of elements after the collection is created.

Что-то мне подсказывает, что IsFixedSize тут не поможет.

Remarks

A collection that is read-only does not allow the addition, removal, or modification of elements after the collection is created.

We decided that there are really not that many fixed size data structures that are not read only. In fact, we only have one – the array. We think that having a property on a very commonly implemented interface that is useful in only one case is not the right thing to do. So we decided to remove IsFixedSize.