可能重复的问题：
C#：初始化int数组的更简洁方法
基本上，我想知道是否有比下面显示的代码更有效的代码。
private static int[] GetDefaultSeriesArray(int size, int value)
{
int[] result = new int[size];
for (int i = 0; i < size; i++)
{
result[i] = value;
}
return result;
}
数组大小可能从10到150000不等。对于小数组来说，这不是问题，但应该有更好的方法来执行上述操作。我使用的是VS2010(.NET 4.0)。
C#/CLR没有内置的方法来使用非默认值初始化数组。
如果以每个元素的操作数作为衡量标准，您的代码已经尽可能高效。
如果并行初始化大型数组的块，可以获得潜在更快的初始化速度。但是，这种方法需要仔细调整，因为多线程操作的成本并不简单。
通过分析您的需求并有可能完全删除整个初始化，可获得更好的结果。例如，如果数组通常包含常量值，则可以实现某种COW（写时复制）方法，其中对象最初没有支持数组，并返回常量值，当要对元素进行写入时，它将创建（可能是部分）支持修改段的备份数组。
较慢但更紧凑的代码（可能更易于阅读）是使用Enumerable.Repeat。请注意，对于大型数组，ToArray将导致分配大量内存（这也可能导致LOH上的分配）- 参见使用Enumerable.Range时内存消耗高吗？。
var result = Enumerable.Repeat(value, size).ToArray();
你可以通过使用Array.Copy来提高速度。它能够在更低的层次上工作，批量分配更大的内存空间。
通过批处理分配，你最终可以将数组从一个部分复制到自身。
此外，这些批次本身可以非常有效地并行化。
以下是我的初始代码。在我的机器上（只有两个核心），使用大小为1000万项的样本数组，我获得了约15%的加速。你需要调整批处理大小（尝试保持在页面大小的倍数以保持效率），以将其调整到你所拥有的项目大小。对于较小的数组，它几乎与你的代码相同，因为它不会超过填充第一个批次，但在这些情况下也不会更糟糕（明显）。
private const int batchSize = 1048576;
private static int[] GetDefaultSeriesArray2(int size, int value)
{
int[] result = new int[size];
//fill the first batch normally
int end = Math.Min(batchSize, size);
for (int i = 0; i < end; i++)
{
result[i] = value;
}
int numBatches = size / batchSize;
Parallel.For(1, numBatches, batch =>
{
Array.Copy(result, 0, result, batch * batchSize, batchSize);
});
//handle partial leftover batch
for (int i = numBatches * batchSize; i < size; i++)
{
result[i] = value;
}
return result;
}
private void Looper()
{
int repeats = 100;
float avg = 0;
ArrayList times = new ArrayList();
for (int i = 0; i < repeats; i++)
times.Add(Time());
Console.WriteLine(GetAverage(times)); //44
times.Clear();
for (int i = 0; i < repeats; i++)
times.Add(TimeUnrolled());
Console.WriteLine(GetAverage(times)); //22
}
private float GetAverage(ArrayList times)
{
long total = 0;
foreach (var item in times)
{
total += (long)item;
}
return total / times.Count;
}
private long Time()
{
Stopwatch sw = new Stopwatch();
int size = 20000000;
int[] result = new int[size];
sw.Start();
for (int i = 0; i < size; i++)
{
result[i] = 5;
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
return sw.ElapsedMilliseconds;
}
private long TimeUnrolled()
{
Stopwatch sw = new Stopwatch();
int size = 20000000;
int[] result = new int[size];
sw.Start();
for (int i = 0; i < size; i += 10)
{
result[i] = 5;
result[i + 1] = 5;
result[i + 2] = 5;
result[i + 3] = 5;
result[i + 4] = 5;
result[i + 5] = 5;
result[i + 6] = 5;
result[i + 7] = 5;
result[i + 8] = 5;
result[i + 9] = 5;
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
return sw.ElapsedMilliseconds;
}
Enumerable.Repeat(value, size).ToArray();
阅读 Enumerable.Repeat 比 ops 标准循环慢 20 倍，我发现唯一可能提高其速度的方法是
private static int[] GetDefaultSeriesArray(int size, int value)
{
int[] result = new int[size];
for (int i = 0; i < size; ++i)
{
result[i] = value;
}
return result;
}
注意，i++ 被改为 ++i。i++ 复制 i，增加 i，并返回原始值。++i 只返回增加后的值。
正如其他人已经提到的，您可以像这样利用并行处理：
int[] result = new int[size];
Parallel.ForEach(result, x => x = value);
return result;
抱歉，我没有时间在这个机器上进行性能测试（没有安装VS），但如果您可以进行测试并分享结果，那就太好了。
编辑：根据评论，虽然我仍然认为它们在性能方面是等效的，但您可以尝试使用并行for循环：
Parallel.For(0, size, i => result[i] = value);