¿Se requiere una verificación nula para el objeto IEnumerable?

Question

var selectedRows = from drow in ugTable.Rows 
         .Cast<Infragistics.Win.UltraWinGrid.UltraGridRow>() 
         .Where(drow => drow != null && drow.Selected) 
        select drow; 

if(selectedRows.Count()==1){//do something with selected rows} 

De la declaración anterior, ¿necesito comprobar Nulo para la variable SelectedRows? selectedRows es una variable IEnumerable.

Answer 1

No necesita comprobar si selectedRows es null. El IEnumerable<> devuelto puede estar vacío, pero nunca será null.

Dicho sea de paso, me gustaría sugerir a simplificar su código escribiendo:

var selectedRows 
    = ugTable.Rows.Cast<Infragistics.Win.UltraWinGrid.UltraGridRow>() 
        .Where(drow => drow != null && drow.Selected); 

que es más corto y equivalente.

Answer 2

La consulta LINQ devolverá una lista vacía (0 elementos), si no hay coincidencias en el lugar.

Por lo tanto, no es necesario comprobar null.

Answer 3

Mi sensación inicial es que no, pero no puede doler.

tengo, de lo que Phil Haack, un método útil extensión que comprueba si un IEnumerable es nulo o vacío ...

/// <summary> 
    /// Determines whether the collection is either null or empty. 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="source">The source collection.</param> 
    /// <returns> 
    ///  <c>true</c> if the collection is null or empty; otherwise, <c>false</c>. 
    /// </returns> 
    public static bool IsNullOrEmpty<T>(this IEnumerable<T> source) 
    { 
     return source == null || !source.Any(); 
    } 

.Any() es mucho más eficiente para comprobar si no está vacío de .Count()

Answer 4

Linq wont retrun NULL. Si desea comprobar algunos datos están ahí se puede ir con Any()

var selectedRows = from drow in ugTable.Rows 
         .Cast<Infragistics.Win.UltraWinGrid.UltraGridRow>() 
         .Where(drow => drow != null && drow.Selected) 
        select drow; 
if(selectedRows .Any()) 
{ 
//your code 
} 

Answer 5

En su ejemplo se le multa usando el método de extensión. Pero si tuviera que implementar su propio método que devolviera un IEnumerable, la respuesta depende de cómo devuelva el resultado.

El siguiente método devuelve un enumerable vacío:

IEnumerable<object> Correct() 
{ 
    yield break; 
} 

El siguiente método sólo devuelve nulo:

IEnumerable<object> Incorrect() 
{ 
    return null; 
} 

llamar a estos métodos dará los siguientes resultados:

Correct().Any(); // returns false 
Incorrect().Any(); // throws ArgumentNullException 

Así tenga cuidado cuando regrese a IEnumerable. Intenta usar la palabra clave yield y siguiendo el patrón correcto.