IndexedCollection

public class IndexedCollection<T> : IEnumerable<T> where T : class
    {
        int _count;
        int _freeCount;
        int[] _freeIndices;
        readonly bool _isRented;
        T[] _items;

        public IndexedCollection(int capacity = 64)
        {
            Capacity = capacity;
            if (capacity > 1024)
            {
                _items = ArrayPool<T>.Shared.Rent(capacity);
                _freeIndices = ArrayPool<int>.Shared.Rent(capacity);
                _isRented = true;
            }
            else
            {
                _items = new T[capacity];
                _freeIndices = new int[capacity];
            }

            _count = 0;
            _freeCount = 0;
        }

        public int Count => _count - _freeCount;

        public int Capacity { get; private set; }

        public int Add(T item)
        {
            int index;

            if (_freeCount > 0)
            {
                index = _freeIndices[--_freeCount];
                _items[index] = item;
            }
            else
            {
                if (_count == Capacity) Expand();

                index = _count++;
                _items[index] = item;
            }

            return index;
        }

        public T this[int index] => Get(index);

        public T Get(int index)
        {
            if (index < 0 || index >= _count) throw new ArgumentOutOfRangeException(nameof(index));
            return _items[index];
        }

        public bool TryGet(int index, out T item)
        {
            if (index >= 0 && index < _count)
            {
                item = _items[index];
                return item != null;
            }
            item = null;
            return false;
        }

        public void Remove(int index, bool compact = false)
        {
            if (index < 0 || index >= _count) throw new ArgumentOutOfRangeException(nameof(index));

            _items[index] = null;

            if (compact && index == _count - 1)
            {
                _count--;
                while (_count > 0 && _items[_count - 1] == null) _count--;
                _freeCount = Math.Max(0, _freeCount - (_count - index));
            }
            else
                _freeIndices[_freeCount++] = index;
        }

        public void Clear()
        {
            for (var i = 0; i < _count; i++) _items[i] = null;
            _count = 0;
            _freeCount = 0;
        }

        public IEnumerable<T> GetActiveItems()
        {
            for (var i = 0; i < _count; i++)
                if (_items[i] != null)
                    yield return _items[i];
        }

        void Expand()
        {
            var newCapacity = Capacity * 2;

            T[] newItems;
            int[] newFreeIndices;

            if (_isRented && newCapacity > 1024)
            {
                newItems = ArrayPool<T>.Shared.Rent(newCapacity);
                newFreeIndices = ArrayPool<int>.Shared.Rent(newCapacity);
                Array.Copy(_items, 0, newItems, 0, _count);
                Array.Copy(_freeIndices, 0, newFreeIndices, 0, _freeCount);
                ArrayPool<T>.Shared.Return(_items);
                ArrayPool<int>.Shared.Return(_freeIndices);
            }
            else
            {
                newItems = new T[newCapacity];
                newFreeIndices = new int[newCapacity];
                Array.Copy(_items, 0, newItems, 0, _count);
                Array.Copy(_freeIndices, 0, newFreeIndices, 0, _freeCount);
            }

            _items = newItems;
            _freeIndices = newFreeIndices;
            Capacity = newCapacity;
        }

        public void Dispose()
        {
            if (_isRented)
            {
                Array.Clear(_items, 0, _count);
                ArrayPool<T>.Shared.Return(_items);
                ArrayPool<int>.Shared.Return(_freeIndices);
            }

            _items = null;
            _freeIndices = null;
        }

        public IEnumerator<T> GetEnumerator() => GetActiveItems().GetEnumerator();

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }