blocks|key|952531|text|我不认为有一个很好的内置方法来解决这个问题，但是你可以像下面这样写一个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|952532|public+static+IEnumerable<IEnumerable<T>>+GroupInto<T>(
++this+IEnumerable<T>+source,
++int+count)+{

++using+(+var+e+=+source.GetEnumerator()+)+{
++++while+(+e.MoveNext()+)+{+
++++++yield+return+GroupIntoHelper(e,+count);
++++}
++}++++
}

private+static+IEnumerable<T>+GroupIntoHelper<T>(
++IEnumerator<T>+e,
++int+count)+{

++do+{
++++yield+return+e.Current;
++++count--;
++}+while+(+count+>+0+&&+e.MoveNext());
}|code-block|syntax|javascript|952533|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I don't think there's a great built-in method for this but you could write one like the following.

<pre><code>public static IEnumerable&lt;IEnumerable&lt;T&gt;&gt; GroupInto&lt;T&gt;(
 this IEnumerable&lt;T&gt; source,
 int count) {

 using ( var e = source.GetEnumerator() ) {
 while ( e.MoveNext() ) { 
 yield return GroupIntoHelper(e, count);
 }
 } 
}

private static IEnumerable&lt;T&gt; GroupIntoHelper&lt;T&gt;(
 IEnumerator&lt;T&gt; e,
 int count) {

 do {
 yield return e.Current;
 count--;
 } while ( count &gt; 0 &amp;&amp; e.MoveNext());
}
</code></pre>

blocks|key|1166739|text|这将生成一个包含3个元素的字符串数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1166740|int+i+=+0;
var+query+=+from+s+in+testArray
++++++++++++let+num+=+i%2B%2B
++++++++++++group+s+by+num+/+3+into+g
++++++++++++select+g.ToArray();
var+results+=+query.ToArray();|code-block|syntax|javascript|1166741|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This will generate an array of string arrays having 3 elements:

<pre><code>int i = 0;
var query = from s in testArray
 let num = i++
 group s by num / 3 into g
 select g.ToArray();
var results = query.ToArray();
</code></pre>

blocks|key|1166805|text|如果你实际使用的是数组，而不是一般的IEnumerables，特别是如果数组非常大，那么这种方法是一种非常快速和高效的内存效率方法。如果你真的只想要一条LINQ语句，那就算了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1166806|++++private+static+T[][]+SliceArray<T>(T[]+source,+int+maxResultElements)
++++{
++++++++int+numberOfArrays+=+source.Length+/+maxResultElements;
++++++++if+(maxResultElements+*+numberOfArrays+<+source.Length)
++++++++++++numberOfArrays%2B%2B;
++++++++T[][]+target+=+new+T[numberOfArrays][];
++++++++for+(int+index+=+0;+index+<+numberOfArrays;+index%2B%2B)
++++++++{
++++++++++++int+elementsInThisArray+=+Math.Min(maxResultElements,+source.Length+-+index+*+maxResultElements);
++++++++++++target[index]+=+new+T[elementsInThisArray];
++++++++++++Array.Copy(source,+index+*+maxResultElements,+target[index],+0,+elementsInThisArray);
++++++++}
++++++++return+target;
++++}|code-block|syntax|javascript|1166807|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If it is actually arrays that you are working with rather than general IEnumerables, and especially if the arrays are very large, then this method is a very fast and memory effecient way to do it. If you really just want a LINQ statement, then nevermind.

<pre><code> private static T[][] SliceArray&lt;T&gt;(T[] source, int maxResultElements)
 {
 int numberOfArrays = source.Length / maxResultElements;
 if (maxResultElements * numberOfArrays &lt; source.Length)
 numberOfArrays++;
 T[][] target = new T[numberOfArrays][];
 for (int index = 0; index &lt; numberOfArrays; index++)
 {
 int elementsInThisArray = Math.Min(maxResultElements, source.Length - index * maxResultElements);
 target[index] = new T[elementsInThisArray];
 Array.Copy(source, index * maxResultElements, target[index], 0, elementsInThisArray);
 }
 return target;
 }
</code></pre>

blocks|key|1166900|text|int+size+=+3;
var+results+=+testArray.Select((x,+i)+=>+new+{+Key+=+i+/+size,+Value+=+x+})
+++++++++++++++++++++++.GroupBy(x+=>+x.Key,+x+=>+x.Value,+(k,+g)+=>+g.ToArray())
+++++++++++++++++++++++.ToArray();|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1166901|如果您不介意将结果类型化为IEnumerable<IEnumerable<T>>而不是T[][]，那么您可以完全省略ToArray调用：|unstyled|offset|length|style|CODE|1166902|int+size+=+3;
var+results+=+testArray.Select((x,+i)+=>+new+{+Key+=+i+/+size,+Value+=+x+})
+++++++++++++++++++++++.GroupBy(x+=>+x.Key,+x+=>+x.Value);|1166903|entityMap^0|0|D|R|17|5|1M|7|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@$G|Q|H|R|I|J]|$G|S|H|T|I|J]|$G|U|H|V|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|X|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>int size = 3;
var results = testArray.Select((x, i) =&gt; new { Key = i / size, Value = x })
 .GroupBy(x =&gt; x.Key, x =&gt; x.Value, (k, g) =&gt; g.ToArray())
 .ToArray();
</code></pre>

If you don't mind the results being typed as <code>IEnumerable&lt;IEnumerable&lt;T&gt;&gt;</code> rather than <code>T[][]</code> then you can omit the <code>ToArray</code> calls altogether:

