Instantiating Null Objects with Null-Coalescing Operator

Question

Consider the following typical scenario:

if(myObject == null) {
    myObject = new myClass();
}

I'm wondering what is thought of the following replacement using the null-coalescing operator:

myObject = myObject ?? new myClass();

I'm not sure whether I should be using the second form. It seems like a nice shorthand, but the myObject = myObject construct at the beginning seems like it could be a bit of a code-smell.

Is this a reasonable thing to do, or is there a better shorthand that I am missing? Or maybe, "It's three lines, get over it!"?

Edit: As has been mentioned, perhaps calling this a typical scenario is something of an overstatement. I usually find that I encounter this situation when I'm retrieving an entity from a database that has a child reference type property that may or may not be populated yet:

myClass myObject = myClassService.getById(id);
myObject.myChildObject = myObject.myChildObject ?? new myChildClass();

Answer 1

I use the null coalescing operator all of the time. I like the conciseness of it.

I find this operator to be similar in nature to the ternary operator (A ? B : C). It takes a little practice before the reading of it is second nature, but once you're used to it I feel readability improves over the longhand versions.

Also, the situation you describe is only one scenario where the operator is useful. It's also handy to replace constructs like this:

if (value != null)
{
    return value;
}
else
{ 
    return otherValue;
}

or

return value != null ? value : otherValue;

with

return value ?? otherValue;

Answer 2

What I'm wondering about specifically is using the operator to set an object to itself unless it's null.

The ?? operator is called the null-coalescing operator and is used to define a default value for nullable value types or reference types. It returns the left-hand operand if the operand is not null; otherwise it returns the right operand.

myObject = myObject ?? new myObject(); - instantiate default value of object

More details and code sample about null-coalescing operator - MSDN article.

If you check for more than nullable condition, as an alternative you may use Ternary operator.

Ternary operator

You may also look at ?: Operator. It is called Ternary or conditional operator. The conditional operator (?:) returns one of two values depending on the value of a Boolean expression.

A nullable type can contain a value, or it can be undefined. The ?? operator defines the default value to be returned when a nullable type is assigned to a non-nullable type. If you try to assign a nullable value type to a non-nullable value type without using the ?? operator, you will generate a compile-time error. If you use a cast, and the nullable value type is currently undefined, an InvalidOperationException exception will be thrown.

A code example from MSDN - ?: Operator (C# Reference):

int? input = Convert.ToInt32(Console.ReadLine());
string classify;

// ?: conditional operator.
classify = (input.HasValue) ? ((input < 0) ? "negative" : "positive") : "undefined";

Answer 3

I don't think that scenario is (or at least should be) typical.

If you want the default value of some field not to be null, then set it in the field initializer:

myClass myObject = new myClass();

Or, if the initialization is more complicated, set it in the constructor.

If you want to create myClass only when you actually need it (e.g. because creating it takes a long time), then you can use Lazy<T>:

Lazy<myClass> myObject = new Lazy<myClass>();

(This calls the default constructor. If the initialization is more complicated, pass lambda that creates myClass to the Lazy<T> constructor.)

To access the value, use myObject.Value, which will call the initialization if this is the first time you're accessing myObject.Value.

Answer 4

I especially like using ?? in conjunction with optional method parameters. I limit the need for overloads and ensure the thing has a value.

public void DoSomething (MyClass thing1 = null) {
    thing1 = thing1 ?? new MyClass();
}