• Тип SomeType должен быть отмечен неким атрибутом
  
• Свойства/поля/параметры/возвращаемые значения методов так же, там где это необходимо, размечаются атрибутами, говорящими, что объекты/значения в них могут быть ещё только частично проинициализированны
  
• Как только переменная типа SomeType покидает такой вот "частично проинициализированный" контекст (например возвращается из метода, возвращаемое значение которого атрибутом не размечено), анализатор может проверить, что тип полностью инициализирован.

a.Next = b;
b.Next = c;
c.Next = d;
d.Next = e;
e.Next = a;
e.Previous = c;
d.Previous = b;
c.Previous = a;
b.Previous = e;
a.Previous = d;

А у Node2.Next будет null?

public static IEnumerable<Node> EnumerateForward(Node? list) {
  while (list) {
    yield return list;
    list = list.Next;
  }
}

this.next = next ?? throw new ArgumentNullException(nameof(next))

S>public static IEnumerable<Node> EnumerateForward(Node? list) {
S>  while (list) {
S>    yield return list;
S>    list = list.Next;
S>  }
S>}
S>

while (!list.IsEmpty)

S>this.next = next ?? throw new ArgumentNullException(nameof(next))
S>

S>

SP>почему только локальные функции? Как бы чего не вышло?

avoiding unexpected nulls is a huge benefit, particularly in larger codebases where it's harder to keep track of the edge cases where things can be null by yourself

S> А вам не приходило в голову задуматься: а почему этому кой-кому не нужен Nullable Reference? Если не приходило — перечитайте стартовый пост, там всё написано.

Так как Next для последнего и Previous для первого будет null

#продвинутый nullable enable
        var obj1 = new SomeType1();
       var obj2 = new SomeType2();
obj1.Prop = obj2;
obj2.Prop = obj1;
// Local functions are allowed
void Connect() => obj1.Child = obj2;
Connect();
#продвинутый nullable disable

S>Попробуйте переписать пример с использованием Optional. Станет хуже

using System;
using System.Collections.Generic;
using Optional;

public class Node<T>
{
    public required T Value { get; set; }
    public Option<Node<T>> Next { get; set; }
    public Option<Node<T>> Previous { get; set; }

    public Node(T value)
    {
        Value = value;
        Next = Option.None<Node<T>>();
        Previous = Option.None<Node<T>>();
    }

    public static Option<Node<T>> Init<T>(IEnumerable<T> values)
    {
        using var enumerator = values.GetEnumerator();
        if (!enumerator.MoveNext())
            return Option.None<Node<T>>();

        var head = new Node<T>(enumerator.Current);
        var current = head;

        while (enumerator.MoveNext())
        {
            var newNode = new Node<T>(enumerator.Current);

            current.Next = Option.Some(newNode);
            newNode.Previous = Option.Some(current);

            current = newNode;
        }

        return Option.Some(head);
    }

    public static IEnumerable<T> TraverseForward<T>(Option<Node<T>> start)
    {
        var current = start;

        while (current.Match(
            some: node =>
            {
                yield return node.Value;
                current = node.Next;
                return true;
            },
            none: () => false
        )) { }
    }
}

class Node
{
    public required Node Next { get; set; }
    public required Node Previous { get; set; }
    public string Name {get; init;}
    public Node(string name) => Name = name;
}

public static IEnumerable<string> Iterate(Node start) {
  var current = start;
  do { 
    yield return current.Name; 
    current = current.Next;
  } while(current != start);
}

var node1 = new Node("Hello"); 
var node2 = new Node("World") { Next = node1, Previous = node1 }; 
foreach(var n in Iterate(node1))
  Console.WriteLine(n);

Compile time error: Required member 'Program.Node.Next' must be set in the object initializer or attribute constructor.
Compile time error: Required member 'Program.Node.Previous' must be set in the object initializer or attribute constructor.

