Why does null-conditional operator not evaluate the entire expressions?

[gurkantuna]

I like to use null-conditional operators if there are some values in my code that are likely to be null. It turns out I was using it wrong until now.

I think that the following foo?.Bar?.ToLower() != foo2?.Bar?.ToLower() lines are executed because they evaluate as equivalent foo?.Bar?.ToLower() != null. What I mean is that next objects are not checked if they are null or not. But I was expecting include all references and all their properties like foo2, foo2.Bar and all their properties in if expression and foo.Do() method to not be executed. So, why the operator doesnt work like this?

internal class Program {
    static void Main(string[] args) {

        var foo = new Foo() { Bar = "Bar" };
        var foo2 = new Foo2();

        if (foo?.Bar?.ToLower() != foo2?.Bar?.ToLower()) {//This row is executed even if foo2 or foo2.Bar is null
            foo.Do();
        }

        if (foo != null && foo.Bar != null &&
            foo2 != null && foo2.Bar != null &&
            foo2.Bar?.ToLower() != foo2.Bar?.ToLower()) {//This row is skipping as I expect
            foo2.Do();
        }

        Console.Read();
    }
}

class Foo {
    public string? Bar { get; set; }
    public Foo2? Foo2 { get; set; }
    public void Do() { Console.WriteLine("Foo.Do"); }
}

class Foo2 {
    public string? Bar { get; set; }
    public void Do() { Console.WriteLine("Foo2.Do"); }
}

[HaloFour]

See: https://github.com/dotnet/csharplang/blob/main/meetings/2014/LDM-2014-04-21.md#null-propagating-operator-associativity

[gurkantuna]

@CyrusNajmabadi Yes, it can be said this way, but honestly, I'm just trying to explain it in a simple way. ☺️

I prefer the short if statement at the top instead of the long one at the bottom in the above code blocks but but it looks like the compiler doesn't agree with me yet.

[CyrusNajmabadi]

@g-u-r-k-a-n I'm honestly not sure waht you mean there. The short if at the top is legal, idiomatic, reasonable C# code. You can and should write it. And it has sensible semantics. It is saying "is the lower of these two values, the same. which would also be true if both were null, since that is symetric".

If you don't want that logic and also want "but dont' do this if either value is null", then you'll have to add those additional checks :)

[gurkantuna]

@CyrusNajmabadi It's ok, I got it :) I used the null-condition operator until now hoping that it included the null check in the expression too, which appears not the be the case. And also, an enormous amount of code has been writte, allright :)

I would have the compiler to check for null with ?. operator and exit the block if so. But what I don't understand is what kind of logical problem would arise if it were used in the way I mentioned?

[CyrusNajmabadi]

But what I don't understand is what kind of logical problem would arise if it were used in the way I mentioned?

It would literally break existing code that very intentionally is written to use teh current behavior. For example:

if (x?.ToLower() != y?.ToLower())
{
    RunMeIfTheStringsAreDifferentButConsiderNullSourcesToBeEqual();
}

Lots of this code exists.

[gurkantuna]

Gosh! It's my bad 😌 ToLower() is not important. I just wrote it a simple method to show usage of the operator. Of course, this is a small example that I wrote in 30 seconds. I noticed this situation in a complex part of a project I wrote.

So as you can guess, even if you remove it, the block will still be executed. But the weird thing is that I changed the blocks to explain with your way above with inner classes and the operator worked exactly as I expected this time. I thought it would go into the if block, but it didn't. I'll review the project I mentioned again. 😳 Thanks anyway.

internal class Program {
    static void Main(string[] args) {

        var x = new X() { Y = new Y { Z = new Z { T = "e" } } };
        var a = new A() { B = new B { C = new C { D = "e" } } };

        x.Y.Z = null;
        //a.B.C = null;

        if (x?.Y?.Z?.T == a?.B?.C?.D) {

        }
        Console.Read();
    }
}

class X { public Y? Y { get; set; } }

class Y { public Z? Z { get; set; } }

class Z { public string? T { get; set; } }

class A { public B? B { get; set; } }

class B { public C? C { get; set; } }

class C { public string? D { get; set; } }