Vérifier la valeur null dans une boucle foreach

Est-il une plus belle façon de faire les suivants:

J'ai besoin d'un chèque de la valeur null pour arriver sur le fichier.Les en-têtes avant de procéder à la boucle

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

En bref, il ressemble un peu moche d'écrire le foreach à l'intérieur de la si en raison du niveau d'indentation qui se passe dans mon code.

Est quelque chose qui permettrait d'évaluer à

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

possible?

Vous pouvez jetez un oeil ici: stackoverflow.com/questions/6937407/...
stackoverflow.com/questions/872323/... c'est une autre idée.
Je pense que c'est complètement différent. La question vérifie si la collection est nul d'abord avant de faire la for-each. Votre lien vérifie si l'élément de la collection est null.
Similaire à stackoverflow.com/q/3088147/80161 et stackoverflow.com/q/6455311/80161
C# 8 aurait pu se contenter d'un nul conditionnelle foreach, de la sorte, c'est à dire de la syntaxe ressemble à ceci: foreach? (var i dans la collection) { } je pense que c'est un scénario assez pour justifier cela, et compte tenu de la récente null-à condition que les ajouts à la langue qu'il a du sens ici?

InformationsquelleAutor Eminem | 2012-07-31

c#foreach loops null

107

Comme une légère cosmétiques plus de Rune de la suggestion, 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())
{
}
```
Changer le nom selon le goût 🙂
- réponse (à l' "stackoverflow.com/a/32134295/401246" c'est la meilleure solution, parce qu'il n'est pas le cas: a) impliquent une dégradation des performances de l' (même lorsqu'il n'est pas null) dégénérescentes la totalité de la boucle à écran LCD de IEnumerable<T> (comme l'aide ?? serait), b) nécessitent l'ajout d'une Méthode d'Extension pour chaque Projet, ou c) exiger d'éviter null IEnumerables (Pffft! Po-LEAZE! SMH.) pour commencer (cuz null moyen N/A, tandis que la liste vide signifie, c'est applicable, mais est actuellement, bien, il est vide!, c'est à dire un Employé pourrait avoir des Commissions que de N/A pour non-Vente ou de vide pour les Ventes, quand ils ne l'ont pas gagnée).
InformationsquelleAutor Jon Skeet
68

En supposant que le type d'éléments dans le fichier.Les en-têtes est T possible de le faire
```
foreach(var header in file.Headers ?? Enumerable.Empty<T>()){
  //do stuff
}
```
cela va créer un vide énumérable de T si fichier.Les en-têtes est null. Si le type de fichier est un type propre je voudrais, toutefois, envisager de changer le getter de Headers à la place. null est la valeur de inconnu, donc si possible au lieu d'utiliser la valeur null comme "je sais il n'y a pas d'éléments" lorsque la valeur null en fait(/à l'origine) doit être interprété comme "je ne sais pas s'il y a des éléments" utiliser un ensemble vide de montrer que vous savez il n'y a pas d'éléments dans le jeu. Ce serait aussi SEC depuis que vous n'aurez pas à faire le nul de vérifier souvent.

MODIFIER suivi sur Jons suggestion, vous pouvez également créer une méthode d'extension de changer le code ci-dessus pour
```
foreach(var header in file.Headers.OrEmptyIfNull()){
  //do stuff
}
```
Dans le cas où vous ne pouvez pas changer le getter, ce serait mon propre privilégiée parce qu'elle exprime l'intention plus clairement en donnant de l'opération un nom (OrEmptyIfNull)

L'extension de la méthode mentionnée ci-dessus peut rendre certaines optimisations impossible pour l'optimiseur à détecter. Plus précisément, ceux qui sont liés à IList à l'aide de la surcharge de méthode ce risque peut être éliminé
```
public static IList<T> OrEmptyIfNull<T>(this IList<T> source)
{
    return source ?? Array.Empty<T>();
}
```
- réponse (à l' "stackoverflow.com/a/32134295/401246" c'est la meilleure solution, parce qu'il n'est pas le cas: a) impliquent une dégradation des performances de l' (même lorsqu'il n'est pas null) dégénérescentes la totalité de la boucle à écran LCD de IEnumerable<T> (comme l'aide ?? serait), b) nécessitent l'ajout d'une Méthode d'Extension pour chaque Projet, ou c) exiger d'éviter null IEnumerables (Pffft! Po-LEAZE! SMH.) pour commencer (cuz null moyen N/A, tandis que la liste vide signifie, c'est applicable, mais est actuellement, bien, il est vide!, c'est à dire un Employé pourrait avoir des Commissions que de N/A pour non-Vente ou de vide pour les Ventes, quand ils ne l'ont pas gagnée).
- à côté de un null vérifier il n'y a pas de pénalité pour le cas où l'agent recenseur n'est pas nulle. Tout en évitant de le vérifier tout en veillant à ce que l'énumération n'est pas null est impossible. Le code ci-dessus exige que les en-Têtes pour un IEnumerable qui est plus restrictif que le foreach besoins, mais il est moins restrictive que la condition de List<T> dans la réponse que vous liez. Qui ont le même rendement peine de tester si le énumérable est null.
- J'ai fondé la "LCD" question sur le commentaire par Eric Lippert sur Vlad Bezden de Réponse dans le même thread que kjbartel Réponse: "@CodeInChaos: Ah, je vois votre point de maintenant. Lorsque le compilateur ne peut détecter que le "foreach" est une itération sur une Liste<T> ou un tableau alors il peut optimiser le foreach de la valeur d'usage de type agents recenseurs ou effectivement générer une boucle "for". Quand ils sont forcés de les énumérer sur une liste ou une séquence vide, il faut remonter vers le "plus petit dénominateur commun" codegen, qui peut dans certains cas être plus lent et de produire plus de pression sur la mémoire....". D'accord, il nécessite List<T>.
- La prémisse de la réponse est que la fichier.Les en-têtes sont un IEnumerable<T> dans ce cas, le compilateur ne peut pas faire l'optimisation. Il est cependant assez simple à étendre la méthode d'extension de la solution pour éviter cela. Voir modifier
InformationsquelleAutor Rune FS
16

Franchement, je conseille: tout le sucer jusqu'à la null test. Un null test est juste un brfalse ou brfalse.s; tout le reste va impliquer beaucoup plus de travail (tests, de devoirs, de extra les appels de méthode, inutile GetEnumerator(), MoveNext(), Dispose() sur l'itérateur, etc).

Un if test est simple, évidente et efficace.
- Vous faites un point intéressant Marc, cependant, je suis actuellement à la recherche pour réduire les niveaux d'indentation du code. Mais je vais garder votre commentaire à l'esprit quand j'ai besoin de prendre note de performance.
- Juste une petite remarque sur ce Marc.. ans après que j'ai posé cette question et la nécessité de mettre en œuvre certaines des améliorations de performances, de votre conseil, extrêmement pratique. Merci
InformationsquelleAutor Marc Gravell
11

le "si" avant l'itération est très bien, quelques-uns de ces "jolis" sémantique peut rendre votre code moins lisible.

de toute façon, si l'indentation qui perturbe votre, vous pouvez modifier la si la pour vérifier:
```
if(file.Headers == null)  
   return;
