Scal dwie (lub więcej) listy w jedną, w języku C # .NET

Czy można przekonwertować dwie lub więcej list na jedną listę w .NET przy użyciu C #?

Na przykład,

public static List<Product> GetAllProducts(int categoryId){ .... }
.
.
.
var productCollection1 = GetAllProducts(CategoryId1);
var productCollection2 = GetAllProducts(CategoryId2);
var productCollection3 = GetAllProducts(CategoryId3);

Możesz użyć LINQ Concati ToListmetod:

var allProducts = productCollection1.Concat(productCollection2)
                                    .Concat(productCollection3)
                                    .ToList();

Zauważ, że istnieją bardziej wydajne sposoby na zrobienie tego - powyższe będzie zasadniczo przechodzić przez wszystkie wpisy, tworząc bufor o dynamicznym rozmiarze. Jak można przewidzieć wielkość na początek, nie trzeba tego rozmiaru dynamicznego ... więc mógł używać:

var allProducts = new List<Product>(productCollection1.Count +
                                    productCollection2.Count +
                                    productCollection3.Count);
allProducts.AddRange(productCollection1);
allProducts.AddRange(productCollection2);
allProducts.AddRange(productCollection3);

( AddRangejest specjalnie zaprojektowany ICollection<T>dla zwiększenia wydajności).

Nie przyjąłbym tego podejścia, chyba że naprawdę musisz.

Zakładając, że potrzebujesz listy zawierającej wszystkie produkty dla określonych kategorii ID, możesz potraktować swoje zapytanie jako rzut, po którym nastąpi operacja spłaszczenia . Jest operatorem LINQ to robi, że: SelectMany.

// implicitly List<Product>
var products = new[] { CategoryId1, CategoryId2, CategoryId3 }
                     .SelectMany(id => GetAllProducts(id))
                     .ToList();

W C # 4 możesz skrócić SelectMany do: .SelectMany(GetAllProducts)

Jeśli masz już listy reprezentujące produkty dla każdego identyfikatora, to potrzebujesz , jak konkatenacja , jak podkreślają inni.

możesz je połączyć za pomocą LINQ:

  list = list1.Concat(list2).Concat(list3).ToList();

bardziej tradycyjne podejście List.AddRange()może być jednak bardziej wydajne.

Spójrz na List.AddRange, aby scalić listy

Możesz użyć metody rozszerzenia Concat :

var result = productCollection1
    .Concat(productCollection2)
    .Concat(productCollection3)
    .ToList();

list4 = list1.Concat(list2).Concat(list3).ToList();

Wiem, że to stare pytanie, pomyślałem, że mogę dodać 2 centy.

Jeśli masz List<Something>[], możesz do nich dołączyć za pomocąAggregate

public List<TType> Concat<TType>(params List<TType>[] lists)
{
    var result = lists.Aggregate(new List<TType>(), (x, y) => x.Concat(y).ToList());

    return result;
}

Mam nadzieję że to pomoże.

Już to skomentowałem, ale nadal uważam, że jest to prawidłowa opcja, po prostu sprawdź, czy w twoim środowisku jest lepsze jedno lub drugie rozwiązanie. W moim szczególnym przypadku używanie source.ForEach(p => dest.Add(p))działa lepiej niż klasyczny, AddRangeale nie badałem, dlaczego na niskim poziomie.

Przykładowy kod możesz zobaczyć tutaj: https://gist.github.com/mcliment/4690433

Tak więc opcją byłoby:

var allProducts = new List<Product>(productCollection1.Count +
                                    productCollection2.Count +
                                    productCollection3.Count);

productCollection1.ForEach(p => allProducts.Add(p));
productCollection2.ForEach(p => allProducts.Add(p));
productCollection3.ForEach(p => allProducts.Add(p));

Przetestuj, aby sprawdzić, czy to działa dla Ciebie.

Oświadczenie : Nie opowiadam się za tym rozwiązaniem, uważam, że jest Concatto najbardziej jasne. Właśnie powiedziałem - w mojej dyskusji z Jonem - że w mojej maszynie ta sprawa działa lepiej niż AddRange, ale on, przy znacznie większej wiedzy niż ja, że ​​to nie ma sensu. Jest sedno, jeśli chcesz porównać.

// I would make it a little bit more simple

 var products = new List<List<product>> {item1, item2, item3 }.SelectMany(id => id).ToList();

W ten sposób jest to wielowymiarowa lista, a .SelectMany () spłaszczy ją do IEnumerable produktu, a następnie użyję metody .ToList ().

Aby scalić lub połączyć z listami w jedną listę.

• Jest jedna rzecz, która musi być prawdziwa: typ obu list będzie równy.

• Na przykład : jeśli mamy listę, stringwięc możemy dodać kolejną listę do istniejącej listy, która ma listę ciągów znaków, inaczej nie możemy.

Przykład :

class Program
{
   static void Main(string[] args)
   {
      List<string> CustomerList_One = new List<string> 
      {
         "James",
         "Scott",
         "Mark",
         "John",
         "Sara",
         "Mary",
         "William",
         "Broad",
         "Ben",
         "Rich",
         "Hack",
         "Bob"
      };

      List<string> CustomerList_Two = new List<string> 
      {
         "Perter",
         "Parker",
         "Bond",
         "been",
         "Bilbo",
         "Cooper"
      };

      // Adding all contents of CustomerList_Two to CustomerList_One.
      CustomerList_One.AddRange(CustomerList_Two);

      // Creating another Listlist and assigning all Contents of CustomerList_One.
      List<string> AllCustomers = new List<string>();

      foreach (var item in CustomerList_One)
      {
         AllCustomers.Add(item);
      }

      // Removing CustomerList_One & CustomerList_Two.
      CustomerList_One = null;

      CustomerList_Two = null;
      // CustomerList_One & CustomerList_Two -- (Garbage Collected)
      GC.Collect();

      Console.WriteLine("Total No. of Customers : " +  AllCustomers.Count());
      Console.WriteLine("-------------------------------------------------");
      foreach (var customer in AllCustomers)
      {
         Console.WriteLine("Customer : " + customer);
      }
      Console.WriteLine("-------------------------------------------------");

   }
}

W szczególnym przypadku: „Wszystkie elementy List1 trafiają do nowej List2”: (np. Lista ciągów)

List<string> list2 = new List<string>(list1);

W takim przypadku lista 2 jest generowana ze wszystkimi elementami z listy 1.

Musisz użyć operacji Concat

Gdy masz kilka list, ale nie wiesz ile dokładnie, użyj tego:

listsOfProducts zawiera kilka list wypełnionych obiektami.

List<Product> productListMerged = new List<Product>();

listsOfProducts.ForEach(q => q.ForEach(e => productListMerged.Add(e)));