¿Existe un singleton de "Lista vacía" en C #?

En C # uso LINQ e IEnumerable un poco. Y todo está bien y bien (o al menos en su mayor parte).

Sin embargo, en muchos casos me encuentro que necesito un vacío IEnumerable<X>por defecto. Es decir, me gustaria

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

para trabajar sin necesidad de una verificación nula. Ahora, esto es lo que hago actualmente, dependiendo del contexto más amplio:

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

Ahora, aunque lo anterior está perfectamente bien para mí , es decir, si hay alguna "sobrecarga adicional" con la creación del objeto de matriz, simplemente no me importa , me preguntaba:

¿Hay singleton "IEnumerable / IList inmutable vacío" en C # /. NET? (E, incluso si no es así, ¿existe una forma "mejor" de manejar el caso descrito anteriormente?)

Java tiene Collections.EMPTY_LISTsingleton inmutable - "bien escrito" vía Collections.emptyList<T>()- que sirve para este propósito, aunque no estoy seguro de si un concepto similar podría funcionar en C # porque los genéricos se manejan de manera diferente.

Gracias.

Que está buscando Enumerable.Empty<T>().

En otras noticias, la lista vacía de Java apesta porque la interfaz List expone métodos para agregar elementos a la lista que arrojan excepciones.

Enumerable.Empty<T>() es exactamente eso.

Creo que estás buscando Enumerable.Empty<T>().

Singleton de lista vacía no tiene mucho sentido, porque las listas a menudo son mutables.

En su ejemplo original, usa una matriz vacía para proporcionar un enumerable vacío. Si bien usar Enumerable.Empty<T>()es perfectamente correcto, puede haber otros casos: si tiene que usar una matriz (o la IList<T>interfaz), puede usar el método

System.Array.Empty<T>()

lo que le ayuda a evitar asignaciones innecesarias.

Notas / referencias:

• la documentación no menciona que este método asigna la matriz vacía solo una vez para cada tipo
• Los analizadores roslyn recomiendan este método con la advertencia CA1825: Evite las asignaciones de arreglos de longitud cero
• Implementación de referencia de Microsoft
• Implementación de .NET Core

Creo que agregar un método de extensión es una alternativa limpia gracias a su capacidad para manejar nulos, algo como:

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

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

Microsoft implementó 'Any ()' así ( fuente )

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

Si desea guardar una llamada en la pila de llamadas, en lugar de escribir un método de extensión que llame !Any(), simplemente vuelva a escribir y realice estos tres cambios:

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
}

Usar Enumerable.Empty<T>()con listas tiene un inconveniente. Si realiza la mano Enumerable.Empty<T>en el constructor de la lista, se asigna una matriz de tamaño 4. Pero si entrega un vacío Collectionen el constructor de la lista, no se produce ninguna asignación. Entonces, si usa esta solución en todo su código, lo más probable es que uno de los IEnumerables se use para construir una lista, lo que resultará en asignaciones innecesarias.