If (items! = Null) è superfluo prima di foreach (T item in items)?

Mi imbatto spesso in codice come il seguente:

if ( items != null)
{
   foreach(T item in items)
   {
        //...
   }
}

Fondamentalmente, la ifcondizione garantisce che il foreachblocco itemsvenga eseguito solo se non è nullo. Mi chiedo se la ifcondizione sia davvero necessaria o foreachse gestirà il caso items == null.

Voglio dire, posso semplicemente scrivere

foreach(T item in items)
{
    //...
}

senza preoccuparsi se itemsè nullo o no? La ifcondizione è superflua? O questo dipende dal tipo di itemso forse su Tcome bene?

Devi ancora controllare se (items! = Null) altrimenti otterrai NullReferenceException. Tuttavia puoi fare qualcosa del genere:

List<string> items = null;  
foreach (var item in items ?? new List<string>())
{
    item.Dump();
}

ma potresti controllarne le prestazioni. Quindi preferisco ancora avere if (items! = Null) prima.

Sulla base del suggerimento di Eric Lippert, ho cambiato il codice in:

List<string> items = null;  
foreach (var item in items ?? Enumerable.Empty<string>())
{
    item.Dump();
}

Utilizzando C # 6 è possibile utilizzare il nuovo operatore condizionale null insieme a List<T>.ForEach(Action<T>)(o il proprio IEnumerable<T>.ForEachmetodo di estensione).

List<string> items = null;
items?.ForEach(item =>
{
    // ...
});

La vera conclusione qui dovrebbe essere che una sequenza non dovrebbe quasi mai essere nulla in primo luogo . Rendi semplicemente invariante in tutti i tuoi programmi che se hai una sequenza, non è mai nulla. Viene sempre inizializzato per essere la sequenza vuota o qualche altra sequenza originale.

Se una sequenza non è mai nulla, ovviamente non è necessario controllarla.

In realtà c'è una richiesta di funzionalità su quel @Connect: http://connect.microsoft.com/VisualStudio/feedback/details/93497/foreach-should-check-for-null

E la risposta è abbastanza logica:

Penso che la maggior parte dei cicli foreach siano scritti con l'intento di iterare una raccolta non nulla. Se provi a iterare tramite null dovresti ottenere la tua eccezione, in modo da poter correggere il tuo codice.

Puoi sempre provarlo con una lista nulla ... ma questo è quello che ho trovato sul sito di msdn

foreach-statement:
    foreach   (   type   identifier   in   expression   )   embedded-statement 

Se l'espressione ha il valore null, viene generata un'eccezione System.NullReferenceException.

Non è superfluo. In fase di esecuzione verrà eseguito il cast degli elementi a un oggetto IEnumerable e verrà chiamato il relativo metodo GetEnumerator. Ciò provocherà una dereferenziazione degli elementi che falliranno

Puoi incapsulare il controllo null in un metodo di estensione e utilizzare un lambda:

public static class EnumerableExtensions {
  public static void ForEach<T>(this IEnumerable<T> self, Action<T> action) {
    if (self != null) {
      foreach (var element in self) {
        action(element);
      }
    }
  }
}

Il codice diventa:

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

If può essere ancora più conciso se vuoi semplicemente chiamare un metodo che prende un articolo e restituisce void:

items.ForEach(MethodThatTakesAnItem);

Ne hai bisogno. Otterrai un'eccezione quando foreachaccedi al contenitore per impostare l'iterazione in caso contrario.

Sotto le coperte, foreachutilizza un'interfaccia implementata sulla classe di raccolta per eseguire l'iterazione. L'interfaccia equivalente generica è qui .

L'istruzione foreach del linguaggio C # (per ciascuno in Visual Basic) nasconde la complessità degli enumeratori. Pertanto, si consiglia di utilizzare foreach invece di manipolare direttamente l'enumeratore.

Il test è necessario, perché se la raccolta è null, foreach genererà un'eccezione NullReferenceException. In realtà è abbastanza semplice provarlo.

List<string> items = null;
foreach(var item in items)
{
   Console.WriteLine(item);
}

il secondo lancerà una NullReferenceExceptioncon il messaggioObject reference not set to an instance of an object.

Come accennato qui, è necessario verificare se non è nullo.

Non utilizzare un'espressione che restituisce null.

In C # 6 puoi scrivere qc in questo modo:

// some string from file or UI, i.e.:
// a) string s = "Hello, World!";
// b) string s = "";
// ...
var items = s?.Split(new char[] { ',', '!', ' ' }) ?? Enumerable.Empty<string>();  
foreach (var item in items)
{
    //..
}

È fondamentalmente la soluzione di Vlad Bezden ma usando il ?? espressione per generare sempre un array che non è nullo e quindi sopravvive al foreach piuttosto che avere questo controllo all'interno della parentesi foreach.