没有办法将数组中的所有元素设置为单个操作，除非，该值是元素类型的默认值。

例如，如果它是一个整数数组，你可以通过一个操作将它们全部设置为0，如下所示: Array.Clear(…)

如果你的数组太大，你应该使用BitArray。它为每个bool值使用1位，而不是一个字节(就像在bool数组中一样)，您还可以使用位操作符将所有位设置为true。或者在true上初始化。如果你只需要做一次，它只会花费更多。

System.Collections.BitArray falses = new System.Collections.BitArray(100000, false);
System.Collections.BitArray trues = new System.Collections.BitArray(100000, true);

// Now both contain only true values.
falses.And(trues);

创建一个包含1000个真值的新数组:

var items = Enumerable.Repeat<bool>(true, 1000).ToArray();  // Or ToList(), etc.

类似地，你可以生成整数序列:

var items = Enumerable.Range(0, 1000).ToArray();  // 0..999

我知道我来晚了，但我有个主意。编写一个包装器，其中包含与被包装值之间的转换操作符，以便它可以用作被包装类型的替身。这实际上是受到@l33t的愚蠢回答的启发。

首先(来自c++)，我意识到在c#中，当数组的元素被构造时，默认的ctor是不被调用的。相反，即使存在用户定义的默认构造函数!——所有数组元素都是零初始化的。这确实让我大吃一惊。

因此，包装器类只提供一个默认的ctor和所需的值，就可以用于c++中的数组，但不适用于c#。一种解决方法是让包装器类型在转换时将0映射到所需的种子值。这样一来，在所有实际应用中，零初始化值似乎都被种子初始化了:

public struct MyBool
{
    private bool _invertedValue;

    public MyBool(bool b) 
    {   
        _invertedValue = !b;
    }

    public static implicit operator MyBool(bool b)
    {
        return new MyBool(b);
    }

    public static implicit operator bool(MyBool mb)
    {
        return !mb._invertedValue;
    }

}

static void Main(string[] args)
{
        MyBool mb = false; // should expose false.
        Console.Out.WriteLine("false init gives false: " 
                              + !mb);

        MyBool[] fakeBoolArray = new MyBool[100];

        Console.Out.WriteLine("Default array elems are true: " 
                              + fakeBoolArray.All(b => b) );

        fakeBoolArray[21] = false;
        Console.Out.WriteLine("Assigning false worked: " 
                              + !fakeBoolArray[21]);

        fakeBoolArray[21] = true;
        // Should define ToString() on a MyBool,
        // hence the !! to force bool
        Console.Out.WriteLine("Assigning true again worked: " 
                              + !!fakeBoolArray[21]);
}

此模式适用于所有值类型。例如，如果需要初始化4，则可以将int类型的0映射到4。

我很想像在c++中那样做一个模板，提供种子值作为模板参数，但我知道这在c#中是不可能的。还是我遗漏了什么?(当然，在c++中，映射根本不是必需的，因为可以提供一个默认的ctor，它将被数组元素调用。)

FWIW，这里有一个等价的c++: https://ideone.com/wG8yEh。

不幸的是，我不认为有一个直接的方法，但我认为你可以为数组类写一个扩展方法来做到这一点

class Program
{
    static void Main(string[] args)
    {
        int[] arr = new int[1000];
        arr.Init(10);
        Array.ForEach(arr, Console.WriteLine);
    }
}

public static class ArrayExtensions
{
    public static void Init<T>(this T[] array, T defaultVaue)
    {
        if (array == null)
            return;
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = defaultVaue;
        }
    }
}

并行实现怎么样

public static void InitializeArray<T>(T[] array, T value)
{
    var cores = Environment.ProcessorCount;

    ArraySegment<T>[] segments = new ArraySegment<T>[cores];

    var step = array.Length / cores;
    for (int i = 0; i < cores; i++)
    {
        segments[i] = new ArraySegment<T>(array, i * step, step);
    }
    var remaining = array.Length % cores;
    if (remaining != 0)
    {
        var lastIndex = segments.Length - 1;
        segments[lastIndex] = new ArraySegment<T>(array, lastIndex * step, array.Length - (lastIndex * step));
    }

    var initializers = new Task[cores];
    for (int i = 0; i < cores; i++)
    {
        var index = i;
        var t = new Task(() =>
        {
            var s = segments[index];
            for (int j = 0; j < s.Count; j++)
            {
                array[j + s.Offset] = value;
            }
        });
        initializers[i] = t;
        t.Start();
    }

    Task.WaitAll(initializers);
}

当只初始化一个数组时，这段代码的力量是看不出来的，但我认为你绝对应该忘记“纯”for。