Unisci due (o più) elenchi in uno, in C # .NET

È possibile convertire due o più elenchi in un unico elenco, in .NET usando C #?

Per esempio,

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

È possibile utilizzare LINQ Concate ToListmetodi:

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

Si noti che esistono modi più efficienti per eseguire questa operazione: quanto sopra sostanzialmente eseguirà il ciclo di tutte le voci, creando un buffer di dimensioni dinamiche. Come si può prevedere le dimensioni per cominciare, non è necessario questo dimensionamento dinamico ... così si potrebbe usare:

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

( AddRangeè speciale ICollection<T>per efficienza.)

Non prenderei questo approccio a meno che tu non debba davvero farlo.

Supponendo che si desideri un elenco contenente tutti i prodotti per gli ID categoria specificati, è possibile considerare la query come una proiezione seguita da un'operazione di appiattimento . C'è un operatore di LINQ che lo fa: SelectMany.

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

In C # 4, puoi accorciare SelectMany per: .SelectMany(GetAllProducts)

Se hai già elenchi che rappresentano i prodotti per ciascun ID, ciò di cui hai bisogno è una concatenazione , come altri sottolineano.

puoi combinarli usando LINQ:

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

l'approccio più tradizionale di utilizzo List.AddRange()potrebbe essere più efficiente però.

Dai un'occhiata a List.AddRange per unire gli elenchi

È possibile utilizzare il metodo di estensione Concat :

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

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

So che questa è una vecchia domanda che pensavo di poter aggiungere solo i miei 2 centesimi.

Se ne hai uno List<Something>[]puoi unirti a loro usandoAggregate

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

    return result;
}

Spero che questo ti aiuti.

L'ho già commentato ma continuo a pensare che sia un'opzione valida, basta provare se nel tuo ambiente è meglio una soluzione o l'altra. Nel mio caso particolare, l'utilizzo source.ForEach(p => dest.Add(p))funziona meglio del classico AddRangema non ho studiato il perché a basso livello.

Puoi vedere un codice di esempio qui: https://gist.github.com/mcliment/4690433

Quindi l'opzione sarebbe:

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

Provalo per vedere se funziona per te.

Disclaimer : non sto sostenendo questa soluzione, trovo Concatla più chiara. Ho appena affermato, nella mia discussione con Jon, che nella mia macchina questo caso funziona meglio di AddRange, ma dice, con molta più conoscenza di me, che questo non ha senso. C'è l'essenza se vuoi confrontare.

// I would make it a little bit more simple

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

In questo modo si tratta di un elenco multidimensionale e .SelectMany () lo appiattirà in un prodotto IEnumerable, quindi utilizzo il metodo .ToList ().

Per unire o combinare a elenchi in un unico elenco.

• C'è una cosa che deve essere vera: il tipo di entrambi gli elenchi sarà uguale.

• Per esempio : se abbiamo un elenco di stringcosì possiamo aggiungere aggiungere un altro elenco all'elenco esistente che ha un elenco di tipo stringa altrimenti non possiamo.

Esempio :

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

   }
}

Nel caso speciale: "Tutti gli elementi di List1 passano a un nuovo List2": (ad esempio un elenco di stringhe)

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

In questo caso, list2 viene generato con tutti gli elementi di list1.

È necessario utilizzare l'operazione Concat

Quando hai qualche elenco ma non sai quanti esattamente, usa questo:

listsOfProducts contiene alcuni elenchi pieni di oggetti.

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

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