Я отвечу ужасным, нарисованным рукой комиком. Второе изображение является причиной того, что result
является undefined
в вашем примере кода.
Вы можете использовать LINQ
для группировки всех элементов по размеру блока и создания новых массивов.
// build sample data with 1200 Strings
string[] items = Enumerable.Range(1, 1200).Select(i => "Item" + i).ToArray();
// split on groups with each 100 items
String[][] chunks = items
.Select((s, i) => new { Value = s, Index = i })
.GroupBy(x => x.Index / 100)
.Select(grp => grp.Select(x => x.Value).ToArray())
.ToArray();
for (int i = 0; i < chunks.Length; i++)
{
foreach (var item in chunks[i])
Console.WriteLine("chunk:{0} {1}", i, item);
}
Обратите внимание, что нет необходимости создавать новые массивы (требуется циклы процессора и память). Вы также можете использовать IEnumerable<IEnumerable<String>>
, когда вы опускаете два ToArrays
.
Вот код запуска: http://ideone.com/K7Hn2
Вы можете использовать Skip()
и Take()
string[] items = new string[]{ "a", "b", "c"};
string[] chunk = items.Skip(1).Take(1).ToArray();
Array.Copy существует с 1,1 и отлично работает с массивами chunking.
string[] buffer;
for(int i = 0; i < source.Length; i+=100)
{
buffer = new string[100];
Array.Copy(source, i, buffer, 0, 100);
// process array
}
И сделать расширение для него:
public static class Extensions
{
public static T[] Slice<T>(this T[] source, int index, int length)
{
T[] slice = new T[length];
Array.Copy(source, index, slice, 0, length);
return slice;
}
}
И для используйте расширение:
string[] source = new string[] { 1200 items here };
// get the first 100
string[] slice = source.Slice(0, 100);
Обновление: я думаю, что вам может понадобиться ArraySegment<>
Нет необходимости в проверках производительности, потому что он просто использует исходный массив в качестве источника и поддерживает свойство Offset и Count для определения «сегмент». К сожалению, нет способа получить JUST сегмент в виде массива, поэтому некоторые люди написали обертки для него, например здесь: ArraySegment - возврат фактического сегмента C #
ArraySegment<string> segment;
for (int i = 0; i < source.Length; i += 100)
{
segment = new ArraySegment<string>(source, i, 100);
// and to loop through the segment
for (int s = segment.Offset; s < segment.Array.Length; s++)
{
Console.WriteLine(segment.Array[s]);
}
}
Метод тестирования (в режиме деблокирования):
static void Main(string[] args)
{
string[] source = new string[1000000];
for (int i = 0; i < source.Length; i++)
{
source[i] = "string " + i.ToString();
}
string[] buffer;
Console.WriteLine("Starting stop watch");
Stopwatch sw = new Stopwatch();
for (int n = 0; n < 5; n++)
{
sw.Reset();
sw.Start();
for (int i = 0; i < source.Length; i += 100)
{
buffer = new string[100];
Array.Copy(source, i, buffer, 0, 100);
}
sw.Stop();
Console.WriteLine("Array.Copy: " + sw.ElapsedMilliseconds.ToString());
sw.Reset();
sw.Start();
for (int i = 0; i < source.Length; i += 100)
{
buffer = new string[100];
buffer = source.Skip(i).Take(100).ToArray();
}
sw.Stop();
Console.WriteLine("Skip/Take: " + sw.ElapsedMilliseconds.ToString());
sw.Reset();
sw.Start();
String[][] chunks = source
.Select((s, i) => new { Value = s, Index = i })
.GroupBy(x => x.Index / 100)
.Select(grp => grp.Select(x => x.Value).ToArray())
.ToArray();
sw.Stop();
Console.WriteLine("LINQ: " + sw.ElapsedMilliseconds.ToString());
}
Console.ReadLine();
}
Результаты (в миллисекундах) :
Array.Copy: 15
Skip/Take: 42464
LINQ: 881
Array.Copy: 21
Skip/Take: 42284
LINQ: 585
Array.Copy: 11
Skip/Take: 43223
LINQ: 760
Array.Copy: 9
Skip/Take: 42842
LINQ: 525
Array.Copy: 24
Skip/Take: 43134
LINQ: 638
Вы можете использовать List.GetRange :
for(var i = 0; i < source.Count; i += chunkSize)
{
List<string> items = source.GetRange(i, Math.Min(chunkSize, source.Count - i));
}
Хотя это не так быстро, как Array.Copy, я думаю, что он выглядит более чистым:
var list = Enumerable.Range(0, 723748).ToList();
var stopwatch = new Stopwatch();
for (int n = 0; n < 5; n++)
{
stopwatch.Reset();
stopwatch.Start();
for(int i = 0; i < list.Count; i += 100)
{
List<int> c = list.GetRange(i, Math.Min(100, list.Count - i));
}
stopwatch.Stop();
Console.WriteLine("List<T>.GetRange: " + stopwatch.ElapsedMilliseconds.ToString());
stopwatch.Reset();
stopwatch.Start();
for (int i = 0; i < list.Count; i += 100)
{
List<int> c = list.Skip(i).Take(100).ToList();
}
stopwatch.Stop();
Console.WriteLine("Skip/Take: " + stopwatch.ElapsedMilliseconds.ToString());
stopwatch.Reset();
stopwatch.Start();
var test = list.ToArray();
for (int i = 0; i < list.Count; i += 100)
{
int length = Math.Min(100, list.Count - i);
int[] c = new int[length];
Array.Copy(test, i, c, 0, length);
}
stopwatch.Stop();
Console.WriteLine("Array.Copy: " + stopwatch.ElapsedMilliseconds.ToString());
stopwatch.Reset();
stopwatch.Start();
List<List<int>> chunks = list
.Select((s, i) => new { Value = s, Index = i })
.GroupBy(x => x.Index / 100)
.Select(grp => grp.Select(x => x.Value).ToList())
.ToList();
stopwatch.Stop();
Console.WriteLine("LINQ: " + stopwatch.ElapsedMilliseconds.ToString());
}
Результаты в миллисекундах:
List<T>.GetRange: 1
Skip/Take: 9820
Array.Copy: 1
LINQ: 161
List<T>.GetRange: 9
Skip/Take: 9237
Array.Copy: 1
LINQ: 148
List<T>.GetRange: 5
Skip/Take: 9470
Array.Copy: 1
LINQ: 186
List<T>.GetRange: 0
Skip/Take: 9498
Array.Copy: 1
LINQ: 110
List<T>.GetRange: 8
Skip/Take: 9717
Array.Copy: 1
LINQ: 148
Используйте LINQ, вы можете использовать функции Take () и Skip ()
Если у вас есть массив, который нужно разделить, но разделение имеет остальное с помощью этого простого решения, вы можете разделить элементы, отсутствующие в разных «кусках» одинаково. В моем решении куски связаны как длинная строка, но вы можете легко изменить это.
public static string[] SplitArrey(string[] ArrInput, int n_column)
{
string[] OutPut = new string[n_column];
int NItem = ArrInput.Length; // total elements
int ItemsForColum = NItem / n_column; // n elements for each chunk
int _total = ItemsForColum * n_column; // Count the equal elements
int MissElement = NItem - _total; // Count missing element
int[] _Arr = new int[n_column];
for (int i = 0; i < n_column; i++)
{
int AddOne = (i < MissElement) ? 1 : 0;
_Arr[i] = ItemsForColum + AddOne;
}
int offset = 0;
for (int Row = 0; Row < n_column; Row++)
{
for (int i = 0; i < _Arr[Row]; i++)
{
OutPut[Row] += ArrInput[i + offset] + " "; // <- Here to change how the strings are linked
}
offset += _Arr[Row];
}
return OutPut;
}
здесь Я нашел другое linq-решение:
int[] source = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int i = 0;
int chunkSize = 3;
int[][] result = source.GroupBy(s => i++ / chunkSize).Select(g => g.ToArray()).ToArray();
//result = [1,2,3][4,5,6][7,8,9]
string[] amzProductAsins = GetProductAsin();;
List<string[]> chunks = new List<string[]>();
for (int i = 0; i < amzProductAsins.Count; i += 100)
{
chunks.Add(amzProductAsins.Skip(i).Take(100).ToArray());
}
Метод общего рекурсивного расширения:
public static IEnumerable<IEnumerable<T>> SplitList<T>(this IEnumerable<T> source, int maxPerList)
{
var enumerable = source as IList<T> ?? source.ToList();
if (!enumerable.Any())
{
return new List<IEnumerable<T>>();
}
return (new List<IEnumerable<T>>() { enumerable.Take(maxPerList) }).Concat(enumerable.Skip(maxPerList).SplitList<T>(maxPerList));
}