retorno a cero para Count() en IEnumerables nulos

Question

Me estoy cansando de usar un código como éste:

var count = 0; 
if (myEnumerable != null) 
{ 
    count = myEnumerable.Count(); 
} 

Y esto es un poco pedante:

var count = (myEnumerable ?? new string[0]).Count(); 

¿Hay alguna manera más ordenada de ¿haciendo esto? Una vez tuve un método de extensión PhantomCount (mal nombrado) en IEnumerable <> que usaba mi primer ejemplo de código, pero tenía algo de olor (además del nombre).

Answer 1

El problema es realmente en lo que está creando estos enumerables. A menos que tenga una buena razón, cualquier cosa que genere una colección iterable debería devolver una colección vacía en lugar de null. Esto se alinearía con el Null-Object-Pattern, por lo tanto, los beneficios son los mismos.

Mi sugerencia sería la de arreglar lo que produce myEnumerable, o si no puede hacerlo, agregue un control de manera antes para ver si es nulo y reaccionan de forma adecuada.

Answer 2

¿Qué tal

count = myEnumerable == null? 0 : myEnumerable.Count() 

Answer 3

No creo que usar el método de extensión sea una mala idea.

public static int NullableCount<T>(this IEnumerable<T> collection) 
{ 
    return collection == null ? 0 : collection.Count(); 
} 

Answer 4

Simplemente crea tu propio método de extensión que maneje enumeradores nulos como desees.

public int CountOrNull<T>(this IEnumerable<T> source) 
{ 
    return source == null ? 0 : source.Count(); 
} 

continuación, puede simplemente usar:

var list1 = new int[] { 1, 2, 3, 4 }; 
var list2 = (int[])null; 

var count1 = list1.CountOrNull(); // 4 
var count2 = list2.CountOrNull(); // 0 

Esa es la gran cosa acerca de los métodos de extensión. Todavía funcionan bien incluso si el objeto sobre el que llama (al parecer) llama al null.

Answer 5

También escribiría mi propio método de extensión CountOrZeroForNull, como se muestra en otras respuestas.

Además ... En lugar de:

var count = (myEnumerable ?? new string[0]).Count(); 
          // ^^^^^^^^^^^^^ 

se podría escribir:

var count = (myEnumerable ?? Enumerable.Empty<string>()).Count(); 
          // ^^^^^^^^^^^^^^^^^^^^^^^^^^ 

Esto no soluciona su problema específico, pero elude la asignación de una matriz sin utilizar. (Enumerable.Empty<T> es más probable implementarse como un simple yield break comunicado.)

Answer 6

var count = 0; 

if (myEnumerable != null) 
    count = myEnumerable.Count(); 

Si bien no es tan técnico como las otras respuestas, es mucho más fácil de leer.

Answer 7

¿Qué medidas está tomando si el valor devuelto es 0?

Si eso es lo interesante, tal vez usted debe usar el método IsNullOrEmpty extensión de Haack para IEnumerable así:

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

El enlace es http://haacked.com/archive/2010/06/10/checking-for-empty-enumerations.aspx

publicado como un comentario en el blog, también encontrará una clase Exception escribí para ir con eso:

public class ArgumentNullOrEmptyException : ArgumentNullException 
{ 
    public ArgumentNullOrEmptyException(string paramName) : base(paramName) 
    {} 

    public ArgumentNullOrEmptyException(string paramName, string message) : base(paramName, message) 
    {} 

    public override string Message 
    { 
     get 
     { 
      return "Value cannot be null nor empty.{0}Parameter name: {1}".FormatWith(Environment.NewLine, ParamName); 
     } 
    } 
} 

Answer 8

Puedo utilizar una extensi personalizada en el método:

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

... 

int count = myEnumerable.EmptyIfNull().Count();