Действие атрибута Serializable распространяется на вложенные типы?

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
 
namespace SortedLinkedList
{
    /// <summary>
    /// Отсортированный односвязный список.
    /// </summary>
    /// <typeparam name="T">Тип элементов.</typeparam>
    [DebuggerDisplay("Count = {Count}")]
    [Serializable()]
    public class SortedLinkedList<T> : IEnumerable<T>, ICollection<T>, IReadOnlyCollection<T>
    {
        private static void ThrowIfNull<TObject>(TObject target, string message)
        {
            if (target == null)
                throw new ArgumentNullException(message);
        }
 
        /// <summary>
        /// Тип узла.
        /// </summary>
        public class Node
        {
            /// <summary>
            /// Значение.
            /// </summary>
            public T Value { get; }
 
            /// <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>
        public int Count { get; private set; }
 
        /// <summary>
        /// Указывает является ли коллекция readonly-коллекцией.
        /// </summary>
        public bool IsReadOnly => false;
 
        /// <summary>
        /// Первый элемент отсортированного списка.
        /// </summary>
        public Node Head { get; private set; }
 
        /// <summary>
        /// Компаратор.
        /// </summary>
        public IComparer<T> Comparer { get; }
 
        /// <summary>
        /// Создаёт отсортированный по неубыванию список из указанной коллекции с использованием указанного компаратора.
        /// </summary>
        /// <param name="sequence">Коллекция.</param>
        /// <param name="comparer">Компаратор.</param>
        public SortedLinkedList(IEnumerable<T> sequence, IComparer<T> comparer)
        {
            ThrowIfNull(sequence, nameof(sequence));
            ThrowIfNull(comparer, nameof(comparer));
            Comparer = comparer;
            foreach (var item in sequence)
                Add(item);
        }
 
        /// <summary>
        /// Создаёт отсортированный по неубыванию список из указанной коллекции с использованием компаратора по умолчанию.
        /// </summary>
        /// <param name="sequence">Коллекция.</param>
        public SortedLinkedList(IEnumerable<T> sequence) : this(sequence, Comparer<T>.Default)
        {
        }
 
        /// <summary>
        /// Создаёт пустой отсортированный по неубыванию список с использованием указанного компаратора.
        /// </summary>
        /// <param name="comparer">Компаратор.</param>
        public SortedLinkedList(IComparer<T> comparer)
        {
            ThrowIfNull(comparer, nameof(comparer));
            Comparer = comparer;
        }
 
        /// <summary>
        /// Создаёт пустой отсортированный по неубыванию список с использованием компаратора по умолчанию.
        /// </summary>
        public SortedLinkedList() : this(Comparer<T>.Default)
        {
        }
 
        /// <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="item">Добавляемое значение.</param>
        public void Add(T item)
        {
            if (Count == 0 || Comparer.Compare(item, Head.Value) == -1)
                Head = new Node(item, Head);
            else
            {
                Node current = Head;
                while (current.Next != null && Comparer.Compare(item, current.Next.Value) >= 0)
                    current = current.Next;
                current.Next = new Node(item, current.Next);
            }
            Count++;
        }
 
        /// <summary>
        /// Очищает коллекцию.
        /// </summary>
        public void Clear()
        {
            Head = null;
            Count = 0;
        }
 
        /// <summary>
        /// Указывает присутствует ли указанный элемент в коллекции.
        /// </summary>
        /// <param name="item">Искомый элемент.</param>
        /// <returns>True, если искомый элемент в коллекции, иначе False.</returns>
        public bool Contains(T item)
        {
            Node current = Head;
            while (current != null && Comparer.Compare(item, current.Value) != 0)
                current = current.Next;
            return current != null;
        }
 
        /// <summary>
        /// Копирует часть коллекции, начиная с указанного индекса в массив.
        /// </summary>
        /// <param name="target">Целевой массив.</param>
        /// <param name="index">Индекс.</param>
        /// <exception cref="ArgumentNullException">Выбрасывается, если массив равен null.</exception>
        /// <exception cref="IndexOutOfRangeException">Выбрасывается, если индекс находится вне допустимого диапазона.</exception>
        /// <exception cref="ArgumentOutOfRangeException">Выбрасывается, если размер массива меньше размера копируемого отсортированного списка.</exception>
        public void CopyTo(T[] 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));
 
            Node current = Head;
            while (current != null)
            {
                target[index] = current.Value;
                current = current.Next;
                index++;
            }
        }
 
        /// <summary>
        /// Удаляет элемент из коллекции.
        /// </summary>
        /// <param name="item">Элемент.</param>
        /// <exception cref="InvalidOperationException">Выбрасывается, если отсортированный список пуст.</exception>
        public bool Remove(T item)
        {
            if (Count == 0)
                throw new InvalidOperationException($"{nameof(Count)} был равен 0.");
            if (Comparer.Compare(item, Head.Value) == 0)
            {
                Head = Head.Next;
            }
            else
            {
                Node current = Head;
                while (current.Next != null && Comparer.Compare(item, current.Next.Value) != 0)
                    current = current.Next;
                if (current.Next == null)
                    return false;
                current.Next = current.Next.Next;
            }
            Count--;
            return true;
        }
 
        /// <summary>
        /// Перечислитель.
        /// </summary>
        public struct Enumerator : IEnumerator<T>
        {
            private SortedLinkedList<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(SortedLinkedList<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()
            {
            }
        }
    }
}