Question

I’ve recently been coding a lot in both Objective C while also working on several C# projects. In this process, I’ve found that I miss things in both directions.

In particular, when I code in C# I find I miss the short null check syntax of Objective C.

Why do you suppose in C# you can’t check an object for null with a syntax like:

if (maybeNullObject)  // works in Objective C, but not C#   :(
{
   ...
}

I agree that if (maybeNullObject != null) is a more verbose / clear syntax, but it feels not only tedious to write it out in code all the time but overly verbose. In addition, I believe the if (maybeNullObject) syntax is generally understood (Javascript, Obj C, and I assume others) by most developers.

I throw this out as a question assuming that perhaps there is a specific reason C# disallows the if (maybeNullObject) syntax. I would think however that the compiler could easily convert an object expression such as if (maybeNullObject) automatically (or automagically) to if (maybeNullObject != null).

Great reference to this question is How an idea becomes a C# language feature?.

Edit

The short null check syntax that I am suggesting would only apply to objects. The short null check would not apply to primitives and types like bool?.

Answer 1

Because if statements in C# are strict. They take only boolean values, nothing else, and there are no subsequent levels of “truthiness” (i.e., 0, null, whatever. They are their own animal and no implicit conversion exists for them).

The compiler could “easily convert” almost any expression to a boolean, but that can cause subtle problems (believe me…) and a conscious decision was made to disallow these implicit conversions.

IMO this was a good choice. You are essentially asking for a one-off implicit conversion where the compiler assumes that, if the expression does not return a boolean result, then the programmer must have wanted to perform a null check. Aside from being a very narrow feature, it is purely syntactic sugar and provides little to no appreciable benefit. As Eric Lippert woudl say, every feature has a cost…

You are asking for a feature which adds needless complexity to the language (yes, it is complex because a type may define an implicit conversion to bool. If that is the case, which check is performed?) only to allow you to not type != null once in a while.

EDIT:

Example of how to define an implicit conversion to bool for @Sam (too long for comments).

class Foo
{
    public int SomeVar;
    public Foo( int i )
    {
        SomeVar = i;
    }

    public static implicit operator bool( Foo f )
    {
        return f.SomeVar != 0;
    }
}

static void Main()
{
    var f = new Foo(1);         
    if( f )
    {
        Console.Write( "It worked!" );
    }
}