¿cómo trato las listas nulas como listas vacías en linq?

Question

A continuación se muestra un código de prueba de linqpad. Cuando esto se ejecuta errores, porque la segunda instancia de "elemento" tiene una lista nula de subelementos en lugar de una lista vacía.

Quiero tratar ambas situaciones (lista vacía o nula) exactamente de la misma manera, pero me preguntaba si había una manera más limpia que simplemente poner una verificación nula en la lista e inicializar una lista vacía cuando hay un nulo.

en otras palabras, que podría hacer esto:

from si in (i.subitems == null ? new List<item>() : i.subitems) 

pero eso es un poco feo y me preguntaba cómo podría mejorar en eso?

public class item 
{ 
    public string itemname { get; set; } 
    public List<item> subitems { get; set; } 
} 

void Main() 
{ 
    List<item> myItemList = new List<item>() 
    { 
     new item 
     { 
      itemname = "item1", 
      subitems = new List<item>() 
      { 
       new item { itemname = "subitem1" }, 
       new item { itemname = "subitem2" } 
      } 
     }, 
     new item 
     { 
      itemname = "item2" 
     } 
    }; 

    myItemList.Dump(); 

    var res = (from i in myItemList 
      from si in i.subitems 
      select new {i.itemname, subitemname = si.itemname}).ToList(); 

    res.Dump(); 
} 

como una pregunta extra, puede esta misma consulta LINQ puede representar como un lambda y tratar los nulos de la misma manera?

Saludos, Chris

Answer 1

Se podría utilizar el null coalescing operator

var res = (from i in myItemList 
      from si in i.subitems ?? new List<item>() 
      select new { i.itemname, subitemname = si.itemname }).ToList(); 

Pero creo que sólo debe filtrar las vacías a cabo

var res = (from i in myItemList 
      where i.subitems != null 
      from si in i.subitems 
      select new { i.itemname, subitemname = si.itemname }).ToList(); 

En cuanto a una versión lambda, podría decir

var res = myItemList.Where(x => x.subitems != null) 
        .SelectMany(
         x => x.subitems.Select(
          y => new { x.itemname, subitemname = y.itemname } 
         ) 
        ); 

Pero la versión de sintaxis de la consulta es mucho más leíble.

Answer 2

from si in (i.subitems ?? new List<item>()) 

¿qué tal?

Answer 3

Se podría añadir un (mal) método de extensión para hacer el trabajo para usted

public static IEnumerable<T> EnsureNotEmpty<T>(this IEnumerable<T> enumerable) { 
    if (enumerable == null) { 
    return Enumerable.Empty<T>(); 
    } else { 
    return enumerable; 
    } 
} 

Answer 4

Un método adicional sería no permitir que los subelementos sean nulos. Puede hacer que el constructor del elemento establezca de manera predeterminada el subelemento en una lista vacía y luego no permita el nulo en el establecedor de subtemas.

Por supuesto, se supone que tiene acceso para modificar el elemento.

El operador coalescente nula es lo que busca como se ha señalado por Hunter Daley