Come si gestiscono gli elenchi Null come elenchi vuoti in linq?

Question

Di seguito è riportato un codice di prova per linqpad. Quando viene eseguito questo errore, la seconda istanza di "elemento" ha un elenco nullo di elementi secondari rispetto a un elenco vuoto.

Voglio trattare entrambe le situazioni (elenco nullo o vuoto) esattamente nello stesso modo, ma mi chiedevo se c'era un modo più pulito di mettere semplicemente un controllo Null sulla lista e inizializzare una lista vuota quando c'è un null.

in altre parole, avrei potuto fare questo:

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

ma questo è un po 'brutto e mi chiedevo come avrei potuto migliorare su questo?

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

come una questione bonus, può questa stessa query LINQ essere rappresentato come un lambda e trattare i null allo stesso modo?

Cheers, Chris

Answer 1

È possibile utilizzare il 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(); 

Ma penso che si dovrebbe solo filtrare i vuoti fuori

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

Come per una versione lambda si potrebbe dire

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

Ma la versione della sintassi della query è molto più leggibile.

Answer 2

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

Che ne dici?

Answer 3

Si potrebbe aggiungere una (male) metodo di estensione per fare il lavoro per voi

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

Answer 4

Un metodo addizionale non è quello di consentire che i valori secondari siano nulli. È possibile creare il costruttore dell'elemento in modo che assuma automaticamente un elemento secondario in una lista vuota e quindi non consentire il null nel subitem setter.

Questo ovviamente presuppone che si abbia accesso a modificare l'elemento.

L'operatore null coalescenza è quello che stai cercando, come sottolineato da Hunter Daley