Bizarre ternary operator behavior in debugger on x64 platform

Question

I'm using a very simple ternary expression in my C# code:

helperClass.SomeData = helperClass.HasData ? GetSomeData() : GetSomeOtherData();

In both cases, the functions on each path of the expression return a non-null object, but if I look at the result in the debugger, it is null until I reference it in the code such as using an assert:

Debug.Assert(helperClass.SomeData != null);

This only appears to happen if I use an "x64" or "Any CPU" platform setting in Debug mode. It's fine in "x86" mode.

I try to be very cautious before assuming I've found a bug in the compiler or debugger, but I can't find any other explanation for this behavior.

Here's a full class to do a repro, just call SomeClass.SomeAction() in the debugger in x64 mode and step through to see it:

public class SomeClass {
    public bool HasData;
    public object SomeData;

    private SomeClass() {
        HasData = false;
    }

    public static void SomeAction() {
        var helperClass = new SomeClass();
        // Exhibits weird debugger behavior of having helperClass.SomeData = null after this line:
        helperClass.SomeData = helperClass.HasData ? GetSomeData() : GetSomeOtherData();

        // Note that trying helperClass.SomeData.ToString() returns a debugger error saying SomeData is null

        // But this code is just fine
        //if(helperClass.HasData) {
        //    helperClass.SomeData = GetSomeData();
        //} 
        //else {
        //    helperClass.SomeData = GetSomeOtherData();
        //}

        // In both cases though, after this line things are fine:
        Debug.Assert(helperClass.SomeData != null);
    }

    private static object GetSomeData() {
        return new object();
    }

    private static object GetSomeOtherData() {
        return new object();
    }
}

Am I missing something or is this a bug in the x64 debugger? I'm using debug mode so no optimizations should be present.

Answer 1

Taking Eric Lippert's advice that this is probably a bug, I've filed an official Connect bug for this issue: https://connect.microsoft.com/VisualStudio/feedback/details/684202

Thanks everyone for your feedback!

UPDATE: They got back to me and said they've fixed this corner case in the next version of the compiler. Hooray! :)

Answer 2

to me this doesn't seem a bug in the debugger but possibly of the compiler...

when changing the code to

{ helperClass.SomeData = helperClass.HasData ? GetSomeData() : GetSomeOtherData(); }

the IL generated is different and the debugger works as expected...