C# Big Stack Class Generic Arrays Over 2GB

BigStack.cs

[DebuggerTypeProxy(typeof(HashSetDebugViewInt<>))]
    [DebuggerDisplay("Count = {Count}")]
    [Serializable]
    public class BigStack<T> : IEnumerable<T>
    {
        public BigArray<T> _array;
        public BigStack() : this(BigArray<T>.Granularity)
        {
        }
        public BigStack(ulong capacity)
        {
            _array = new BigArray<T>(capacity);
            Count  = 0;
        }
        public BigStack(ICollection col)
        {
            if(col != null)
            {
                _array = new BigArray<T>((ulong) col.Count);
                Count  = 0;
                var en = col.GetEnumerator();
                while(en.MoveNext())
                    Push((T) en.Current);
            }
        }
        public BigStack(IEnumerable<T> col)
        {
            if(col != null)
            {
                _array = new BigArray<T>(BigArray<T>.Granularity);
                Count  = 0;
                using(var en = col.GetEnumerator())
                {
                    while(en.MoveNext())
                        Push(en.Current);
                }
            }
        }
        public ulong Count{get; private set;}
        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return new Enumerator(this);
        }
        IEnumerator IEnumerable.GetEnumerator()
        {
            return new Enumerator(this);
        }
        public void Clear()
        {
            _array.Clear();
            Count = 0;
        }
        public bool Contains(T item)
        {
            var size             = Count;
            var equalityComparer = new BigComparer<T>();
            while(size-- > 0)
                if(item == null)
                {
                    if(_array[size] == null)
                        return true;
                }
                else
                {
                    if(_array[size] != null && equalityComparer.Equals(_array[size], item))
                        return true;
                }
            return false;
        }
        public T Peek()
        {
            return _array[Count - 1];
        }
        public T Pop()
        {
            Count--;
            var TVal = _array[Count];
            _array[Count] = default;
            return TVal;
        }
        public void Push(T item)
        {
            _array[Count++] = item;
        }
        public BigArray<T> ToArray()
        {
            var ta = new BigArray<T>(Count);
            for(var i = 0ul; i < Count; ++i)
                ta[i] = _array[Count - i - 1];
            return ta;
        }
        [Serializable]
        public struct Enumerator : IEnumerator<T>
        {
            private readonly BigStack<T> _stack;
            private          ulong       _index;
            public           T           Current {get; private set;}
            object IEnumerator.          Current => Current;
            internal Enumerator(BigStack<T> stack)
            {
                _stack  = stack;
                _index  = ulong.MaxValue;
                Current = default;
            }
            public void Dispose()
            {
                _index = ulong.MaxValue - 1;
            }
            public bool MoveNext()
            {
                if(_index == ulong.MaxValue)
                {
                    _index = _stack.Count - 1;
                    if(_index < ulong.MaxValue - 1)
                        Current = _stack._array[_index];
                    return _index < ulong.MaxValue - 1;
                }
                if(_index == ulong.MaxValue - 1)
                    return false;
                _index--;
                Current = !(_index < ulong.MaxValue - 1) ? default : _stack._array[_index];
                return _index < ulong.MaxValue - 1;
            }
            void IEnumerator.Reset()
            {
                _index  = ulong.MaxValue;
                Current = default;
            }
        }
    }