Verifique se há nulo no loop foreach

Existe uma maneira mais agradável de fazer o seguinte:
Preciso que uma verificação de null aconteça no arquivo. Cabeçalhos antes de prosseguir com o loop

if (file.Headers != null)
{
  foreach (var h in file.Headers)
  {
   //set lots of properties & some other stuff
  }
}

Resumindo, parece um pouco feio escrever o foreach dentro do if devido ao nível de indentação que ocorre no meu código.

É algo que avaliaria

foreach(var h in (file.Headers != null))
{
  //do stuff
}

possível?

Apenas como uma pequena adição estética à sugestão de Rune, você pode criar seu próprio método de extensão:

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

Então você pode escrever:

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

Mude o nome de acordo com o gosto :)

Supondo que o tipo de elementos no arquivo. Cabeçalhos é T, você poderia fazer isso

foreach(var header in file.Headers ?? Enumerable.Empty<T>()){
  //do stuff
}

isso criará um enumerável vazio de T se file.Headers for null. Se o tipo de arquivo for um tipo seu, eu, entretanto, consideraria alterar o getter de Headers. nullé o valor de desconhecido, então, se possível, em vez de usar nulo como "Eu sei que não há elementos", quando nulo na verdade (/ originalmente) deve ser interpretado como "Não sei se há algum elemento", use um conjunto vazio para mostrar que você sabe que não há elementos no conjunto. Isso também seria mais seco, pois você não terá que fazer a verificação de nulos com tanta frequência.

EDITAR seguindo a sugestão de Jons, você também pode criar um método de extensão alterando o código acima para

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

No caso em que você não pode alterar o getter, seria a minha preferência, pois expressa a intenção de forma mais clara, dando um nome à operação (OrEmptyIfNull)

O método de extensão mencionado acima pode tornar certas otimizações impossíveis para o otimizador detectar. Especificamente, aqueles que estão relacionados a IList usando a sobrecarga de método podem ser eliminados

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

Francamente, eu aconselho: apenas absorva o nullteste. Um nullteste é apenas um brfalseou brfalse.s; tudo o resto vai envolver muito mais trabalho (exames, atribuições, chamadas de método extra, desnecessário GetEnumerator(), MoveNext(), Dispose()no iterador, etc).

Um ifteste é simples, óbvio e eficiente.

o "se" antes da iteração está bom, poucas dessas semânticas "bonitas" podem tornar seu código menos legível.

de qualquer forma, se o recuo atrapalhar você, você pode alterar o if para verificar:

if(file.Headers == null)  
   return;

e você obterá o loop foreach apenas quando houver um valor verdadeiro na propriedade headers.

outra opção que posso pensar é usar o operador de coalescência nula dentro de seu loop foreach e evitar completamente a verificação de nulos. amostra:

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

(substitua a coleção pelo seu verdadeiro objeto / tipo)

Usando o operador nulo condicional e ForEach () que funciona mais rápido do que o loop foreach padrão.
No entanto, você deve lançar a coleção para List.

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

Estou usando um pequeno método de extensão agradável para estes cenários:

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

Dado que Cabeçalhos é do tipo lista, você pode fazer o seguinte:

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

Para alguns casos, eu preferiria um pouco outra variante genérica, supondo que, como regra, os construtores de coleção padrão retornam instâncias vazias.

Seria melhor nomear este método NewIfDefault. Pode ser útil não apenas para coleções, portanto, a restrição de tipo IEnumerable<T>pode ser redundante.

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