Est-ce que if (items! = Null) est superflu avant foreach (T item in items)?

Je rencontre souvent du code comme celui-ci:

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

Fondamentalement, la ifcondition garantit que le foreachbloc ne s'exécutera que s'il itemsn'est pas nul. Je me demande si la ifcondition est vraiment nécessaire, ouforeach va gérer le cas si items == null.

Je veux dire, puis-je simplement écrire

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

sans se soucier de savoir si itemsest nul ou non? La ifcondition est-elle superflue? Ou cela dépend du type de itemsou peut-être Taussi?

Vous devez toujours vérifier si (items! = Null) sinon vous obtiendrez NullReferenceException. Cependant, vous pouvez faire quelque chose comme ceci:

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

mais vous pouvez en vérifier les performances. Donc je préfère toujours avoir if (items! = Null) en premier.

Sur la base de la suggestion d'Eric Lippert, j'ai changé le code en:

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

En utilisant C # 6, vous pouvez utiliser le nouvel opérateur conditionnel null avec List<T>.ForEach(Action<T>)(ou votre propre IEnumerable<T>.ForEachméthode d'extension).

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

La vraie chose à retenir ici devrait être qu'une séquence ne devrait presque jamais être nulle en premier lieu . Faites simplement en un invariant dans tous vos programmes que si vous avez une séquence, elle n'est jamais nulle. Il est toujours initialisé pour être la séquence vide ou une autre séquence authentique.

Si une séquence n'est jamais nulle, vous n'avez évidemment pas besoin de la vérifier.

En fait, il y a une demande de fonctionnalité sur ce @Connect: http://connect.microsoft.com/VisualStudio/feedback/details/93497/foreach-should-check-for-null

Et la réponse est assez logique:

Je pense que la plupart des boucles foreach sont écrites dans le but d'itérer une collection non nulle. Si vous essayez d'itérer sur null, vous devriez obtenir votre exception, afin de pouvoir corriger votre code.

Vous pouvez toujours le tester avec une liste nulle ... mais c'est ce que j'ai trouvé sur le site Web de msdn

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

Si expression a la valeur null, une exception System.NullReferenceException est levée.

Ce n'est pas superfleux. Au moment de l'exécution, les éléments seront convertis en un IEnumerable et sa méthode GetEnumerator sera appelée. Cela entraînera un déréférencement des éléments qui échoueront

Vous pouvez encapsuler la vérification null dans une méthode d'extension et utiliser 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);
      }
    }
  }
}

Le code devient:

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

Cela peut être encore plus concis si vous souhaitez simplement appeler une méthode qui prend un élément et renvoie void:

items.ForEach(MethodThatTakesAnItem);

Vous en avez besoin. Vous obtiendrez une exception lorsque vous foreachaccéderez au conteneur pour configurer l'itération dans le cas contraire.

Sous les couvertures, foreachutilise une interface implémentée sur la classe de collection pour effectuer l'itération. L'interface équivalente générique est ici .

L'instruction foreach du langage C # (pour chacun dans Visual Basic) masque la complexité des énumérateurs. Par conséquent, il est recommandé d'utiliser foreach au lieu de manipuler directement l'énumérateur.

Le test est nécessaire, car si la collection est nulle, foreach lèvera une NullReferenceException. C'est en fait assez simple de l'essayer.

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

le second lancera un NullReferenceExceptionavec le messageObject reference not set to an instance of an object.

Comme mentionné ici, vous devez vérifier s'il n'est pas nul.

N'utilisez pas une expression évaluée à null.

En C # 6, vous pouvez écrire qc comme ceci:

// 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)
{
    //..
}

C'est essentiellement la solution de Vlad Bezden mais en utilisant le ?? expression pour toujours générer un tableau qui n'est pas nul et qui survit donc au foreach plutôt que d'avoir cette vérification à l'intérieur du crochet foreach.