Обходной путь С# для классов общих друзей

Итак, у меня есть вариант использования, похожий на Вот этот, но с некоторыми дополнительными особенностями, которые, как мне кажется, оправдывают новый вопрос. (Связанныйвопросы, для справки)

Я пишу структуру данных, реализующую цикл. Базовая конструкция примерно такая:

public class Cycle<T>
{
    public Node<T> Origin { get; private set; }
    public int Count { get; private set; }
}

public class Node<T>
{
    public Cycle<T> Cycle { get; private set; }
    public Node<T> Next { get; private set; }
    public Node<T> Previous { get; private set; }
    public T Value { get; set; }
}

Однако я хочу реализовать все следующего поведения:

1. Обновлять Cycle.Count по мере вставки/удаления узлов
2. Разрешить «пустой» Cycle (т. е. Origin = null) создать новый Node для Origin
3. Предотвратить строительство новых Node объектов за пределами случаев 1 и 2
4. Избегайте раскрытия методов, которые не нужно вызывать классами, отличными от этих двух.

В C++ я бы просто сделал каждый класс friend другого. Но в С# я не вижу способа заставить это работать.

Я знаю, что могу выполнить все, кроме № 3, если вложу Node внутрь Cycle и выставлю только один конструктор для Node, например:

public class Cycle<T>
{
    public Node Origin { get; private set; }
    public int Count { get; private set; }
    
    public class Node
    {
        public Cycle<T> Cycle { get; private set; }
        public Node Next { get; private set; }
        public Node Previous { get; private set; }
        public T Value { get; set; }
        
        internal Node<T>(Cycle<T> cycle)
        {
            if (cycle.Origin != null)
                throw new InvalidOperationException();
            else
            {
                Cycle = cycle;
                Next = this;
                Previous = this;
                cycle.Origin = this;
                cycle.Count = 1;
            }
        }
    }
}

Но, как видите, я могу дойти только до internal, поэтому мне все еще нужно проверить целостность данных или нарушить инкапсуляцию.

У меня есть «умная» идея один, но это своего рода ответ черная магия:

public abstract class Cycle<T>
{
    public Node Origin { get; private set; }
    public int Count { get; private set; }
    
    public sealed class Node
    {
        private CycleInternal _cycle;
        public Cycle<T> Cycle { get { return _cycle; } }
        public Node Next { get; private set; }
        public Node Previous { get; private set; }
        public T Value { get; set; }
        
        // this constructor can be called by CycleInternal, but not other classes!
        private Node(CycleInternal cycle)
        {
            Cycle = cycle;
            Next = this;
            Previous = this;
            cycle.Origin = this;
            cycle.Count = 1;
        }
        
        private sealed class CycleInternal :  Cycle<T>
        {
            // this constructor can be called by Node, but not other classes!
            public CycleInternal() {}
        }
    }
}

В этом случае меня беспокоит то, что что-то еще может наследоваться от Cycle; можно ли предотвратить это, сделав конструктор закрытым для цикла? Или я тут просто параноик?