IEnumerable Null Safeguard Extension - Useful When Iterating (ForEach Loop)

1Q_ForEachSafeNullCheck.cs

foreach (var item in items ?? new List<string>())
{
  //do something
}

2A_BetterIteratorSafeCheckExtension.cs

public static class EnumerableExtensions
{
    public static IEnumerable<T> OrEmptyListIfNull<T>(this IEnumerable<T> source)
    {
        return source ?? Enumerable.Empty<T>();
    }
}

foreach(var item in items.OrEmptyListIfNull()) 
{
  //do something
}

This book is great for these types of questions:
http://is.gd/TYQUYA

Suggested by cammerman https://gist.github.com/1120655

http://twitter.com/cammerman/status/98438025121505280
"@ferventcoder My implementation is a little more generalized: http://is.gd/1LpCSW"

http://twitter.com/sclarson/status/98436532796534784
"@ferventcoder for how many times I have been assigned tickets that require fixing the problem that safeguards I'm going to go with good."

Think I like @cammerman's the best... most elegant... and reusable... multiple wins! Close second is Chris Ortman. Didn't see the code though. ;)

I agree with @chrisortman.

I much prefer linqish extension methods over the foreach block as it wraps up ceremony in a more declarative syntax.

Though AFAIK the following code

items.ForEach(x => {...});

will throw a NullReference exception if items is null, so you'd be safer to write:

(items ?? Enumerable.Empty<string>()).ForEach(x => {...});

or, as @stevehorn suggested,

items = items ?? Enumerable.Empty<string>());
items.ForEach(x => {...});

or even, to hide this ceremony further, wrap .ForEach(...) in your own extension method

public static void Each<T>(this IEnumerable<T> source, Action<T> action)
{
    if (source == null)
         return;
    source.ForEach(x => action(x));
 }

I've also seen similar useful overloads like

public static void Each<T>(this IEnumerable<T> source, Action<T, int> action)
{
    if (source == null)
         return;

    int i = 0;
    foreach(T item in source) {
        action(item, i++);
    }
 }

Come to think of it, are you sure that foreach will throw if the source is null? I know if the source is empty it simply short-circuts....

I typically do all this as an assignment outside the looping construct - extensions are nice but they can be confusing.

items = items ?? new List();

or

var list = items ?? new List();

is cleaner IMO

@jglozano: I started down that path and thought, I could shortcut this at the point of the loop...

Late entry by @damianh (randompunter on twitter) - https://gist.github.com/1120821

http://twitter.com/randompunter/status/98457825998684160

"@ferventcoder in a similar vein https://gist.github.com/1120821"

Good stuff. The name of the extension is a little more clear.

I settled on the extension method named OrEmptyListIfNull. This directly borrows from @cammerman's https://gist.github.com/1120655 ;)

as in

foreach(var item in items.OrEmptyListIfNull()) 
{
  //do something
}

I posted the code back at the top of this gist.

This feels like community design... :D