Führen Sie zwei (oder mehr) Listen in C # .NET zu einer zusammen

Ist es möglich, zwei oder mehr Listen in .NET mit C # in eine einzige Liste zu konvertieren?

Beispielsweise,

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

Sie können den LINQ Concatund die ToListMethoden verwenden:

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

Beachten Sie, dass es effizientere Möglichkeiten gibt, dies zu tun. Im Folgenden werden grundsätzlich alle Einträge durchlaufen, wodurch ein Puffer mit dynamischer Größe erstellt wird. Wie Sie die Größe , mit zu beginnen vorhersagen können, brauchen Sie nicht diese dynamische Dimensionierung ... so Sie könnten verwenden:

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

( AddRangeist speziell ICollection<T>für Effizienz ausgelegt.)

Ich würde diesen Ansatz nicht wählen, wenn Sie es nicht wirklich müssen.

Angenommen, Sie möchten eine Liste mit allen Produkten für die angegebenen Kategorie-IDs, können Sie Ihre Abfrage als Projektion behandeln, gefolgt von einem Reduzierungsvorgang . Es gibt einen LINQ-Operator, der das macht : SelectMany.

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

In C # 4 können Sie SelectMany verkürzen auf: .SelectMany(GetAllProducts)

Wenn Sie bereits Listen haben, die die Produkte für jede ID darstellen, benötigen Sie eine Verkettung , wie andere betonen.

Sie können sie mit LINQ kombinieren:

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

Der traditionellere Ansatz der Verwendung List.AddRange()könnte jedoch effizienter sein.

Schauen Sie sich List.AddRange an, um Listen zusammenzuführen

Sie können die Concat- Erweiterungsmethode verwenden:

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

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

Ich weiß, dass dies eine alte Frage ist, von der ich dachte, ich könnte nur meine 2 Cent hinzufügen.

Wenn Sie eine haben List<Something>[], können Sie sie mit verbindenAggregate

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

    return result;
}

Hoffe das hilft.

Ich habe es bereits kommentiert, aber ich denke immer noch, dass es eine gültige Option ist. Testen Sie einfach, ob in Ihrer Umgebung die eine oder andere Lösung besser ist. In meinem speziellen Fall ist die Verwendung source.ForEach(p => dest.Add(p))besser als der Klassiker, AddRangeaber ich habe nicht untersucht, warum dies auf niedrigem Niveau der Fall ist .

Einen Beispielcode finden Sie hier: https://gist.github.com/mcliment/4690433

Die Option wäre also:

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

Testen Sie es, um zu sehen, ob es für Sie funktioniert.

Haftungsausschluss : Ich befürworte diese Lösung nicht, ich finde Concatdie klarste. Ich habe gerade in meiner Diskussion mit Jon festgestellt, dass dieser Fall in meiner Maschine eine bessere Leistung erbringt als AddRange, aber er sagt mit weitaus mehr Wissen als ich, dass dies keinen Sinn ergibt. Es gibt das Wesentliche, wenn Sie vergleichen möchten.

// I would make it a little bit more simple

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

Auf diese Weise handelt es sich um eine mehrdimensionale Liste, und .SelectMany () reduziert sie in eine IEnumerable von Produkten. Anschließend verwende ich die Methode .ToList ().

Zusammenführen oder Kombinieren zu Listen zu einer Ein-Liste.

• Eines muss zutreffen: Der Typ beider Listen ist gleich.

• Zum Beispiel : Wenn wir eine Liste von haben string, können wir der vorhandenen Liste eine weitere Liste hinzufügen, die eine Liste mit Typzeichenfolgen enthält, andernfalls können wir dies nicht.

Beispiel :

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

   }
}

Im Sonderfall: "Alle Elemente von List1 gehen in eine neue List2": (zB eine String-Liste)

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

In diesem Fall wird list2 mit allen Elementen aus list1 generiert.

Sie müssen den Concat-Betrieb verwenden

Wenn Sie nur wenige Listen haben, aber nicht genau wissen, wie viele, verwenden Sie Folgendes:

listsOfProducts enthält nur wenige mit Objekten gefüllte Listen.

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

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