Question

class Program
{
    static void Main(string[] args)
    {
        var x = new Program();
        Console.Write(x.Text);
        Console.Write(x.Num);
        //Console.Write(x.Num);//line A
    }

    private string Text_;
    public string Text
    {
        get
        {
            return Text_ ?? (Text_ = "hello");//line B
        }
    }

    private int? Num_;
    public int Num
    {
        get
        {
            return (int)(Num_ ?? (Num_ = 42));//line C
        }
    }
}

I’m using Visual Studio 2010 to get code coverage results. It shows that line B is totally covered while line C is partially covered. I would expect that line B is partially covered as well instead of being totally covered. Why is it the case that the code coverage results shows line B as being totally covered?

To demonstrate that it’s working “correctly” for Num property, uncomment line A and run the coverage. It should show line C as totally being covered.

When I rewrite the code to a more verbose form (see below), it works correctly and reports that Text_ is partially covered. I prefer to use the former for its brevity, and would like to know if the two forms are equivalent too. Thanks in advance.

if (Text_ != null)
{
    return Text_;
}
else
{
    return Text_ = "hello";
}

Answer 1

The ?? on Nullable<T> expands to something more complex at the compiler, i.e.

a ?? b

is really

a.HasValue ? a.GetValueOrDefault() : b

Now, since a was null/empty for the only time it was executed, the a.GetValueOrDefault() has never been called. The underlying code when using a string (or any flat reference) is simpler.

In reality, just call it twice to make this go away:

Console.Write(x.Text); // first call; performs init
Console.Write(x.Text); // test once initialized
Console.Write(x.Num); // first call; performs init
Console.Write(x.Num); // test once initialized