如何将List <T>初始化为给定的大小（而不是容量）？

.NET提供了一个性能几乎相同的通用列表容器（请参阅阵列性能与列表性能问题）。但是，它们在初始化方面有很大的不同。

数组很容易使用默认值初始化，并且根据定义，它们已经具有一定的大小：

string[] Ar = new string[10];

这样可以安全地分配随机项目，例如：

Ar[5]="hello";

与列表相比，事情更加棘手。我可以看到执行相同初始化的两种方法，这两种都不是您所说的优雅：

List<string> L = new List<string>(10);
for (int i=0;i<10;i++) L.Add(null);

要么

string[] Ar = new string[10];
List<string> L = new List<string>(Ar);

什么是更清洁的方式？

编辑：到目前为止的答案涉及容量，这是除预填充列表以外的其他功能。例如，在刚创建的容量为10的列表上，一个不能执行L[2]="somevalue"

编辑2：人们想知道为什么我要以这种方式使用列表，因为这不是他们打算使用的方式。我可以看到两个原因：

1. 令人信服的是，列表是“下一代”数组，几乎没有损失，却增加了灵活性。因此，默认情况下应使用它们。我指出，它们可能不那么容易初始化。

2. 我目前正在编写的是一个基类，该基类在更大的框架中提供了默认功能。在我提供的默认功能中，列表的大小是高级已知的，因此我可以使用数组。但是，我想为任何基类提供动态扩展它的机会，因此我选择了一个列表。

我不能说我经常需要-您能否提供更多为什么要这样做的详细信息？我可能会将其作为静态方法放在帮助器类中：

public static class Lists
{
    public static List<T> RepeatedDefault<T>(int count)
    {
        return Repeated(default(T), count);
    }

    public static List<T> Repeated<T>(T value, int count)
    {
        List<T> ret = new List<T>(count);
        ret.AddRange(Enumerable.Repeat(value, count));
        return ret;
    }
}

您可以使用，Enumerable.Repeat(default(T), count).ToList()但是由于缓冲区大小调整，效率会很低。

注意，如果T是引用类型，它将存储count为value参数传递的引用的副本-因此它们都将引用同一对象。这可能取决于您的用例，也可能不是您想要的。

编辑：如注释中所述，如果需要，您可以Repeated使用循环来填充列表。那也会稍微快一点。我个人认为代码使用的是Repeat更具描述性的，并且怀疑在现实世界中，性能差异是无关紧要的，但是您的工作量可能会有所不同。

List<string> L = new List<string> ( new string[10] );

使用将int（“容量”）作为参数的构造函数：

List<string> = new List<string>(10);

编辑：我应该补充一点，我同意弗雷德里克。您使用列表的方式与首先使用列表的全部原因背道而驰。

编辑2：

编辑2：我当前正在编写的是一个基类，该基类提供默认功能，作为更大框架的一部分。在我提供的默认功能中，列表的大小是高级已知的，因此我可以使用数组。但是，我想为任何基类提供动态扩展它的机会，因此我选择了一个列表。

为什么有人需要知道具有所有空值的列表的大小？如果列表中没有实际值，则我希望长度为0。无论如何，这很笨拙，这表明它与类的预期用途背道而驰。

首先创建一个数组，其中包含所需的项目数，然后将其转换为列表。

int[] fakeArray = new int[10];

List<int> list = fakeArray.ToList();

如果要使用固定值初始化列表，为什么要使用列表？我可以理解，出于性能考虑，您想要为其提供初始容量，但这不是列表在常规数组上的优势之一，列表可以在需要时增长吗？

执行此操作时：

List<int> = new List<int>(100);

您创建一个列表，其容量为100个整数。这意味着您的列表在添加第101个项目之前不需要“增长”。列表的基础数组将初始化为100。

像这样初始化列表的内容并不是真正的列表用途。列表旨在容纳对象。如果要将特定数字映射到特定对象，请考虑使用键值对结构（例如哈希表或字典）而不是列表。

您似乎在强调需要与数据进行位置关联，因此关联数组会更合适吗？

Dictionary<int, string> foo = new Dictionary<int, string>();
foo[2] = "string";

如果要使用固定值的N个元素初始化列表，请执行以下操作：

public List<T> InitList<T>(int count, T initValue)
{
  return Enumerable.Repeat(initValue, count).ToList();
}

您可以使用Linq巧妙地使用默认值初始化列表。（类似于David B的回答。）

var defaultStrings = (new int[10]).Select(x => "my value").ToList();

再向前走一步，并使用不同的值“字符串1”，“字符串2”，“字符串3”等初始化每个字符串：

int x = 1;
var numberedStrings = (new int[10]).Select(x => "string " + x++).ToList();

string [] temp = new string[] {"1","2","3"};
List<string> temp2 = temp.ToList();

接受的答案（带有绿色复选标记的答案）存在问题。

问题：

var result = Lists.Repeated(new MyType(), sizeOfList);
// each item in the list references the same MyType() object
// if you edit item 1 in the list, you are also editing item 2 in the list

我建议更改上面的行以执行对象的副本。关于此有许多不同的文章：

• 通过反射调用的String.MemberwiseClone（）方法不起作用，为什么？
• https://code.msdn.microsoft.com/windowsdesktop/CSDeepCloneObject-8a53311e

如果要使用默认构造函数而不是NULL初始化列表中的每个项目，请添加以下方法：

public static List<T> RepeatedDefaultInstance<T>(int count)
    {
        List<T> ret = new List<T>(count);
        for (var i = 0; i < count; i++)
        {
            ret.Add((T)Activator.CreateInstance(typeof(T)));
        }
        return ret;
    }

关于IList的通知： MSDN IList备注：“ IList实现分为三类：只读，固定大小和可变大小。（...）。有关此接口的通用版本，请参见 System.Collections.Generic.IList<T>。”

IList<T>不继承自IList（但同时List<T>实现IList<T>和IList），但始终为可变大小。从.NET 4.5开始，我们还拥有IReadOnlyList<T>AFAIK，因此没有所需的固定大小的通用列表。

这是我用于单元测试的样本。我创建了一个类对象列表。然后，我使用forloop添加了我期望从服务中获得的“ X”个对象。这样，您可以添加/初始化任何给定大小的列表。

public void TestMethod1()
    {
        var expected = new List<DotaViewer.Interface.DotaHero>();
        for (int i = 0; i < 22; i++)//You add empty initialization here
        {
            var temp = new DotaViewer.Interface.DotaHero();
            expected.Add(temp);
        }
        var nw = new DotaHeroCsvService();
        var items = nw.GetHero();

        CollectionAssert.AreEqual(expected,items);


    }

希望我能对你们有所帮助。

有点晚了，但是您提出的第一个解决方案对我来说似乎更干净：您不会两次分配内存。甚至List构造函数也需要遍历数组以进行复制；它甚至不知道事先只有空元素。

1.-分配N-循环N成本：1 *分配（N）+ N *循环迭代

2.-分配N-分配N +循环（）成本：2 *分配（N）+ N *循环迭代

但是，由于List是内置类，所以List的循环分配可能更快，但是C＃是jit编译的……