Ist if (items! = Null) vor foreach überflüssig (T item in items)?

Ich stoße oft auf folgenden Code:

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

Grundsätzlich stellt die ifBedingung sicher, dass der foreachBlock nur ausgeführt wird, wenn er itemsnicht null ist. Ich frage mich, ob die ifBedingung wirklich benötigt wird oder foreachob der Fall behandelt wird, wenn items == null.

Ich meine, kann ich einfach schreiben

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

ohne sich Gedanken darüber zu machen, ob itemsnull ist oder nicht? Ist der ifZustand überflüssig? Oder dies hängt von der Art der itemsoder vielleicht auf Tso gut?

Sie müssen noch prüfen, ob (items! = Null), sonst erhalten Sie die NullReferenceException. Sie können jedoch Folgendes tun:

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

Sie können jedoch die Leistung überprüfen. Also bevorzuge ich es immer noch, wenn (items! = Null) zuerst zu haben.

Aufgrund von Erics Lippert-Vorschlag habe ich den Code geändert in:

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

Mit C # 6 können Sie den neuen bedingten Nulloperator zusammen mit List<T>.ForEach(Action<T>)(oder Ihrer eigenen IEnumerable<T>.ForEachErweiterungsmethode) verwenden.

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

Das eigentliche Mitnehmen hier sollte eine Sequenz sein, die fast nie null sein sollte . Machen Sie es einfach in allen Ihren Programmen zu einer Invariante, dass eine Sequenz niemals null ist, wenn Sie sie haben. Es wird immer als leere Sequenz oder eine andere echte Sequenz initialisiert.

Wenn eine Sequenz niemals null ist, müssen Sie sie natürlich nicht überprüfen.

Tatsächlich gibt es auf diesem @Connect eine Funktionsanforderung: http://connect.microsoft.com/VisualStudio/feedback/details/93497/foreach-should-check-for-null

Und die Antwort ist ganz logisch:

Ich denke, dass die meisten foreach-Schleifen mit der Absicht geschrieben wurden, eine Nicht-Null-Sammlung zu iterieren. Wenn Sie versuchen, null zu durchlaufen, sollten Sie Ihre Ausnahme erhalten, damit Sie Ihren Code reparieren können.

Sie könnten es immer mit einer Nullliste testen ... aber das habe ich auf der msdn-Website gefunden

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

Wenn expression den Wert null hat, wird eine System.NullReferenceException ausgelöst.

Es ist nicht überflüssig. Zur Laufzeit werden Elemente in eine IEnumerable umgewandelt und die GetEnumerator-Methode aufgerufen. Dies führt zu einer Dereferenzierung von Elementen, die fehlschlagen

Sie können die Nullprüfung in eine Erweiterungsmethode einkapseln und ein Lambda verwenden:

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);
      }
    }
  }
}

Der Code wird:

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

If kann noch präziser sein, wenn Sie nur eine Methode aufrufen möchten, die ein Element nimmt und zurückgibt void:

items.ForEach(MethodThatTakesAnItem);

Du brauchst das. Beim foreachZugriff auf den Container wird eine Ausnahme angezeigt, um die Iteration anderweitig einzurichten.

Unter den Abdeckungen, foreachverwendet eine Schnittstelle für die Sammlung Klasse implementiert , um die Iteration durchzuführen. Die generische äquivalente Schnittstelle ist hier .

Die foreach-Anweisung der C # -Sprache (für jede in Visual Basic) verbirgt die Komplexität der Enumeratoren. Daher wird empfohlen, foreach zu verwenden, anstatt den Enumerator direkt zu manipulieren.

Der Test ist erforderlich, denn wenn die Auflistung null ist, löst foreach eine NullReferenceException aus. Es ist eigentlich ganz einfach, es auszuprobieren.

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

Der zweite wird ein NullReferenceExceptionmit der Nachricht werfenObject reference not set to an instance of an object.

Wie hier erwähnt , müssen Sie überprüfen, ob es nicht null ist.

Verwenden Sie keinen Ausdruck, der null ergibt.

In C # 6 können Sie etw wie folgt schreiben:

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

Es ist im Grunde Vlad Bezdens Lösung, aber mit dem ?? Ausdruck, um immer ein Array zu generieren, das nicht null ist und daher die foreach überlebt, anstatt diese Prüfung in der foreach-Klammer zu haben.