Cách thanh lịch để kết hợp nhiều bộ sưu tập các yếu tố?

Giả sử tôi có một số bộ sưu tập tùy ý, mỗi bộ chứa các đối tượng cùng loại (ví dụ: List<int> foovà List<int> bar). Nếu bản thân những bộ sưu tập này nằm trong một bộ sưu tập (ví dụ: loại List<List<int>>, tôi có thể sử dụng SelectManyđể kết hợp tất cả chúng thành một bộ sưu tập.

Tuy nhiên, nếu những bộ sưu tập này không nằm trong cùng một bộ sưu tập, thì ấn tượng của tôi là tôi phải viết một phương thức như thế này:

public static IEnumerable<T> Combine<T>(params ICollection<T>[] toCombine)
{
   return toCombine.SelectMany(x => x);
}

Sau đó tôi sẽ gọi như thế này:

var combined = Combine(foo, bar);

Có cách nào gọn gàng và thanh lịch để kết hợp (bất kỳ số lượng) bộ sưu tập nào mà không cần phải viết một phương thức tiện ích như Combinetrên không? Nó có vẻ đơn giản đến mức phải có một cách để làm điều đó trong LINQ, nhưng có lẽ không.

Tôi nghĩ bạn có thể đang tìm kiếm LINQ's .Concat()?

var combined = foo.Concat(bar).Concat(foobar).Concat(...);

Ngoài ra, .Union()sẽ loại bỏ các phần tử trùng lặp.

Đối với tôi Concatnhư một phương thức mở rộng không phải là rất thanh lịch trong mã của tôi khi tôi có nhiều chuỗi lớn để nối. Đây chỉ đơn thuần là vấn đề thụt lề / định dạng codde và một cái gì đó rất cá nhân.

Chắc chắn nó sẽ tốt như thế này:

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

Không thể đọc được khi nó đọc như:

var list = list1.Select(x = > x)
   .Concat(list2.Where(x => true)
   .Concat(list3.OrderBy(x => x));

Hoặc khi nó trông giống như:

return Normalize(list1, a, b)
    .Concat(Normalize(list2, b, c))
       .Concat(Normalize(list3, c, d));

hoặc bất kỳ định dạng ưa thích của bạn là gì. Mọi thứ trở nên tồi tệ hơn với những kết nối phức tạp hơn. Lý do cho tôi loại bất hòa nhận thức với phong cách trên là người đầu tiên bên ngoài chuỗi lời nói dối của Concatphương pháp trong khi trình tự tiếp theo nằm bên trong. Tôi thích gọi Concatphương thức tĩnh trực tiếp chứ không phải kiểu mở rộng:

var list = Enumerable.Concat(list1.Select(x => x),
                             list2.Where(x => true));

Để có thêm số lượng kết hợp của chuỗi, tôi thực hiện cùng một phương thức tĩnh như trong OP:

public static IEnumerable<T> Concat<T>(params IEnumerable<T>[] sequences)
{
    return sequences.SelectMany(x => x);
}

Vì vậy, tôi có thể viết:

return EnumerableEx.Concat
(
    list1.Select(x = > x),
    list2.Where(x => true),
    list3.OrderBy(x => x)
);

Trông tốt hơn. Việc bổ sung, nếu không thì thừa, tên lớp mà tôi phải viết không phải là vấn đề đối với tôi vì các trình tự của tôi trông gọn gàng hơn với lệnh Concatgọi. Nó ít có vấn đề hơn trong C # 6 . Bạn chỉ có thể viết:

return Concat(list1.Select(x = > x),
              list2.Where(x => true),
              list3.OrderBy(x => x));

Chúng tôi muốn chúng tôi có danh sách các toán tử nối trong C #, giống như:

list1 @ list2 // F#
list1 ++ list2 // Scala

Theo cách đó sạch hơn nhiều.

Đối với trường hợp khi bạn làm có một bộ sưu tập các bộ sưu tập, tức là một List<List<T>>, Enumerable.Aggregatelà một cách thanh lịch hơn để kết hợp tất cả danh sách thành một:

var combined = lists.Aggregate((acc, list) => { return acc.Concat(list); });

Sử dụng Enumerable.Concatnhư vậy:

var combined = foo.Concat(bar).Concat(baz)....;

Sử dụng Enumerable.Concact:

var query = foo.Concat(bar);

Bạn luôn có thể sử dụng Aggregate kết hợp với Concat ...

        var listOfLists = new List<List<int>>
        {
            new List<int> {1, 2, 3, 4},
            new List<int> {5, 6, 7, 8},
            new List<int> {9, 10}
        };

        IEnumerable<int> combined = new List<int>();
        combined = listOfLists.Aggregate(combined, (current, list) => current.Concat(list)).ToList();

Cách duy nhất tôi thấy là sử dụng Concat()

 var foo = new List<int> { 1, 2, 3 };
 var bar = new List<int> { 4, 5, 6 };
 var tor = new List<int> { 7, 8, 9 };

 var result = foo.Concat(bar).Concat(tor);

Nhưng bạn nên quyết định điều gì tốt hơn:

var result = Combine(foo, bar, tor);

hoặc là

var result = foo.Concat(bar).Concat(tor);

Một điểm tại sao Concat()sẽ là lựa chọn tốt hơn là nó sẽ rõ ràng hơn đối với một nhà phát triển khác. Dễ đọc và đơn giản hơn.

Bạn có thể sử dụng Union như sau:

var combined=foo.Union(bar).Union(baz)...

Tuy nhiên, điều này sẽ loại bỏ các phần tử giống hệt nhau, vì vậy nếu bạn có những phần tử đó, bạn có thể muốn sử dụng Concatthay thế.

Một số kỹ thuật sử dụng Bộ khởi tạo Bộ sưu tập -

giả sử các danh sách này:

var list1 = new List<int> { 1, 2, 3 };
var list2 = new List<int> { 4, 5, 6 };

SelectMany với trình khởi tạo mảng (đối với tôi không thực sự thanh lịch nhưng không dựa vào bất kỳ chức năng trợ giúp nào):

var combined = new []{ list1, list2 }.SelectMany(x => x);

Xác định tiện ích mở rộng danh sách cho Thêm mà cho phép IEnumerable<T>trong trình List<T> khởi tạo :

public static class CollectionExtensions
{
    public static void Add<T>(this ICollection<T> collection, IEnumerable<T> items)
    {
        foreach (var item in items) collection.Add(item);
    }
}

Sau đó, bạn có thể tạo một danh sách mới chứa các phần tử của những phần tử khác như thế này (nó cũng cho phép các mục riêng lẻ được trộn vào).

var combined = new List<int> { list1, list2, 7, 8 };

Cho rằng bạn đang bắt đầu với một loạt các bộ sưu tập riêng biệt, tôi nghĩ rằng giải pháp của bạn khá thanh lịch. Bạn sẽ phải làm gì đó để ghép chúng lại với nhau.

Sẽ thuận tiện hơn về mặt cú pháp nếu tạo một phương thức mở rộng ra khỏi phương thức Kết hợp của bạn, phương thức này sẽ làm cho nó có sẵn ở mọi nơi bạn đến.

Tất cả những gì bạn cần là cái này, cho bất kỳ IEnumerable<IEnumerable<T>> lists:

var combined = lists.Aggregate((l1, l2) => l1.Concat(l2));

Điều này sẽ kết hợp tất cả các mục liststhành một IEnumerable<T>(với các bản sao). Sử dụng Unionthay vì Concatđể loại bỏ các bản sao, như đã lưu ý trong các câu trả lời khác.