ArrayWrapper.cs

public sealed class ArrayWrapper<T> : IReadOnlyDictionary<int, T>
{
    private readonly T[] arr;

    public ArrayWrapper(T[] arr)
    {
        if (arr == null)
        {
            throw new ArgumentNullException("arr");
        }

        this.arr = arr;
    }

    public int Count { get { return this.arr.Length; } }

    public T this[int key] { get { return this.arr[key]; } }

    public IEnumerable<int> Keys { get { return Enumerable.Range(0, this.arr.Length); } }

    public IEnumerable<T> Values { get { return this.arr.Skip(0); } }

    public IEnumerator<KeyValuePair<int, T>> GetEnumerator()
    {
        return new Enumerator(this.arr);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }

    public bool ContainsKey(int key)
    {
        return 0 <= key &&
               key < this.arr.Length;
    }

    public bool TryGetValue(int key, out T value)
    {
        if (this.ContainsKey(key))
        {
            value = this.arr[key];
            return true;
        }

        value = default(T);
        return false;
    }

    private sealed class Enumerator : IEnumerator<KeyValuePair<int, T>>
    {
        private readonly T[] arr;
        private int idx = -1;

        public Enumerator(T[] arr)
        {
            this.arr = arr;
        }

        public KeyValuePair<int, T> Current { get { return new KeyValuePair<int, T>(this.idx, this.arr[idx]); } }

        object IEnumerator.Current { get { return this.Current; } }

        public bool MoveNext()
        {
            return (++this.idx) < this.arr.Length;
        }

        public void Reset()
        {
            this.idx = -1;
        }

        void IDisposable.Dispose()
        {
        }
    }
}