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

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

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.

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).

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.

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

interface IList2
{
  this[int index] { get; }
}

interface IMutableList2
{
  this[int index] { get; set; }
}

class MyLis2 : IMutableList2, IList2 { ... }

...

IList2 lst = new MyLis2();

IMutableList2 mutableLst = (IMutableList2)lst;
...
// или с проверкой

var mutableLst = lst as IMutableList2;

if (mutableLst != null)
  ...