DebuggerTypeProxy не работает

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
 
namespace PersistentStack
{
    /// <summary>
    /// Персистентный стек.
    /// </summary>
    /// <typeparam name="T">Тип элементов.</typeparam>
    [DebuggerTypeProxy(typeof(CollectionProxy<>))]
    [DebuggerDisplay("Count = {Count}")]
    [Serializable()]
    public class PersistentStack<T> : IEnumerable<T>, ICollection, IReadOnlyCollection<T>, IReadOnlyPersistentColletion<PersistentStack<T>.Node>
    {
        private List<Node> heads = new List<Node>();
 
        private void ThrowIfEmpty()
        {
            if (Count == 0)
                throw new InvalidOperationException($"Свойство {nameof(Count)} было равно {Count}.");
        }
 
        private static void ThrowIfNull<TObject>(TObject target, string message)
        {
            if (target == null)
                throw new ArgumentNullException(message);
        }
 
        private void ThrowIfInvalidArrayRange(Array target, int index)
        {
            if (target == null)
                throw new ArgumentNullException(nameof(target));
            if (index < 0 || index >= target.Length)
                throw new IndexOutOfRangeException(nameof(index));
            if (Count > target.Length - index)
                throw new ArgumentOutOfRangeException(nameof(index));
        }
 
        private void InternalCopyTo(Array target, int index)
        {
            Node current = Head;
            while (current != null)
            {
                target.SetValue(current.Value, index);
                current = current.Next;
                index++;
            }
        }
 
        /// <summary>
        /// Узел.
        /// </summary>
        public class Node
        {
            /// <summary>
            /// Значение.
            /// </summary>
            public T Value { get; internal set; }
 
            /// <summary>
            /// Значение.
            /// </summary>
            public Node Next { get; internal set; }
 
            public Node(T value, Node next)
            {
                Value = value;
                Next = next;
            }
 
            /// <summary>
            /// Возвращает строковое представление объекта.
            /// </summary>
            /// <returns>Строковое представление объекта.</returns>
            public override string ToString()
            {
                return Value.ToString();
            }
        }
 
        /// <summary>
        /// Получает версию с указанным индексом.
        /// </summary>
        /// <param name="index">Индекс версии.</param>
        /// <exception cref="IndexOutOfRangeException">Выбрасывается, если индекс лежит вне допустимого диапазона.</exception>
        /// <returns>Версия.</returns>
        public Node this[int index]
        {
            get
            {
                if (index < 0 || index >= heads.Count)
                    throw new IndexOutOfRangeException(nameof(index));
                return heads[index];
            }
        }
 
        /// <summary>
        /// Количество элементов коллекции.
        /// </summary>
        public int Count { get; private set; }
 
        /// <summary>
        /// Объект синхронизации.
        /// </summary>
        public object SyncRoot { get; } = new object();
 
        /// <summary>
        /// Указывает является ли коллекция синхронизированной.
        /// </summary>
        public bool IsSynchronized => false;
 
        /// <summary>
        /// Количество версий.
        /// </summary>
        public int VersionsCount => heads.Count;
 
        /// <summary>
        /// Голова стека.
        /// </summary>
        public Node Head => heads[heads.Count - 1];
 
        /// <summary>
        /// Создаёт персистентный стек из указанной коллекции.
        /// </summary>
        /// <param name="sequence">Коллекция.</param>
        /// <exception cref="ArgumentNullException">Выбрасывается, если коллекция была null.</exception>
        public PersistentStack(IEnumerable<T> sequence)
        {
            if (sequence == null)
                throw new ArgumentNullException(nameof(sequence));
            heads.Add(null);
            foreach (var item in sequence)
                Push(item);
        }
 
        /// <summary>
        /// Создаёт пустой персистентный стек.
        /// </summary>
        public PersistentStack()
        {
            heads.Add(null);
        }
 
        /// <summary>
        /// Возвращает перечислитель коллекции.
        /// </summary>
        /// <returns>Перечислитель.</returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
 
