Überprüfen Sie die foreach-Schleife auf Null

Gibt es eine bessere Möglichkeit, Folgendes zu tun:
Ich muss prüfen, ob in der Datei null vorkommt. Kopfzeilen, bevor ich mit der Schleife fortfahre

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

Kurz gesagt, es sieht ein bisschen hässlich aus, das foreach in das if zu schreiben, da in meinem Code ein Einrückungsgrad auftritt.

Ist etwas, das zu bewerten wäre

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

möglich?

Nur als kleine kosmetische Ergänzung zu Runes Vorschlag können Sie Ihre eigene Erweiterungsmethode erstellen:

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

Dann können Sie schreiben:

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

Ändern Sie den Namen nach Geschmack :)

Angenommen, der Elementtyp in file.Headers ist T, könnten Sie dies tun

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

Dadurch wird eine leere Aufzählung von T erstellt, wenn file.Headers null ist. Wenn der Dateityp ein Typ ist, den Sie besitzen, würde ich jedoch in Betracht ziehen, Headersstattdessen den Getter von zu ändern .nullist der Wert von unknown. Wenn möglich, anstatt null als "Ich weiß, dass es keine Elemente gibt" zu verwenden, wenn null tatsächlich (/ ursprünglich) als "Ich weiß nicht, ob es Elemente gibt" interpretiert werden sollte, verwenden Sie eine leere Menge, um anzuzeigen dass Sie wissen, dass das Set keine Elemente enthält. Das wäre auch DRY'er, da Sie die Nullprüfung nicht so oft durchführen müssen.

BEARBEITEN Als Folge von Jons Vorschlag können Sie auch eine Erweiterungsmethode erstellen, die den obigen Code in ändert

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

In dem Fall, in dem Sie den Getter nicht ändern können, wäre dies meine eigene Präferenz, da es die Absicht klarer ausdrückt, indem Sie der Operation einen Namen geben (OrEmptyIfNull).

Die oben erwähnte Erweiterungsmethode kann es dem Optimierer unmöglich machen, bestimmte Optimierungen zu erkennen. Insbesondere diejenigen, die mit IList in Verbindung stehen, indem diese Methode überladen wird, können eliminiert werden

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

Ehrlich gesagt rate ich: saugen Sie einfach den nullTest auf. Ein nullTest ist nur ein brfalseoder brfalse.s; alles andere wird sich viel mehr Arbeit (Tests, Aufgaben, zusätzliche Methodenaufrufe, unnötige beinhalten GetEnumerator(), MoveNext(), Dispose()auf dem Iterator, etc).

Ein ifTest ist einfach, offensichtlich und effizient.

Das "Wenn" vor der Iteration ist in Ordnung, nur wenige dieser "hübschen" Semantiken können Ihren Code weniger lesbar machen.

Wenn die Einrückung Sie stört, können Sie das zu ändernde if ändern:

if(file.Headers == null)  
   return;

und Sie gelangen nur dann zur foreach-Schleife, wenn die Eigenschaft headers einen wahren Wert enthält.

Eine andere Option, über die ich nachdenken kann, ist die Verwendung des Null-Koaleszenz-Operators in Ihrer foreach-Schleife und die vollständige Vermeidung der Nullprüfung. Stichprobe:

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

(Ersetzen Sie die Sammlung durch Ihr wahres Objekt / Ihren wahren Typ)

Verwenden des nullbedingten Operators und von ForEach (), die schneller als die Standard-foreach-Schleife arbeiten.
Sie müssen die Sammlung jedoch in List umwandeln.

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

Ich verwende eine nette kleine Erweiterungsmethode für diese Szenarien:

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

Da es sich bei den Headern um eine Typliste handelt, können Sie Folgendes tun:

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

In einigen Fällen würde ich eine etwas andere generische Variante bevorzugen, vorausgesetzt, dass Standardauflistungskonstruktoren in der Regel leere Instanzen zurückgeben.

Es wäre besser, diese Methode zu benennen NewIfDefault. Dies kann nicht nur für Sammlungen nützlich sein, daher IEnumerable<T>ist die Typbeschränkung möglicherweise redundant.

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