Check for null in foreach loop

Question

Is there a nicer way of doing the following:
I need a check for null to happen on file.Headers before proceeding with the loop

if (file.Headers != null         


        

Answer 1

the "if" before the iteration is fine, few of those "pretty" semantics can make your code less readable.

anyway, if the indentation disturbs your, you can change the if to check:

if(file.Headers == null)  
   return;

and you'll get to the foreach loop only when there is a true value at the headers property.

another option I can think about is using the null-coalescing operator inside your foreach loop and to completely avoid null checking. sample:

List<int> collection = new List<int>();
collection = null;
foreach (var i in collection ?? Enumerable.Empty<int>())
{
    //your code here
}

(replace the collection with your true object/type)

Answer 2

Using Null-conditional Operator and ForEach() which works faster than standard foreach loop.
You have to cast the collection to List though.

   listOfItems?.ForEach(item => // ... );

Answer 3

Just as a slight cosmetic addition to Rune's suggestion, you could create your own extension method:

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

Then you can write:

foreach (var header in file.Headers.OrEmptyIfNull())
{
}

Change the name according to taste :)

Answer 4

Frankly, I advise: just suck up the null test. A null test is just a brfalse or brfalse.s; everything else is going to involve much more work (tests, assignments, extra method calls, unnecessary GetEnumerator(), MoveNext(), Dispose() on the iterator, etc).

An if test is simple, obvious, and efficient.

Answer 5

I am using a nice little extension method for these scenarios:

  public static class Extensions
  {
    public static IList<T> EnsureNotNull<T>(this IList<T> list)
    {
      return list ?? new List<T>();
    }
  }

Given that Headers is of type list, you can do following:

foreach(var h in (file.Headers.EnsureNotNull()))
{
  //do stuff
}

Answer 6

For some cases I'd prefer slightly another, generic variant, assuming that, as a rule, default collection constructors return empty instances.

It would be better to name this method NewIfDefault. It can be useful not only for collections, so type constraint IEnumerable<T> is maybe redundant.

public static TCollection EmptyIfDefault<TCollection, T>(this TCollection collection)
        where TCollection: class, IEnumerable<T>, new()
    {
        return collection ?? new TCollection();
    }