        /// <summary>
        /// Возвращает перечислитель коллекции.
        /// </summary>
        /// <returns>Перечислитель.</returns>
        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return new Enumerator(this);
        }
 
        /// <summary>
        /// Возвращает перечислитель коллекции.
        /// </summary>
        /// <returns>Перечислитель.</returns>
        public Enumerator GetEnumerator()
        {
            return new Enumerator(this);
        }
 
        /// <summary>
        /// Копирует часть коллекции, начиная с указанного индекса в массив.
        /// </summary>
        /// <param name="target">Целевой массив.</param>
        /// <param name="index">Индекс.</param>
        /// <exception cref="ArgumentOutOfRangeException">Выбрасывается, если ранг массива не был равен 1.</exception>
        void ICollection.CopyTo(Array target, int index)
        {
            ThrowIfInvalidArrayRange(target, index);
            if (target.Rank != 1)
                throw new ArgumentOutOfRangeException(nameof(target.Rank));
            InternalCopyTo(target, index);
        }
 
        /// <summary>
        /// Копирует часть коллекции, начиная с указанного индекса в массив.
        /// </summary>
        /// <param name="target">Целевой массив.</param>
        /// <param name="index">Индекс.</param>
        public void CopyTo(T[] target, int index)
        {
            ThrowIfInvalidArrayRange(target, index);
            InternalCopyTo(target, index);
        }
 
        /// <summary>
        /// Добавляет элемент в стек.
        /// </summary>
        /// <param name="item">Добавляемый элемент.</param>
        public void Push(T item)
        {
            int lastIndex = heads.Count - 1;
            heads.Add(heads[lastIndex++]);
            heads[lastIndex] = new Node(item, heads[lastIndex]);
            Count++;
        }
 
        /// <summary>
        /// Удаляет элемент из стека и возвращает его.
        /// </summary>
        public T Pop()
        {
            ThrowIfEmpty();
            int lastIndex = heads.Count - 1;
            heads.Add(heads[lastIndex++]);
            T result = heads[lastIndex].Value;
            heads[lastIndex] = heads[lastIndex].Next;
            Count--;
            return result;
        }
 
        /// <summary>
        /// Возвращает элемент на вершине стека.
        /// </summary>
        /// <returns>Элемент на вершине стека.</returns>
        public T Peek()
        {
            ThrowIfEmpty();
            return heads[heads.Count - 1].Value;
        }
 
        /// <summary>
        /// Очищает коллекцию.
        /// </summary>
        public void Clear()
        {
            ThrowIfEmpty();
            int lastIndex = heads.Count - 1;
            heads.Add(heads[lastIndex++]);
            heads[lastIndex] = null;
            Count = 0;
        }
 
        /// <summary>
        /// Перечислитель.
        /// </summary>
        public struct Enumerator : IEnumerator<T>
        {
            private PersistentStack<T> source;
            private Node current;
            private int index;
 
            /// <summary>
            /// Текущий элемент.
            /// </summary>
            object IEnumerator.Current => Current;
 
            /// <summary>
            /// Текущий элемент.
            /// </summary>
            public T Current => current.Value;
 
            /// <summary>
            /// Создаёт перечислитель, связанный с персистентным стеком.
            /// </summary>
            /// <param name="source">Персистентный стек.</param>
            public Enumerator(PersistentStack<T> source) : this()
            {
                ThrowIfNull(source, nameof(source));
                this.source = source;
                index = -1;
            }
 
            /// <summary>
            /// Сдвигает перечислитель на единицу и возвращает значение, указывающее возможно ли движение дальше.
            /// </summary>
            /// <returns>True, если движение дальше возможно, иначе False</returns>
            public bool MoveNext()
            {
                if (index == -1)
                    current = source.Head;
                else
                    current = current.Next;
                return ++index < source.Count;
            }
 
            /// <summary>
            /// Переустанавливает перечислитель в позицию перед первым элементом.
            /// </summary>
            public void Reset()
            {
                index = -1;
            }
 
            /// <summary>
            /// Высвобождает неуправляемые ресурсы объекта.
            /// </summary>
            public void Dispose()
            {
            }
        }
    }
}