Gibt es in C # einen Singleton "Leere Liste"?

In C # verwende ich LINQ und IEnumerable ein gutes Stück. Und alles ist gut und schön (oder zumindest meistens).

In vielen Fällen stelle ich jedoch fest, dass ich IEnumerable<X>standardmäßig ein Leerzeichen benötige . Das heißt, ich würde gerne

for (var x in xs) { ... }

zu arbeiten, ohne eine Nullprüfung zu benötigen. Dies ist, was ich derzeit mache, abhängig vom größeren Kontext:

var xs = f() ?? new X[0];              // when xs is assigned, sometimes
for (var x in xs ?? new X[0]) { ... }  // inline, sometimes

Nun, obwohl das oben Genannte für mich vollkommen in Ordnung ist - das heißt, wenn es beim Erstellen des Array-Objekts einen "zusätzlichen Aufwand" gibt, ist es mir einfach egal -, habe ich mich gefragt:

Gibt es in C # /. NET den Singleton "leerer unveränderlicher IEnumerable / IList"? (Und selbst wenn nicht, gibt es eine "bessere" Möglichkeit, den oben beschriebenen Fall zu behandeln?)

Java hat einen Collections.EMPTY_LISTunveränderlichen Singleton - "gut typisiert" über Collections.emptyList<T>()-, der diesem Zweck dient, obwohl ich nicht sicher bin, ob ein ähnliches Konzept überhaupt in C # funktionieren könnte, da Generika anders behandelt werden.

Vielen Dank.

Sie suchen Enumerable.Empty<T>().

In anderen Nachrichten ist die leere Java-Liste zum Kotzen, weil die List-Schnittstelle Methoden zum Hinzufügen von Elementen zur Liste bereitstellt, die Ausnahmen auslösen.

Enumerable.Empty<T>() ist genau das.

Ich denke du suchst Enumerable.Empty<T>().

Ein Singleton mit leeren Listen macht nicht so viel Sinn, da Listen oft veränderlich sind.

In Ihrem ursprünglichen Beispiel verwenden Sie ein leeres Array, um eine leere Aufzählung bereitzustellen. Bei der Verwendung von Enumerable.Empty<T>()rechts ist perfekt, es könnten auch andere Fälle: Wenn Sie verwenden müssen ein Array (oder die IList<T>Schnittstelle), können Sie die Methode verwenden ,

System.Array.Empty<T>()

Dies hilft Ihnen, unnötige Zuordnungen zu vermeiden.

Anmerkungen / Referenzen:

• In der Dokumentation wird nicht erwähnt, dass diese Methode das leere Array für jeden Typ nur einmal zuweist
• Roslyn-Analysatoren empfehlen diese Methode mit der Warnung CA1825: Vermeiden Sie Array-Zuordnungen mit der Länge Null
• Microsoft- Referenzimplementierung
• .NET Core-Implementierung

Ich denke, das Hinzufügen einer Erweiterungsmethode ist eine saubere Alternative, da sie mit Nullen umgehen können - so etwas wie:

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

  foreach(var x in xs.EmptyIfNull())
  {
    ...
  }

Microsoft hat "Any ()" wie folgt implementiert ( Quelle )

public static bool Any<TSource>(this IEnumerable<TSource> source)
{
    if (source == null) throw new ArgumentNullException("source");
    using (IEnumerator<TSource> e = source.GetEnumerator())
    {
        if (e.MoveNext()) return true;
    }
    return false;
}

Wenn Sie einen Aufruf auf dem Aufrufstapel speichern möchten, anstatt eine aufrufende Erweiterungsmethode zu !Any()schreiben, schreiben Sie diese drei Änderungen einfach neu:

public static bool IsEmpty<TSource>(this IEnumerable<TSource> source) //first change (name)
{
    if (source == null) throw new ArgumentNullException("source");
    using (IEnumerator<TSource> e = source.GetEnumerator())
    {
        if (e.MoveNext()) return false; //second change
    }
    return true; //third change
}

Die Verwendung Enumerable.Empty<T>()mit Listen hat einen Nachteil. Wenn Sie Enumerable.Empty<T>den Listenkonstruktor übergeben, wird ein Array der Größe 4 zugewiesen. Wenn Sie dem Listenkonstruktor jedoch ein CollectionLeerzeichen übergeben, erfolgt keine Zuordnung. Wenn Sie diese Lösung im gesamten Code verwenden, wird höchstwahrscheinlich eines der IEnumerables zum Erstellen einer Liste verwendet, was zu unnötigen Zuordnungen führt.