LINQ Danh sách phân vùng vào danh sách của 8 thành viên

Question

Làm thế nào người ta sẽ lấy một danh sách (sử dụng LINQ) và phá vỡ nó thành một danh sách liệt kê phân vùng danh sách ban đầu trên tất cả các entry 8?

Tôi tưởng tượng một cái gì đó như thế này sẽ liên quan đến Bỏ qua và/hoặc Take, nhưng tôi vẫn còn khá mới với LINQ.

Chỉnh sửa: Sử dụng C#/.Net 3.5

Chỉnh sửa2: Câu hỏi này được viết khác với câu hỏi "trùng lặp" khác. Mặc dù những vấn đề tương tự, câu trả lời trong câu hỏi này là vượt trội: Cả "chấp nhận" Câu trả lời là rất rắn (với tuyên bố yield) cũng như đề nghị của Jon Skeet sử dụng MoreLinq (mà không được khuyến khích trong câu hỏi "khác". Đôi khi các bản sao là tốt ở chỗ chúng buộc phải kiểm tra lại vấn đề.

Answer 1

Sử dụng các phương pháp khuyến nông sau để phá vỡ các đầu vào thành các tập con

public static class IEnumerableExtensions 
{ 
    public static IEnumerable<List<T>> InSetsOf<T>(this IEnumerable<T> source, int max) 
    { 
     List<T> toReturn = new List<T>(max); 
     foreach(var item in source) 
     { 
       toReturn.Add(item); 
       if (toReturn.Count == max) 
       { 
         yield return toReturn; 
         toReturn = new List<T>(max); 
       } 
     } 
     if (toReturn.Any()) 
     { 
       yield return toReturn; 
     } 
    } 
} 

Answer 2

Chúng tôi chỉ có như vậy một phương pháp trong MoreLINQ như Batch phương pháp:

// As IEnumerable<IEnumerable<T>> 
var items = list.Batch(8); 

hoặc

// As IEnumerable<List<T>> 
var items = list.Batch(8, seq => seq.ToList()); 

Answer 3

Bạn nên sử dụng thư viện lik e MoreLinq, nhưng nếu bạn thực sự phải làm điều này bằng "LINQ đồng bằng", bạn có thể sử dụng GroupBy:

var sequence = new[] {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; 

var result = sequence.Select((x, i) => new {Group = i/8, Value = x}) 
        .GroupBy(item => item.Group, g => g.Value) 
        .Select(g => g.Where(x => true)); 

// result is: { {1,2,3,4,5,6,7,8}, {9,10,11,12,13,14,15,16} } 

Về cơ bản, chúng tôi sử dụng các phiên bản của Select() cung cấp một chỉ số cho giá trị được tiêu thụ, chúng tôi chia chỉ số của 8 để xác định nhóm nào mỗi giá trị thuộc về. Sau đó, chúng tôi nhóm chuỗi theo khóa nhóm này. Cuối cùng Select chỉ làm giảm IGrouping<> xuống thành IEnumerable<IEnumerable<T>> (và không thực sự cần thiết vì IGrouping là IEnumerable).

Thật dễ dàng, đủ để biến điều này thành phương pháp có thể tái sử dụng bằng cách tính số hằng số 8 trong ví dụ và thay thế bằng thông số được chỉ định. Nó không nhất thiết phải là giải pháp thanh lịch nhất, và nó không còn là một giải pháp lười biếng, streaming ... nhưng nó hoạt động.

Bạn cũng có thể viết phương pháp mở rộng của riêng mình bằng cách sử dụng các khối lặp (yield return) có thể mang lại hiệu suất tốt hơn và sử dụng ít bộ nhớ hơn GroupBy. Đây là phương thức Batch() của MoreLinq làm IIRC.

Answer 4

Đưa sẽ không thể rất hiệu quả, bởi vì nó không loại bỏ các mục thực hiện.

tại sao không sử dụng một vòng lặp đơn giản:

public IEnumerable<IList<T>> Partition<T>(this/* <-- see extension methods*/ IEnumerable<T> src,int num) 
{ 
    IEnumerator<T> enu=src.getEnumerator(); 
    while(true) 
    { 
     List<T> result=new List<T>(num); 
     for(int i=0;i<num;i++) 
     { 
      if(!enu.MoveNext()) 
      { 
       if(i>0)yield return result; 
       yield break; 
      } 
      result.Add(enu.Current); 
     } 
     yield return result; 
    } 
} 

Answer 5

Nó không phải ở tất cả những gì các nhà thiết kế LINQ ban đầu có trong tâm trí, nhưng hãy kiểm tra lạm dụng này groupby:

public static IEnumerable<IEnumerable<T>> BatchBy<T>(this IEnumerable<T> items, int batchSize) 
{ 
    var count = 0; 
    return items.GroupBy(x => (count++/batchSize)).ToList(); 
} 

[TestMethod] 
public void BatchBy_breaks_a_list_into_chunks() 
{ 
    var values = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
    var batches = values.BatchBy(3); 
    batches.Count().ShouldEqual(4); 
    batches.First().Count().ShouldEqual(3); 
    batches.Last().Count().ShouldEqual(1); 
} 

Tôi nghĩ rằng nó thắng giải "golf" cho câu hỏi này. Các ToList là rất quan trọng vì bạn muốn chắc chắn rằng các nhóm đã thực sự được thực hiện trước khi bạn cố gắng làm bất cứ điều gì với đầu ra.Nếu bạn loại bỏ các ToList, bạn sẽ nhận được một số tác dụng phụ lạ.

Answer 6

from b in Enumerable.Range(0,8) select items.Where((x,i) => (i % 8) == b); 

Answer 7

Giải pháp đơn giản nhất được đưa ra bởi Mel:

public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> items, 
                 int partitionSize) 
{ 
    int i = 0; 
    return items.GroupBy(x => i++/partitionSize).ToArray(); 
} 

ngắn gọn nhưng chậm hơn. Phương thức trên chia tách một IEnumerable thành các khối kích thước cố định mong muốn với tổng số khối không quan trọng. Để chia một IEnumerable vào số N của khối có kích thước tương đương hoặc gần với kích thước bằng nhau, bạn có thể làm:

public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> items, 
                int numOfParts) 
{ 
    int i = 0; 
    return items.GroupBy(x => i++ % numOfParts); 
} 

Đẩy nhanh tiến độ điều, một cách tiếp cận đơn giản sẽ làm gì:

public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> items, 
                 int partitionSize) 
{ 
    if (partitionSize <= 0) 
     throw new ArgumentOutOfRangeException("partitionSize"); 

    int innerListCounter = 0; 
    int numberOfPackets = 0; 
    foreach (var item in items) 
    { 
     innerListCounter++; 
     if (innerListCounter == partitionSize) 
     { 
      yield return items.Skip(numberOfPackets * partitionSize).Take(partitionSize); 
      innerListCounter = 0; 
      numberOfPackets++; 
     } 
    } 

    if (innerListCounter > 0) 
     yield return items.Skip(numberOfPackets * partitionSize); 
} 

này nhanh hơn bất cứ điều gì hiện đang trên hành tinh bây giờ :) Các phương pháp tương đương cho hoạt động Splithere