Combine dos (o más) listas en una, en C # .NET

¿Es posible convertir dos o más listas en una sola lista, en .NET usando C #?

Por ejemplo,

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

Puede usar el LINQ Concaty los ToListmétodos:

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

Tenga en cuenta que hay formas más eficientes de hacer esto: lo anterior básicamente recorrerá todas las entradas, creando un búfer de tamaño dinámico. Como puede predecir el tamaño para comenzar, no necesita este tamaño dinámico ... por lo que podría usar:

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

( AddRangeestá especialmente revestido ICollection<T>para mayor eficiencia).

Sin embargo, no tomaría este enfoque a menos que realmente tenga que hacerlo.

Suponiendo que desea una lista que contenga todos los productos para los ID de categoría especificados, puede tratar su consulta como una proyección seguida de una operación de aplanamiento . Hay un operador de LINQ que hace eso: SelectMany.

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

En C # 4, puede acortar SelectMany a: .SelectMany(GetAllProducts)

Si ya tiene listas que representan los productos para cada Id, entonces lo que necesita es una concatenación , como otros señalan.

puedes combinarlos usando LINQ:

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

Sin List.AddRange()embargo, el enfoque más tradicional del uso podría ser más eficiente.

Eche un vistazo a List.AddRange para fusionar Listas

Puede usar el método de extensión Concat :

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

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

Sé que esta es una vieja pregunta que pensé que podría agregar mis 2 centavos.

Si tienes un List<Something>[]puedes unirte a ellos 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;
}

Espero que esto ayude.

Ya lo he comentado, pero sigo pensando que es una opción válida, solo pruebe si en su entorno es mejor una solución u otra. En mi caso particular, el uso source.ForEach(p => dest.Add(p))funciona mejor que el clásico, AddRangepero no he investigado por qué en el nivel bajo.

Puede ver un código de ejemplo aquí: https://gist.github.com/mcliment/4690433

Entonces la opción sería:

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

Pruébalo para ver si te funciona.

Descargo de responsabilidad : no estoy abogando por esta solución, encuentro Concatla más clara. Simplemente dije, en mi discusión con Jon, que en mi máquina este caso funciona mejor que AddRange, pero él dice, con mucho más conocimiento que yo, que esto no tiene sentido. Ahí está la esencia si quieres comparar.

// I would make it a little bit more simple

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

De esta manera, es una Lista multidimensional y .SelectMany () lo aplanará en un IEnumerable de producto y luego usaré el método .ToList () después.

Para fusionar o combinar a listas en una lista de One.

• Hay una cosa que debe ser cierta: el tipo de ambas listas será igual.

• Por ejemplo : si tenemos una lista de stringmodo que podamos agregar, agregue otra lista a la lista existente que tenga una lista de tipo cadena; de lo contrario, no podemos.

Ejemplo :

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

   }
}

En el caso especial: "Todos los elementos de la Lista1 van a una nueva Lista2": (por ejemplo, una lista de cadenas)

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

En este caso, list2 se genera con todos los elementos de list1.

Necesita usar la operación Concat

Cuando tienes pocas listas pero no sabes cuántas exactamente, usa esto:

listsOfProducts contiene pocas listas llenas de objetos.

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

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