Vérifier la valeur nulle dans la boucle foreach

Existe-t-il un moyen plus agréable de faire ce qui suit:
J'ai besoin d'une vérification de la présence de null sur le fichier.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, cela semble un peu moche d'écrire le foreach à l'intérieur du if en raison du niveau d'indentation qui se produit dans mon code.

Est-ce quelque chose qui serait évalué à

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

possible?

Juste comme un léger ajout cosmétique à la suggestion de Rune, vous pouvez 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 pouvez écrire:

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

Changez le nom selon vos goûts :)

En supposant que le type d'éléments dans file.Headers est T, vous pouvez le faire

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

cela créera un énumérable vide de T si file.Headers est nul. Si le type de fichier est un type que vous possédez, j'envisagerais cependant de changer le getter à la Headersplace. nullest 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 en fait (/ à l'origine) devrait être interprété comme "Je ne sais pas s'il y a des éléments", utilisez un ensemble vide pour afficher que vous savez qu'il n'y a aucun élément dans l'ensemble. Ce serait également DRY'er puisque vous n'aurez pas à faire la vérification de null aussi souvent.

EDIT comme suite à la suggestion de Jons, vous pouvez également créer une méthode d'extension en changeant 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 mon préféré car il 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. Plus précisément, ceux qui sont liés à IList en utilisant une surcharge de méthode peuvent être éliminés

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

Franchement, je conseille: il suffit d'aspirer null test. Un nulltest est juste un brfalseou brfalse.s; tout le reste va impliquer beaucoup plus de travail (tests, devoirs, appels de méthodes supplémentaires, inutiles GetEnumerator(), MoveNext(),Dispose() sur le iterator, etc.).

Un iftest est simple, évident et efficace.

le "si" avant l'itération est correct, 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 pour vérifier:

if(file.Headers == null)  
   return;

et vous n'obtiendrez la boucle foreach que s'il y a une valeur vraie dans la propriété headers.

une autre option à laquelle je peux penser consiste à utiliser l'opérateur de fusion null dans votre boucle foreach et d'éviter complètement la vérification null. é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)

Utilisation de l' opérateur conditionnel Null et de ForEach () qui fonctionne plus rapidement que la boucle foreach standard.
Vous devez cependant convertir la collection dans List.

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

J'utilise une jolie petite méthode d'extension pour ces scénarios:

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

Étant donné que les en-têtes sont de type liste, vous pouvez faire ce qui suit:

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

Dans certains cas, je préférerais légèrement une autre variante générique, en supposant que, en règle générale, les constructeurs de collection par défaut renvoient des instances vides.

Il serait préférable de nommer cette méthode NewIfDefault. Cela peut être utile non seulement pour les collections, donc la contrainte de type IEnumerable<T>est peut-être redondante.

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