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

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

для 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;
}