Unique ways to use the null coalescing operator [closed]

Answer 1

Another advantage is that the ternary operator requires a double evaluation or a temporary variable.

Consider this, for instance:

string result = MyMethod() ?? "default value";

while with the ternary operator you are left with either:

string result = (MyMethod () != null ? MyMethod () : "default value");

which calls MyMethod twice, or:

string methodResult = MyMethod ();
string result = (methodResult != null ? methodResult : "default value");

Either way, the null coalescing operator is cleaner and, I guess, more efficient.

Answer 2

I like to use the null coalesce operator to lazy load certain properties.

A very simple (and contrived) example just to illustrate my point:

public class StackOverflow
{
    private IEnumerable<string> _definitions;
    public IEnumerable<string> Definitions
    {
        get
        {
            return _definitions ?? (
                _definitions = new List<string>
                {
                    "definition 1",
                    "definition 2",
                    "definition 3"
                }
            );
        }
    } 
}

Answer 3

One thing I've been doing a lot lately is using null coalescing for backups to as. For example:

object boxed = 4;
int i = (boxed as int?) ?? 99;

Console.WriteLine(i); // Prints 4

It's also useful for backing up long chains of ?. that could each fail

int result = MyObj?.Prop?.Foo?.Val ?? 4;
string other = (MyObj?.Prop?.Foo?.Name as string)?.ToLower() ?? "not there";

Answer 4

The biggest advantage that I find to the ?? operator is that you can easily convert nullable value types to non-nullable types:

int? test = null;
var result = test ?? 0; // 'result' is int, not int?

I frequently use this in LINQ queries:

Dictionary<int, int?> PurchaseQuantities;
// PurchaseQuantities populated via ASP .NET MVC form.
var totalPurchased = PurchaseQuantities.Sum(kvp => kvp.Value ?? 0);
// totalPurchased is int, not int?

Answer 5

Is ?? necessary, or should you just use the ternary operator (that most are familiar with)

You should use what best expresses your intent. Since there is a null coalesce operator, use it.

On the other hand, since it's so specialized, I don't think it has other uses. I would have preferred an appropriate overload of the || operator, as other languages do. This would be more parsimonious in the language design. But well …

Answer 6

I have used it like this:

for (int i = 0; i < result.Count; i++)
{
    object[] atom = result[i];

    atom[3] = atom[3] ?? 0;
    atom[4] = atom[4] != null ? "Test" : string.Empty;
    atom[5] = atom[5] ?? "";
    atom[6] = atom[6] ?? "";
    atom[7] = atom[7] ?? "";
    atom[8] = atom[8] ?? "";
    atom[9] = atom[9] ?? "";
    atom[10] = atom[10] ?? "";
    atom[12] = atom[12] ?? false;
}