Что подразумевается под коротким замыканием нулевого условного оператора?

Это действительно короткое замыкание (если под этим мы подразумеваем «завершить цепочку вызовов»).

Рассмотрим этот код:

using System;

namespace ConsoleApplication1
{
    class C
    {
        public C Inner
        {
            get
            {
                Console.WriteLine("Inner called.");
                return this; // Change this to `return null;`
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var c = new C();

            var x = c?.Inner?.Inner?.Inner;
        }
    }
}

Запустите это, и оно напечатает

Inner called.
Inner called.
Inner called.

Теперь измените return this; на return null;, и он напечатает

Inner called.

тем самым демонстрируя, что цепочка вызовов была остановлена ​​при первом нулевом значении.

Теперь измените выражение на:

var x = c?.Inner?.Inner.Inner;

и все равно будет печатать

Inner called.

потому что это короткое замыкание.

Очевидно, что он должен получить доступ к Inner по крайней мере один раз, чтобы увидеть, является ли он нулевым. Если сам c равен нулю, то Inner вообще не используется.

Обратите внимание, что с учетом выражения:

var x = c?.Inner.Inner;

он выдаст исключение нулевой ссылки при первом использовании .Inner, потому что он уже проверил, что c не является нулевым, используя c?, и теперь он продолжает использовать .Inner.

Если бы c было нулевым, он бы вообще не обращался к .Inner из-за c?..

Короткое замыкание здесь означает, что когда у вас есть, например, obj?.Property1?.Property2?.Property3, а obj равно null, тогда все выражение возвращает null, и никакие другие свойства не вызываются (поскольку они будут генерировать).

Это короткое замыкание может произойти на каждом ?. в зависимости от того, какая часть null. если obj не равно нулю, а первый Property равен, то только остальные 2 не будут вызываться. То же самое для второго и так далее.

Короткое замыкание происходит в выражении, а не в остальных операторах после этого выражения.

Проще говоря, короткое замыкание — это гарантия того, что если он определит, что одно свойство имеет значение null, он не будет продолжать попытки оценить остальные.

Это может быть понятнее с примером, который не включает нулевой оператор.

В приведенном ниже примере мы проверяем, является ли x значением null, прежде чем проверять значение его свойства.

if(x != null & x.SomeProperty == 1)

Но это все равно вызовет исключение, если x равно null, потому что он будет оценивать оба условия. Даже если x равно нулю, он все равно попытается проверить x.SomeProperty и выдаст NullReferenceException.

Но если вместо этого мы используем оператор &&

if(x != null && x.SomeProperty == 1)

Потом "короткое замыкание". Если первое условие неверно, то второе условие даже не будет оцениваться. Он проверяет, верны ли они оба. Но если первое неверно, то они оба не могут быть правдой — значение второго не имеет значения. Таким образом, он останавливается после первого условия.

Короткое замыкание в конечном итоге означает, что если он оценивает что-либо, что делает остальные условия неактуальными, то он гарантированно не оценивает оставшиеся условия.