ReadOnlyCollection.cs

Go to the documentation of this file.

using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
 
namespace System.Collections.ObjectModel;
 
[Serializable]
[DebuggerTypeProxy(typeof(ICollectionDebugView<>))]
[DebuggerDisplay("Count = {Count}")]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public class ReadOnlyCollection<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T>
{
    private readonly IList<T> list;
 
    public int Count => list.Count;
 
    public T this[int index] => list[index];
 
    protected IList<T> Items => list;
 
    bool ICollection<T>.IsReadOnly => true;
 
    T IList<T>.this[int index]
    {
        get
        {
            return list[index];
        }
        set
        {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
        }
    }
    T IList<T>.this[int index] {…};
 
    bool ICollection.IsSynchronized => false;
 
    object ICollection.SyncRoot
    {
        get
        {
            if (!(list is ICollection collection))
            {
                return this;
            }
            return collection.SyncRoot;
        }
    }
    object ICollection.SyncRoot {…};
 
    bool IList.IsFixedSize => true;
 
    bool IList.IsReadOnly => true;
 
    object? IList.this[int index]
    {
        get
        {
            return list[index];
        }
        set
        {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
        }
    }
    object? IList.this[int index] {…};
 
    public ReadOnlyCollection(IList<T> list)
    {
        if (list == null)
        {
            ThrowHelper.ThrowArgumentNullException(ExceptionArgument.list);
        }
        this.list = list;
    }
    public ReadOnlyCollection(IList<T> list) {…}
 
    public bool Contains(T value)
    {
        return list.Contains(value);
    }
    public bool Contains(T value) {…}
 
    public void CopyTo(T[] array, int index)
    {
        list.CopyTo(array, index);
    }
    public void CopyTo(T[] array, int index) {…}
 
    public IEnumerator<T> GetEnumerator()
    {
        return list.GetEnumerator();
    }
    public IEnumerator<T> GetEnumerator() {…}
 
    public int IndexOf(T value)
    {
        return list.IndexOf(value);
    }
    public int IndexOf(T value) {…}
 
    void ICollection<T>.Add(T value)
    {
        ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
    }
    void ICollection<T>.Add(T value) {…}
 
    void ICollection<T>.Clear()
    {
        ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
    }
    void ICollection<T>.Clear() {…}
 
    void IList<T>.Insert(int index, T value)
    {
        ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
    }
    void IList<T>.Insert(int index, T value) {…}
 
    bool ICollection<T>.Remove(T value)
    {
        ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
        return false;
    }
    bool ICollection<T>.Remove(T value) {…}
 
    void IList<T>.RemoveAt(int index)
    {
        ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
    }
    void IList<T>.RemoveAt(int index) {…}
 
    IEnumerator IEnumerable.GetEnumerator()
    {
        return ((IEnumerable)list).GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator() {…}
 
    void ICollection.CopyTo(Array array, int index)
    {
        if (array == null)
        {
            ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
        }
        if (array.Rank != 1)
        {
            ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
        }
        if (array.GetLowerBound(0) != 0)
        {
            ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
        }
        if (index < 0)
        {
            ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
        }
        if (array.Length - index < Count)
        {
            ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
        }
        if (array is T[] array2)
        {
            list.CopyTo(array2, index);
            return;
        }
        Type elementType = array.GetType().GetElementType();
        Type typeFromHandle = typeof(T);
        if (!elementType.IsAssignableFrom(typeFromHandle) && !typeFromHandle.IsAssignableFrom(elementType))
        {
            ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
        }
        object[] array3 = array as object[];
        if (array3 == null)
        {
            ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
        }
        int count = list.Count;
        try
        {
            for (int i = 0; i < count; i++)
            {
                array3[index++] = list[i];
            }
        }
        catch (ArrayTypeMismatchException)
        {
            ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
        }
    }
    void ICollection.CopyTo(Array array, int index) {…}
 
    int IList.Add(object value)
    {
        ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
        return -1;
    }
    int IList.Add(object value) {…}
 
    void IList.Clear()
    {
        ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
    }
    void IList.Clear() {…}
 
    private static bool IsCompatibleObject(object value)
    {
        if (!(value is T))
        {
            if (value == null)
            {
                return default(T) == null;
            }
            return false;
        }
        return true;
    }
    private static bool IsCompatibleObject(object value) {…}
 
    bool IList.Contains(object value)
    {
        if (IsCompatibleObject(value))
        {
            return Contains((T)value);
        }
        return false;
    }
    bool IList.Contains(object value) {…}
 
    int IList.IndexOf(object value)
    {
        if (IsCompatibleObject(value))
        {
            return IndexOf((T)value);
        }
        return -1;
    }
    int IList.IndexOf(object value) {…}
 
    void IList.Insert(int index, object value)
    {
        ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
    }
    void IList.Insert(int index, object value) {…}
 
    void IList.Remove(object value)
    {
        ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
    }
    void IList.Remove(object value) {…}
 
    void IList.RemoveAt(int index)
    {
        ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
    }
    void IList.RemoveAt(int index) {…}
}
public class ReadOnlyCollection<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T> {…};