<pre><code>int size = 3;
var results = testArray.Select((x, i) =&gt; new { Key = i / size, Value = x })
 .GroupBy(x =&gt; x.Key, x =&gt; x.Value);
</code></pre>

blocks|key|1167179|text|MoreLinq提供Batch扩展方法|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1167180|entityMap|0|LINK|mutability|MUTABLE|url|https://code.google.com/p/morelinq/wiki/OperatorsOverview^0|A|5|0|8|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

<a href="https://code.google.com/p/morelinq/wiki/OperatorsOverview" rel="nofollow noreferrer">MoreLinq</a> provides <code>Batch</code> extension method

blocks|key|953016|text|您可以使用此扩展|type|unstyled|depth|inlineStyleRanges|entityRanges|data|953017|public+static+class+Extension
{
++++private+static+IEnumerable<TList>+Split<TList,+T>(this+TList+value,+int+countOfEachPart)+where+TList+:+IEnumerable<T>
++++{
++++++++int+cnt+=+value.Count()+/+countOfEachPart;
++++++++List<IEnumerable<T>>+result+=+new+List<IEnumerable<T>>();
++++++++for+(int+i+=+0;+i+<=+cnt;+i%2B%2B)
++++++++{
++++++++++++IEnumerable<T>+newPart+=+value.Skip(i+*+countOfEachPart).Take(countOfEachPart).ToArray();
++++++++++++if+(newPart.Any())
++++++++++++++++result.Add(newPart);
++++++++++++else
++++++++++++++++break;
++++++++}

++++++++return+result.Cast<TList>();
++++}

++++public+static+IEnumerable<IDictionary<TKey,+TValue>>+Split<TKey,+TValue>(this+IDictionary<TKey,+TValue>+value,+int+countOfEachPart)
++++{
++++++++IEnumerable<Dictionary<TKey,+TValue>>+result+=+value.ToArray()
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.Split(countOfEachPart)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.Select(p+=>+p.ToDictionary(k+=>+k.Key,+v+=>+v.Value));
++++++++return+result;
++++}

++++public+static+IEnumerable<IList<T>>+Split<T>(this+IList<T>+value,+int+countOfEachPart)
++++{
++++++++return+value.Split<IList<T>,+T>(countOfEachPart);
++++}

++++public+static+IEnumerable<T[]>+Split<T>(this+T[]+value,+int+countOfEachPart)
++++{
++++++++return+value.Split<T[],+T>(countOfEachPart);
++++}

++++public+static+IEnumerable<IEnumerable<T>>+Split<T>(this+IEnumerable<T>+value,+int+countOfEachPart)
++++{
++++++++return+value.Split<IEnumerable<T>,+T>(countOfEachPart);
++++}
}|code-block|syntax|javascript|953018|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use this Extension

<pre><code>public static class Extension
{
 private static IEnumerable&lt;TList&gt; Split&lt;TList, T&gt;(this TList value, int countOfEachPart) where TList : IEnumerable&lt;T&gt;
 {
 int cnt = value.Count() / countOfEachPart;
 List&lt;IEnumerable&lt;T&gt;&gt; result = new List&lt;IEnumerable&lt;T&gt;&gt;();
 for (int i = 0; i &lt;= cnt; i++)
 {
 IEnumerable&lt;T&gt; newPart = value.Skip(i * countOfEachPart).Take(countOfEachPart).ToArray();
 if (newPart.Any())
 result.Add(newPart);
 else
 break;
 }

 return result.Cast&lt;TList&gt;();
 }

 public static IEnumerable&lt;IDictionary&lt;TKey, TValue&gt;&gt; Split&lt;TKey, TValue&gt;(this IDictionary&lt;TKey, TValue&gt; value, int countOfEachPart)
 {
 IEnumerable&lt;Dictionary&lt;TKey, TValue&gt;&gt; result = value.ToArray()
 .Split(countOfEachPart)
 .Select(p =&gt; p.ToDictionary(k =&gt; k.Key, v =&gt; v.Value));
 return result;
 }

 public static IEnumerable&lt;IList&lt;T&gt;&gt; Split&lt;T&gt;(this IList&lt;T&gt; value, int countOfEachPart)
 {
 return value.Split&lt;IList&lt;T&gt;, T&gt;(countOfEachPart);
 }

 public static IEnumerable&lt;T[]&gt; Split&lt;T&gt;(this T[] value, int countOfEachPart)
 {
 return value.Split&lt;T[], T&gt;(countOfEachPart);
 }

 public static IEnumerable&lt;IEnumerable&lt;T&gt;&gt; Split&lt;T&gt;(this IEnumerable&lt;T&gt; value, int countOfEachPart)
 {
 return value.Split&lt;IEnumerable&lt;T&gt;, T&gt;(countOfEachPart);
 }
}
</code></pre>

What is the best way to group an array into a list of array of n elements each in c# 4.

E.g

<pre><code>string[] testArray = { "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8" };
</code></pre>

should be split into if we take n=3.

<pre><code>string[] A1 = {"s1", "s2", "s3"};
string[] A2 = {"s4", "s5", "s6"};
string[] A3 = {"s7", "s8"};
</code></pre>

May be a simple way using LINQ?

How to split an array into a group of n elements each?

在c# 4中，将数组分组为包含n个元素的数组列表的最佳方式是什么？E.gstring[] testArray = { "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8" };如果我们取n=3的话应该分成两部分。string[] A1 = {"s1", "s2", "s3"};s...

问如何将一个数组拆分为n个元素组成的组？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将一个数组拆分为n个元素组成的组？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将一个数组拆分为n个元素组成的组？
EN