Jak traktować puste listy, takie jak puste listy w linq?

Question

Poniżej znajduje się kod testowy linqpad. Gdy uruchamia to błędy, ponieważ druga instancja "elementu" ma zerową listę podelementów w przeciwieństwie do pustej listy.

Chciałbym traktować obie sytuacje (pusty lub pusty list) w dokładnie taki sam sposób, ale zastanawiałem się, czy był lepszy sposób niż tylko umieszczenie zerowej kontroli na liście i zainicjowanie pustej listy, gdy jest pusta.

innymi słowy, mogę to zrobić:

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

ale to trochę brzydki i zastanawiałem się jak mogę poprawić na to?

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

jako pytanie dodatkowe, czy to samo zapytanie linq może być przedstawione jako lambda i traktować wartości zerowe w ten sam sposób?

Cheers Chris

Answer 1

Można użyć 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(); 

Ale myślę, że należy po prostu filtrować pustych się

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

Jeśli chodzi o wersję lambda, można powiedzieć:

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

Ale wersja składni zapytań jest o wiele bardziej czytelna.

Answer 2

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

jak o tym?

Answer 3

Można dodać (EVIL) metodę rozszerzenia do pracy dla Ciebie

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

Answer 4

Dodatkowa metoda nie pozwalałaby na wyzerowanie podelementów. Można skonstruować obiekt tak, aby domyślnie był podrzędny względem pustej listy, a następnie nie zezwalał na wartość null w podsieci ustawiającym.

To oczywiście zakłada, że ​​masz dostęp do modyfikacji przedmiotu.

null operator koalescencyjny jest to, czego szukasz, jak podkreślił Hunter Daley