.net - 为什么 ReadOnlyCollection 不是 ReadOnlyList？

Question

我以为IEnumerable事物是可以迭代的对象。
如果他们也是ICollection你知道里面有多少元素。
如果它们是偶数 IList您可以从特定索引中获取包含对象。

一个 ReadOnlyCollection<T> 实现IList<T> 。所以不会ReadOnlyList<T>起一个更好的名字。

有没有真正的 ReadOnlyCollection<T>在框架中？
(所以我不需要 IList 来创建这样的只读包装器)

Answer 1

如ReadOnlyCollection<T>只是 IList<T> 的包装。不允许修改列表，应该很容易为 ICollection<T> 生成类似的包装器:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading;

class MyReadOnlyCollection<T> : ICollection<T>, IEnumerable<T>, ICollection, IEnumerable
{
    private ICollection<T> _collection;
    private object _syncRoot;

    public MyReadOnlyCollection(ICollection<T> collection)
    {
        _collection = collection;
    }


    public void Add(T item)
    {
        throw new NotSupportedException("Trying to modify a read-only collection.");
    }

    public void Clear()
    {
        throw new NotSupportedException("Trying to modify a read-only collection.");
    }

    public bool Contains(T item)
    {
        return _collection.Contains(item);
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        _collection.CopyTo(array, arrayIndex);
    }

    public int Count
    {
        get { return _collection.Count; }
    }

    public bool IsReadOnly
    {
        get { return true; }
    }

    public bool Remove(T item)
    {
        throw new NotSupportedException("Trying to modify a read-only collection.");
    }

    public IEnumerator<T> GetEnumerator()
    {
        return _collection.GetEnumerator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return ((ICollection)_collection).GetEnumerator();
    }

    public void CopyTo(Array array, int index)
    {
        ((ICollection)_collection).CopyTo(array, index);
    }

    public bool IsSynchronized
    {
        get { return false; }
    }

    public object SyncRoot
    {
        get
        {
            if (_syncRoot == null)
            {
                ICollection list = _collection as ICollection;
                if (list != null)
                {
                    _syncRoot = list.SyncRoot;
                }
                else
                {
                    Interlocked.CompareExchange(ref _syncRoot, new object(), null);
                }
            }
            return _syncRoot;
        }
    }
}