C# 正在寻找一种更好的方法来初始化C中的大型对象列表# 新列表 { 新衍生型 { x=“x1”，y=“y1”，z=“z1” }, 新衍生型 { x=“x2”，y=“y2”，z=“z2” }, 新衍生型 { x=“x3”，y=“y3”，z=“z3” }, 新衍生型 { x=“x4”，y=“y4”，z=“z3” }, ... }

在静态方法中，列表是通过上面的方法初始化的，我想知道是否有更好的方法在语法上实现这一点

---

每次都以相同的顺序设置相同的字段，以方便操作。

为什么不在此处使用for循环

new List<BaseType>
{
    new DerivedType
    {
        x="x1",y="y1",z="z1"
    },
    new DerivedType
    {
        x="x2",y="y2",z="z2"
    },
    new DerivedType
    {
        x="x3",y="y3",z="z3"
    },
    new DerivedType
    {
        x="x4",y="y4",z="z3"
    },
    ...
}

var list=新列表（SomeValue）；
对于（inti=1；i

---

注意：我假设示例代码中的最后一个init应该是

“z4”

，而不是

“z3”

为什么不在这里使用for循环

new List<BaseType>
{
    new DerivedType
    {
        x="x1",y="y1",z="z1"
    },
    new DerivedType
    {
        x="x2",y="y2",z="z2"
    },
    new DerivedType
    {
        x="x3",y="y3",z="z3"
    },
    new DerivedType
    {
        x="x4",y="y4",z="z3"
    },
    ...
}

var list=新列表（SomeValue）；
对于（inti=1；i

注意：我假设示例代码中的最后一个init应该是

“z4”

而不是

“z3”

如果值实际上是“x1”等，那么：

var list = new List<BaseType>(SomeValue);
for (int i = 1; i < SomeValue; i++) { 
  list.Add(new DerivedType {
    x = string.Format("x{0}", i),
    y = string.Format("y{0}", i),
    z = string.Format("z{0}", i)
  });
}

或者，如果这些只是样本值（或者即使不是），只需向

DerivedType

添加一个构造函数，允许您一次性传递三个属性，就可以减少混乱：

var list = Enumerable.Range(1, n)
                     .Select(i => (BaseType) new DerivedType {
                                 x = "x" + i,
                                 y = "y" + i,
                                 z = "z" + i
                             })
                     .ToList();

新列表
{
新衍生类型（“x1”、“y1”、“z1”），
新衍生类型（“x2”、“y2”、“z2”），
新衍生类型（“x3”、“y3”、“z3”），
新衍生类型（“x4”、“y4”、“z4”），
...
}

如果值实际上是“x1”等，那么：

var list = new List<BaseType>(SomeValue);
for (int i = 1; i < SomeValue; i++) { 
  list.Add(new DerivedType {
    x = string.Format("x{0}", i),
    y = string.Format("y{0}", i),
    z = string.Format("z{0}", i)
  });
}

或者，如果这些只是样本值（或者即使不是），只需向

DerivedType

添加一个构造函数，允许您一次性传递三个属性，就可以减少混乱：

var list = Enumerable.Range(1, n)
                     .Select(i => (BaseType) new DerivedType {
                                 x = "x" + i,
                                 y = "y" + i,
                                 z = "z" + i
                             })
                     .ToList();

新列表
{
新衍生类型（“x1”、“y1”、“z1”），
新衍生类型（“x2”、“y2”、“z2”），
新衍生类型（“x3”、“y3”、“z3”），
新衍生类型（“x4”、“y4”、“z4”），
...
}

您需要一行或两行代码（您可以从NuGet获得）：

List List=Builder.CreateListOfSize（5.Build（））
.ToList（）；

它使用值初始化所有属性（属性名称+元素索引）

您需要一行或两行代码（您可以从NuGet获得）：

List List=Builder.CreateListOfSize（5.Build（））
.ToList（）；

---

它使用值初始化所有属性（属性名称+元素索引）

我会使用一个简单的数组来保存数据。然后使用此数组构建派生类型。注意，数据值可以是任意的（这里显示的是字符串和int类型）。只需使用字符串数组，就可以针对原始问题对其进行优化

List<BaseType> list = Builder<DerivedType>.CreateListOfSize(5).Build()
                                          .ToList<BaseType>();

对象[]数据=
{
“x1”，“y1”，4，
“x2”，“y2”，3，
“x3”、“y3”、2、，
“x4”、“y4”和“3”
};
int countPerType=3；
int size=data.Length；
var initMe=新列表（）；
for（int idx=0；idx

我会使用一个简单的数组来保存数据。然后使用此数组构建派生类型。注意，数据值可以是任意的（这里显示的是字符串和int类型）。只需使用字符串数组，就可以针对原始问题对其进行优化

List<BaseType> list = Builder<DerivedType>.CreateListOfSize(5).Build()
                                          .ToList<BaseType>();

对象[]数据=
{
“x1”，“y1”，4，
“x2”，“y2”，3，
“x3”、“y3”、2、，
“x4”、“y4”和“3”
};
int countPerType=3；
int size=data.Length；
var initMe=新列表（）；
for（int idx=0；idx

我觉得奇怪的是，没有人解决老年退休金计划这个更一般的问题，而是把重点放在这个例子中人为设计的特例上

正如这里所有重量级人物所注意到的，对于本例的特定情况，正如Perl苦行僧可能会说的那样，“-有多种方法可以做到这一点。有些比其他更好（或至少更简洁）

在更一般的情况下，事情并不都是单调序列，我认为没有什么比这更好的了。你被很多重复的样板文件困住了

C#没有JSON或Javascript的对象初始值设定项，或C（2000年随C99引入），所有这些都为这类事情提供了更简洁的语法。很遗憾，如果你问我的话

这里有一个想法，虽然有点丑陋：

SCG.List

和许多其他

SCG

集合有一个构造函数重载，它接受一个

IEnumerable

，

IDictionary

或类似的东西，从中填充正在构建的对象。可以想象，您可以将程序集中所需的数据以一种便于使用的格式嵌入到程序集中。它甚至不必是嵌入式资源：一个简单的多行字符串文字，每个项目有一个逗号分隔的行，就可以做到这一点。提供一个简单的工厂类或方法，使用该资源生成LINQy

IEnumerable

小部件流，这些小部件可以交给

List

构造函数和Bob的叔叔

---

就像我说的，有点难看，但它可以避免重复打字。

我觉得奇怪的是，没有人解决老年退休金计划更一般的问题，而是专注于人为设计的特殊问题

new BaseTypeList
{
    { "x1", "y1", "z1" },
    { "x2", "y2", "z2" },
    { "x3", "y3", "z3" },
    { "x4", "y4", "z3" /* (sic) */ },
    //...
}

public class BaseTypeList : List<BaseType>
{
    public void Add(Type t, string x, string y, string z)
    {
        Add((BaseType)Activator.CreateInstance(t, x, y, z));
    }
}

new BaseTypeList
{
    { typeof(DerivedType1), "x1", "y1", "z1" },
    { typeof(DerivedType1), "x2", "y2", "z2" },
    { typeof(DerivedType2), "x3", "y3", "z3" },
    { typeof(DerivedType2), "x4", "y4", "z3" /* (sic) */ },
    //...
}