var node1 = new Node("Hello") { Next = null!, Previous = null! }; 
var node2 = new Node("World") { Next = node1, Previous = node1) }; 
node1.Previous = node2;
foreach(var n in Iterate(node1)
  Console.WriteLine(n);

S>#продвинутый nullable enable
S>        var obj1 = new SomeType1();
S>       var obj2 = new SomeType2();
S>obj1.Prop = obj2;
S>obj2.Prop = obj1;
S>// Local functions are allowed
S>void Connect() => obj1.Child = obj2;
S>Connect();
S>#продвинутый nullable disable
S>

S>>#продвинутый nullable enable
S>>        var obj1 = new SomeType1();
S>>       var obj2 = new SomeType2();
S>>obj1.Prop = obj2;
S>>obj2.Prop = obj1;
S>>// Local functions are allowed
S>>void Connect() => obj1.Child = obj2;
S>>Connect();
S>>#продвинутый nullable disable
S>>

 #nullable disable
 #продвинутй nullable enable
 код c проверкой на присваивание всем полям не null значений
 #продвинутй nullable disable
 #nullable enable

S>var node1 = new Node("Hello") { Next = null!, Previous = null! }; 
S>var node2 = new Node("World") { Next = node1, Previous = node1) }; 
S>node1.Previous = node2;
S>foreach(var n in Iterate(node1)
S>  Console.WriteLine(n);
S>

var node1 = new Node("Hello") { Next = Node.EmptyNode, Previous = Node.EmptyNode }; 
var node2 = new Node("World") { Next = node1, Previous = Node.EmptyNode) }; 
node1.Previous = node2;
foreach(var n in Iterate(node1)
Console.WriteLine(n);

S>>Попробуйте переписать пример с использованием Optional. Станет хуже

SP>using System;
SP>using System.Collections.Generic;
SP>using Optional;

SP>public class Node<T>
SP>{
SP>    public required T Value { get; set; }
SP>    public Option<Node<T>> Next { get; set; }
SP>    public Option<Node<T>> Previous { get; set; }

SP>    public Node(T value)
SP>    {
SP>        Value = value;
SP>        Next = Option.None<Node<T>>();
SP>        Previous = Option.None<Node<T>>();
SP>    }

SP>    public static Option<Node<T>> Init<T>(IEnumerable<T> values)
SP>    {
SP>        using var enumerator = values.GetEnumerator();
SP>        if (!enumerator.MoveNext())
SP>            return Option.None<Node<T>>();

SP>        var head = new Node<T>(enumerator.Current);
SP>        var current = head;

SP>        while (enumerator.MoveNext())
SP>        {
SP>            var newNode = new Node<T>(enumerator.Current);

SP>            current.Next = Option.Some(newNode);
SP>            newNode.Previous = Option.Some(current);

SP>            current = newNode;
SP>        }

SP>        return Option.Some(head);
SP>    }

SP>    public static IEnumerable<T> TraverseForward<T>(Option<Node<T>> start)
SP>    {
SP>        var current = start;

SP>        while (current.Match(
SP>            some: node =>
SP>            {
SP>                yield return node.Value;
SP>                current = node.Next;
SP>                return true;
SP>            },
SP>            none: () => false
SP>        )) { }
SP>    }
SP>}
SP>

using System;
using System.Collections.Generic;

public class Node<T>
{
    public required T Value { get; set; }
    public Node<T>? Next { get; set; }
    public Node<T>? Previous { get; set; }

    public Node(T value)
    {
        Value = value;
    }

    public static Node<T>? Init<T>(IEnumerable<T> values)
    {
        using var enumerator = values.GetEnumerator();
        if (!enumerator.MoveNext())
            return null;

        var head = new Node<T>(enumerator.Current);
        var current = head;

        while (enumerator.MoveNext())
        {
            var newNode = new Node<T>(enumerator.Current);

            current.Next = newNode;
            newNode.Previous = current;

            current = newNode;
        }

        return Option.Some(head);
    }

    public static IEnumerable<T> TraverseForward<T>(Node<T>? start)
    {
        var current = start;

        while (current)
        {
             yield return node.Value;
             current = node.Next;
        }
    }
}

S>>var node1 = new Node("Hello") { Next = Node.EmptyNode, Previous = Node.EmptyNode }; 
S>>var node2 = new Node("World") { Next = node1, Previous = Node.EmptyNode) }; 
S>>node1.Previous = node2;
S>>foreach(var n in Iterate(node1)
S>>Console.WriteLine(n);
S>>

S>Во-первых, вы сначала напишите код Node.EmptyNode

S>У нас проблема не в NullReferenceException, а в нарушении инварианта. В частности, node1.Next и node2.Previous так и остались непроинициализированными. Вы код-то попробуйте запустить

private Node(bool blin)
{
 this._next= this;
 this._previous = this;
}

S>>У нас проблема не в NullReferenceException, а в нарушении инварианта. В частности, node1.Next и node2.Previous так и остались непроинициализированными. Вы код-то попробуйте запустить

S>private Node(bool blin)
S>{
S> this._next= this;
S> this._previous = this;
S>}
S>

node1.Next == Node.EmptyNode
node1.Previous == node2
node2.Next == node1
node2.Previous == Node.EmptyNode

node1.Next == node2
node1.Previous == node2
node2.Next == node1
node2.Previous == node1

для not null reference нужны заглушки типам Node.EmptyNode
Опять же для первой ноды должно быть Previous = Node.EmptyNode, а для последней Next = Node.EmptyNode

public Node<T>? Next { get; set; }
    public Node<T>? Previous { get; set; }

string.IsNullOrEmpty(str)

str.IsEmpty

#nullable disable
#nullable enable

S>

S>И ещё и настаиваете на своём решении

 #nullable disable
 #продвинутй nullable enable
 код c проверкой на присваивание всем полям не null значений
 #продвинутй nullable disable
 #nullable enable

 #nullable disable
 #pragma warning restore продвинутый nullable
 код c проверкой на присваивание всем полям не null значений
 #pragma warning disable продвинутый nullable
 #nullable enable

var node1 = new Node("Hello") { Next = Node.EmptyNode, Previous = Node.EmptyNode }; 
var node2 = new Node("World") { Next = node1, Previous = Node.EmptyNode) }; 
node1.Previous = node2;
foreach(var n in Iterate(node1)
  Console.WriteLine(n);

S>var node1 = new Node("Hello") { Next = Node.EmptyNode, Previous = Node.EmptyNode }; 
S>var node2 = new Node("World") { Next = node1, Previous = Node.EmptyNode) }; 
S>node1.Previous = node2;
S>foreach(var n in Iterate(node1)
S>  Console.WriteLine(n);
S>

 void AddBeforeNode(Node node)
{
  if (node == FirstNode) // if (node.Previous  == Node.Empty) 
{
  var node = new Node(Node.Empty,node);
}
 else 
{
// Вернее этот код будет работать и для первой ноды так как node.Previous == Node.Empty
  var node = new Node(node.Previous ,node);
  node.Previous.Next = node;
}

node.Previous = node;
}

 void AddNodeToEnd()
{
  if (LastNode == node.Empty)
{
   LastNode = new Node(Node.Empty,Node.Empty);
 FirstNode = LastNode; 
}
else
{
  
var node = new Node(LastNode ,LastNode.Next);
LastNode.Next = node;
LastNode = node;
 
}

}

node1.Next == node2
node1.Previous == node2
node2.Next == node1
node2.Previous == node1

	Для наглядности возможные графы

init (var root = new TreeNode(), var child1 = new TreeNode(), var child2 = new TreeNode())
{
    root.Left = child1;
    root.Right = child2;
    
    SetParent(child1, root);
    SetParent(child2, root);
    
    void SetParent(TreeNode child, TreeNode parent)
    {
        child.Parent = parent; // Parent is a non-nullable property
    }
}

Сlass Node
{
    public required Node Next { get; set; }
    public required Node Previous { get; set; }
}

init (var node1 = new Node(), var node2 = new Node())
{
    node1.Next = node2;
    node2.Previous = node1;
}