¿Tiene C#IsNullOrEmpty para List/IEnumerable?

Question

Sé que generalmente la lista vacía es más preferible que NULL. Pero voy a devolver NULL, principalmente por dos razones

1. Debo verificar y manejar valores nulos explícitamente, evitando errores y ataques.
2. Es fácil de realizar ?? operación posterior para obtener un valor de retorno.

Para cadenas, tenemos IsNullOrEmpty. ¿Hay algo desde C # que haga lo mismo para List o IEnumerable?

Answer 1

Como todos han dicho, nada está incorporado en el marco, pero si estás usando Castle entonces Castle.Core.Internal lo tiene.

using Castle.Core.Internal;
namespace PhoneNumbers
{
public class PhoneNumberService : IPhoneNumberService
{
public void ConsolidateNumbers(Account accountRequest)
{
if (accountRequest.Addresses.IsNullOrEmpty()) // Addresses is List<T>
{
return;
}
...

Answer 2

Modifiqué la sugerencia de Matthew Vines para evitar la "Enumeración múltiple posible de IEnumerable" - problema. (ver también el comentario de Jon Hanna)

public static bool IsNullOrEmpty(this IEnumerable items)
=> items == null
|| (items as ICollection)?.Count == 0
|| !items.GetEnumerator().MoveNext();

... y la prueba de unidad:

[Test]
public void TestEnumerableEx()
{
List<int> list = null;
Assert.IsTrue(list.IsNullOrEmpty());
list = new List<int>();
Assert.IsTrue(list.IsNullOrEmpty());
list.AddRange(new []{1, 2, 3});
Assert.IsFalse(list.IsNullOrEmpty());
var enumerator = list.GetEnumerator();
for(var i = 1; i <= list.Count; i++)
{
Assert.IsFalse(list.IsNullOrEmpty());
Assert.IsTrue(enumerator.MoveNext());
Assert.AreEqual(i, enumerator.Current);
}
Assert.IsFalse(list.IsNullOrEmpty());
Assert.IsFalse(enumerator.MoveNext());
}

Answer 3

No hay nada incorporado

Sin embargo, es un método de extensión simple:

public static bool IsNullOrEmpty<T>(this IEnumerable<T> enumerable)
{
if(enumerable == null)
return true;
return !enumerable.Any();
}

Answer 4

Si necesita poder recuperar todos los elementos en caso de que no estén vacíos, algunas de las respuestas aquí no funcionarán, porque la llamada a Any() en un enumerable no rewindable "olvidará" un elemento.

Podría tomar un enfoque diferente y convertir los valores nulos en vacíos:

bool didSomething = false;
foreach(var element in someEnumeration ?? Enumerable.Empty<MyType>())
{
//some sensible thing to do on element...
didSomething = true;
}
if(!didSomething)
{
//handle the fact that it was null or empty (without caring which).
}

Del mismo modo (someEnumeration ?? Enumerable.Empty<MyType>()).ToList() etc.

Answer 5

Uniendo las respuestas anteriores en un método de extensión simple para C # 6.0+:

 public static bool IsNullOrEmpty<T>(this IEnumerable<T> me) => !me?.Any() ?? true;

Answer 6

nada en el marco, pero es un método de extensión bastante directo.

Mira aquí

/// <summary>
/// Determines whether the collection is null or contains no elements.
/// </summary>
/// <typeparam name="T">The IEnumerable type.</typeparam>
/// <param name="enumerable">The enumerable, which may be null or empty.</param>
/// <returns>
/// <c>true</c> if the IEnumerable is null or empty; otherwise, <c>false</c>.
/// </returns>
public static bool IsNullOrEmpty<T>(this IEnumerable<T> enumerable)
{
if (enumerable == null)
{
return true;
}
/* If this is a list, use the Count property for efficiency.
* The Count property is O(1) while IEnumerable.Count() is O(N). */
var collection = enumerable as ICollection<T>;
if (collection != null)
{
return collection.Count < 1;
}
return !enumerable.Any();
}

Daniel Vaughan da el paso extra de lanzar a ICollection (donde sea posible) por motivos de rendimiento. Algo que no hubiera pensado hacer.

Answer 7

Actualización tardía : desde C # 6.0, el operador de propagación nula se puede usar para expresar concisión como esta:

if (enumerable?.Any() ?? false)

Nota 1: ?? false ?? false es necesario, por el siguiente motivo (resumen / cita de esta publicación ):

?. el operador devolverá null si un miembro hijo es null . Pero [...] si intentamos obtener un miembro que no sea Nullable , como el método Any() , que devuelve bool [...] el compilador "ajustará" un valor de retorno en Nullable<> . Por ejemplo, Object?.Any() nos dará bool? (que es Nullable<bool> ), no bool . [...] Dado que no se puede convertir implícitamente en bool esta expresión no se puede usar en el if

Nota 2: como una bonificación, la declaración también es "thread-safe" (cita de la respuesta de esta pregunta ):

En un contexto multiproceso, si se puede acceder a [ enumerable ] desde otro subproceso (ya sea porque es un campo accesible o porque está cerrado en un lambda que está expuesto a otro subproceso), el valor podría ser diferente cada vez que se compute [ ieprior null -check ]

Answer 8

var nullOrEmpty = !( list?.Count > 0 );

Answer 9

var nullOrEmpty = list == null || !list.Any();