Array.cs

using System;
using System.Collections;
using System.Collections.Generic;
 
namespace Waher.Content.Asn1
{
    public class Array<T> : IEnumerable<T>
    {
        private readonly T[] elements;
 
        public static implicit operator T[](Array<T> A) => A.elements;
 
        public static implicit operator Array(Array<T> A) => A.elements;
 
        public static implicit operator Array<T>(T[] A) => new Array<T>(A);
 
        public Array(int Length)
        {
            if (Length < 0)
                throw new ArgumentException("Length must be non-negative.", nameof(Length));
        }
 
        public Array(T[] Elements)
        {
            this.elements = Elements;
        }
 
        public int Rank => 1;
 
        public int Length => this.elements.Length;
 
        public T[] Elements => this.elements;
 
        public T this[int Index]
        {
            get => this.elements[Index];
            set => this.elements[Index] = value;
        }
 
        public object Clone()
        {
            return new Array<T>((T[])this.elements.Clone());
        }
 
        public void CopyTo(Array<T> array, int index)
        {
            this.elements.CopyTo(array.elements, index);
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.elements.GetEnumerator();
        }
 
        public IEnumerator<T> GetEnumerator()
        {
            return new ElementEnumerator(this.elements.GetEnumerator());
        }
 
        private class ElementEnumerator : IEnumerator<T>
        {
            private readonly IEnumerator e;
 
            public ElementEnumerator(IEnumerator Enumerator)
            {
                this.e = Enumerator;
            }
 
            public T Current => (T)this.e.Current;
 
            object IEnumerator.Current => this.e.Current;
 
            public void Dispose()
            {
            }
 
            public bool MoveNext()
            {
                return this.e.MoveNext();
            }
 
            public void Reset()
            {
                this.e.Reset();
            }
        }
 
        public int GetLength(int dimension)
        {
            return this.elements.GetLength(dimension);
        }
 
        public int GetLowerBound(int dimension)
        {
            return this.elements.GetLowerBound(dimension);
        }
 
        public int GetUpperBound(int dimension)
        {
            return this.elements.GetUpperBound(dimension);
        }
 
        public object GetValue(int index)
        {
            return this.elements.GetValue(index);
        }
 
        public object GetValue(params int[] indices)
        {
            return this.elements.GetValue(indices);
        }
 
        public void Initialize()
        {
            this.elements.Initialize();
        }
 
        public void SetValue(object value, params int[] indices)
        {
            this.elements.SetValue(value, indices);
        }
 
        public void SetValue(object value, int index)
        {
            this.elements.SetValue(value, index);
        }
    }
}