```
et vous obtiendrez à la boucle foreach seulement quand il y a la valeur true à la propriété headers.

une autre option que je peux penser est l'aide de l'null-coalescence de l'opérateur à l'intérieur de votre boucle foreach et d'éviter complètement nulle vérification.
exemple:
```
List<int> collection = new List<int>();
collection = null;
foreach (var i in collection ?? Enumerable.Empty<int>())
{
    //your code here
}
```
(remplacer la collecte avec votre véritable objet/type)
- Votre première option ne fonctionnera pas si il n'y a aucun code à l'extérieur de l'instruction if.
- Je suis d'accord, si la déclaration est facile et peu coûteux à mettre en œuvre par rapport à la création d'une nouvelle liste, juste pour le code de l'embellissement.
InformationsquelleAutor Tamir
5

À l'aide de Null-Opérateur conditionnel et ForEach() qui fonctionne plus rapidement que celle de la boucle foreach.

Vous devez lancer la collection à la Liste si.
```
   listOfItems?.ForEach(item => //... );
```
- S'il vous plaît ajouter quelques explications autour de votre réponse, en précisant explicitement pourquoi cette solution fonctionne, plutôt que de simplement un code one-liner
InformationsquelleAutor Andrei Karcheuski
3

Je suis à l'aide d'un joli petit méthode d'extension de 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 est de type liste, vous pouvez effectuer les opérations suivantes:
```
foreach(var h in (file.Headers.EnsureNotNull()))
{
  //do stuff
}
```
- vous pouvez utiliser le ?? de l'opérateur et de raccourcir l'instruction de retour à return list ?? new List<T>;
- Si je comprends bien le tester pour null dans votre échantillon file.Headers.EnsureNotNull() != null n'est pas nécessaire, et est le même problème?
InformationsquelleAutor Wolfgang Ziegler
0

Pour certains cas, je préfère légèrement l'autre, générique variante, en supposant que, en règle générale, le défaut de collecte des constructeurs de retour à vide instances.

Il serait préférable de le nom de cette méthode NewIfDefault. Il peut être utile non seulement pour les collections, afin contrainte de type IEnumerable<T> est peut-être redondant.
```
public static TCollection EmptyIfDefault<TCollection, T>(this TCollection collection)
        where TCollection: class, IEnumerable<T>, new()
    {
        return collection ?? new TCollection();
    }
```
InformationsquelleAutor N. Kudryavtsev

Vous devez vous connecter pour publier un commentaire.