Vérifier les nullités dans la boucle foreach

Question

Existe-t-il une façon plus agréable de faire ce qui suit :
J'ai besoin d'une vérification de nullité sur file.Headers avant de poursuivre la boucle.

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

En bref, il est un peu laid d'écrire le foreach à l'intérieur du if en raison du niveau d'indentation de mon code.

C'est quelque chose qui évaluerait à

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

possible ?

Answer 1

Pour compléter la suggestion de Rune, vous pourriez créer votre propre méthode d'extension :

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

Ensuite, vous pourrez écrire :

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

Changez le nom selon vos goûts :)

Answer 2

En supposant que le type d'éléments dans file.Headers soit T, vous pourriez faire ceci

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

ceci créera un énumérable vide de T si file.Headers est null. Si le type de fichier est un type que vous possédez, j'envisagerais cependant de modifier le getter de Headers à la place. null est la valeur de unknown, donc si possible, au lieu d'utiliser null comme "Je sais qu'il n'y a pas d'éléments" alors que null devrait en fait (/originalement) être interprété comme "Je ne sais pas s'il y a des éléments", utilisez un ensemble vide pour montrer que vous savez qu'il n'y a pas d'éléments dans l'ensemble. Cela serait également DRY'er puisque vous n'aurez pas à faire la vérification de null aussi souvent.

EDITAR pour donner suite à la suggestion de Jons, vous pourriez également créer une méthode d'extension en modifiant le code ci-dessus en

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

Dans le cas où vous ne pouvez pas changer le getter, ce serait ma propre préférence car elle exprime l'intention plus clairement en donnant un nom à l'opération (OrEmptyIfNull).

La méthode d'extension mentionnée ci-dessus peut rendre certaines optimisations impossibles à détecter par l'optimiseur. Spécifiquement, celles qui sont liées à IList en utilisant la surcharge de méthode cela peut être éliminé

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

Answer 3

Franchement, je conseille : juste de sucer le null test. A null le test est juste a brfalse o brfalse.s tout le reste va impliquer beaucoup plus de travail (tests, devoirs, appels de méthodes supplémentaires, inutiles, etc. GetEnumerator() , MoveNext() , Dispose() sur l'itérateur, etc).

Un site if Le test est simple, évident et efficace.

Answer 4

Utilisation de Opérateur conditionnel nul et ForEach() qui fonctionne plus rapidement que la boucle foreach standard.
Vous devez cependant lancer la collection sur la liste.

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

Answer 5

Le "if" avant l'itération est bien, peu de ces "jolies" sémantiques peuvent rendre votre code moins lisible.

de toute façon, si l'indentation vous dérange, vous pouvez changer le if en check :

if(file.Headers == null)  
   return;

et vous n'arriverez à la boucle foreach que lorsqu'il y aura une valeur vraie à la propriété headers.

Une autre option à laquelle je peux penser est d'utiliser l'opérateur de coalescence des nullités dans votre boucle foreach et d'éviter complètement la vérification des nullités. échantillon :

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

(remplacez la collection par votre véritable objet/type)