Verificare la presenza di null nel ciclo foreach

Esiste un modo migliore per eseguire le seguenti operazioni:
Ho bisogno di un controllo per verificare che non sia presente alcun valore null sul file.Headers prima di procedere con il ciclo

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

In breve, sembra un po 'brutto scrivere il foreach all'interno di if a causa del livello di indentazione che si verifica nel mio codice.

È qualcosa che valuterebbe

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

possibile?

Proprio come una leggera aggiunta cosmetica al suggerimento di Rune, potresti creare il tuo metodo di estensione:

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

Quindi puoi scrivere:

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

Cambia il nome in base ai gusti :)

Supponendo che il tipo di elementi in file.Headers sia T, potresti farlo

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

questo creerà un enumerabile vuoto di T se file.Headers è nullo. Se il tipo di file è un tipo che possiedi, tuttavia, prenderei in considerazione la possibilità di cambiare il getter di Headers.nullèil valore di unknown quindi se possibile invece di usare null come "So che non ci sono elementi" quando null in realtà (/ originariamente) dovrebbe essere interpretato come "Non so se ci sono elementi" usa un set vuoto per mostrare che sai che non ci sono elementi nel set. Sarebbe anche DRY'er dal momento che non dovrai fare il controllo nullo così spesso.

EDIT come seguito al suggerimento di Jons, potresti anche creare un metodo di estensione cambiando il codice sopra in

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

Nel caso in cui non sia possibile modificare il getter, questo sarebbe il mio preferito poiché esprime l'intenzione in modo più chiaro dando un nome all'operazione (OrEmptyIfNull)

Il metodo di estensione sopra menzionato potrebbe rendere impossibili da rilevare alcune ottimizzazioni per l'ottimizzatore. In particolare, quelli correlati a IList che utilizzano il sovraccarico del metodo possono essere eliminati

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

Francamente, lo consiglio: basta succhiare il nulltest. Un nulltest è solo un brfalseo brfalse.s; tutto il resto sta per coinvolgere molto di più di lavoro (test, le assegnazioni, chiamate di metodo in più, inutile GetEnumerator(), MoveNext(), Dispose()sul iteratore, ecc).

Un iftest è semplice, ovvio ed efficiente.

il "se" prima dell'iterazione va bene, poche di quelle semantiche "carine" possono rendere il codice meno leggibile.

comunque, se il rientro disturba il tuo, puoi cambiare if per verificare:

if(file.Headers == null)  
   return;

e arriverai al ciclo foreach solo quando c'è un valore vero nella proprietà headers.

un'altra opzione a cui posso pensare è usare l'operatore di coalescenza null all'interno del tuo ciclo foreach e per evitare completamente il controllo null. campione:

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

(sostituisci la collezione con il tuo vero oggetto / tipo)

Utilizzo dell'operatore Null-conditional e ForEach () che funziona più velocemente del ciclo foreach standard.
Tuttavia, devi trasmettere la raccolta a List.

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

Sto usando un piccolo metodo di estensione per questi scenari:

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

Dato che Headers è di tipo list, puoi fare quanto segue:

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

Per alcuni casi preferirei leggermente un'altra variante generica, supponendo che, di regola, i costruttori di raccolta predefiniti restituiscano istanze vuote.

Sarebbe meglio nominare questo metodo NewIfDefault. Può essere utile non solo per le raccolte, quindi il vincolo di tipo IEnumerable<T>è forse ridondante.

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