C# 我如何创建一个方法来创建一系列对象？

每当我编写C#时，我都会一直使用Linq，因为我喜欢它，而且它允许我像函数式程序员一样思考，我发现这比命令式编程容易得多。我在创建对象的随机列表时经常使用的约定如下：

var animals= Enumerable.Range(0, 100).Select(n => new Animal()).ToList();

我知道这是（可能更慢）for循环的同步糖，它将项目添加到列表中。这对我来说是完全可以接受的，因为它不会冒犯我的感情。以下是我不喜欢的：

变量动物=可枚举。范围（01100）。选择（n=>new Animal（））。ToList（）

我想做一个助手Func，它可以用更少的输入来完成这项工作。理想情况下，我想键入：

var animals = NewRange(0, 100, Animal);

但我对如何做到这一点（如果可能的话）感到困惑。我可以使用反射和其他各种恶心的东西（恶心！），但是如果没有反射，我就无法理解。这是我得到的最接近的结果：

public Func<int, Type, List<object>> NewRange = (n, t) => Enumerable.Range(0, n).Select(o => new t()).ToList();

public Func NewRange=（n，t）=>Enumerable.Range（0，n）。选择（o=>newt（））.ToList（）；

---

但这不会编译（因为显而易见的原因）。有人对我如何创建方便的dandy函数有什么建议吗

试试这样的方法：

public static List<T> NewRange<T>(int n) where T: new()
{
    return Enumerable.Range(0, n).Select(_ => new T()).ToList();
}

public static List<T> CreateList<T>(int numberOfItems) where T : new()
{       
    var result = new List<T>(numberOfItems);
    for (int ix = 0; ix < numberOfItems; ix++)
    {
        result.Add(new T());
    }
    return result;
}

公共静态列表NewRange（int n），其中T:new（）
{
返回可枚举的.Range（0，n）.Select（=>newt（））.ToList（）；
}

或与表情体成员：

public static List<T> NewRange<T>(int n) where T : new() => 
        Enumerable.Range(0, n).Select(_ => new T()).ToList();

公共静态列表NewRange（int n），其中T:new（）=>
Enumerable.Range（0，n）.Select（=>newt（））.ToList（）；

并使用它：

var animals = NewRange<Animal>(100);

var动物=新范围（100）；

试试这样的方法：

public static List<T> NewRange<T>(int n) where T: new()
{
    return Enumerable.Range(0, n).Select(_ => new T()).ToList();
}

public static List<T> CreateList<T>(int numberOfItems) where T : new()
{       
    var result = new List<T>(numberOfItems);
    for (int ix = 0; ix < numberOfItems; ix++)
    {
        result.Add(new T());
    }
    return result;
}

公共静态列表NewRange（int n），其中T:new（）
{
返回可枚举的.Range（0，n）.Select（=>newt（））.ToList（）；
}

或与表情体成员：

public static List<T> NewRange<T>(int n) where T : new() => 
        Enumerable.Range(0, n).Select(_ => new T()).ToList();

公共静态列表NewRange（int n），其中T:new（）=>
Enumerable.Range（0，n）.Select（=>newt（））.ToList（）；

并使用它：

var animals = NewRange<Animal>(100);

var动物=新范围（100）；

您需要一个类型约束来确保可以实例化

T

，因此：

List<T> NewRange<T>(int howMany) where T : new()
{
    return Enumerable.Range(0, howMany).Select(n => new T()).ToList();
}

列出新范围（int-howMany），其中T:new（）
{
返回可枚举的.Range（0，howmount）.Select（n=>newt（））.ToList（）；
}

你可以像这样使用它：

var animals = NewRange<Animal>(100);

var动物=新范围（100）；

您需要一个类型约束来确保可以实例化

T

，因此：

List<T> NewRange<T>(int howMany) where T : new()
{
    return Enumerable.Range(0, howMany).Select(n => new T()).ToList();
}

列出新范围（int-howMany），其中T:new（）
{
返回可枚举的.Range（0，howmount）.Select（n=>newt（））.ToList（）；
}

你可以像这样使用它：

var animals = NewRange<Animal>(100);

var动物=新范围（100）；

那么您最终只需要一个IEnumerable，用n个实例初始化，所有实例都使用默认构造函数

像这样的东西怎么样：

public static List<T> NewRange<T>(int n) where T: new()
{
    return Enumerable.Range(0, n).Select(_ => new T()).ToList();
}

public static List<T> CreateList<T>(int numberOfItems) where T : new()
{       
    var result = new List<T>(numberOfItems);
    for (int ix = 0; ix < numberOfItems; ix++)
    {
        result.Add(new T());
    }
    return result;
}

公共静态列表CreateList（int numberOfItems），其中T:new（）
{       
var结果=新列表（numberOfItems）；
对于（int ix=0；ix

那么您最终只需要一个IEnumerable，用n个实例初始化，所有实例都使用默认构造函数

像这样的东西怎么样：

public static List<T> NewRange<T>(int n) where T: new()
{
    return Enumerable.Range(0, n).Select(_ => new T()).ToList();
}

public static List<T> CreateList<T>(int numberOfItems) where T : new()
{       
    var result = new List<T>(numberOfItems);
    for (int ix = 0; ix < numberOfItems; ix++)
    {
        result.Add(new T());
    }
    return result;
}

公共静态列表CreateList（int numberOfItems），其中T:new（）
{       
var结果=新列表（numberOfItems）；
对于（int ix=0；ix

您可以向函数传递lambda来创建新对象：

public static List<T> NewRange<T>(int n, Func<T> NewObject) {
    return Enumerable.Range(0, n).Select(_ => NewObject()).ToList();
}

---

可以将lambda传递给函数以创建新对象：

public static List<T> NewRange<T>(int n, Func<T> NewObject) {
    return Enumerable.Range(0, n).Select(_ => NewObject()).ToList();
}

---

我不确定你是否能在没有任何思考的情况下处理好你的问题

下面是一个小示例，说明如何使用泛型类型简化它：

public void Main()
{
   var animals = NewRange<Animal>(0, 100);
}

public static List<T> NewRange<T>(int n, int b)
{
   return (List<T>)Enumerable.Range(n, b).Select(instance => (T)Activator.CreateInstance(typeof(T))).ToList();
}

public void Main（）
{
动物变量=新范围（0，100）；
}
公共静态列表新范围（int n，int b）
{
return（List）Enumerable.Range（n，b）.Select（instance=>（T）Activator.CreateInstance（typeof（T））.ToList（）；
}

---

我希望这将正确回答您的问题，并符合您的需要

我不确定您是否可以不经过任何思考就处理好您的问题

下面是一个小示例，说明如何使用泛型类型简化它：

public void Main()
{
   var animals = NewRange<Animal>(0, 100);
}

public static List<T> NewRange<T>(int n, int b)
{
   return (List<T>)Enumerable.Range(n, b).Select(instance => (T)Activator.CreateInstance(typeof(T))).ToList();
}

public void Main（）
{
动物变量=新范围（0，100）；
}
公共静态列表新范围（int n，int b）
{
return（List）Enumerable.Range（n，b）.Select（instance=>（T）Activator.CreateInstance（typeof（T））.ToList（）；
}

---

我希望这将正确回答您的问题，并符合您的需要

快速、准确的回答。我不喜欢使用可枚举的。范围，因为你真的不需要一个递增的数字范围。好的，快速的答案。我不喜欢使用Enumerable.Range，因为你真的不需要一系列递增的数字。比我快7秒！；-）我很惊讶你在7秒后发布了答案，然后在5秒后发布了@Tim:）这是一个很好的答案，但与下面类似，我不知道为什么Range方法有用（除了在问题中使用它的事实）。它是为递增列表而设计的，这似乎非常适合这个用例。您的第一个答案甚至不会编译。函数

NewRange

后缺少分号和类型。有关正确的语法，请参见其他答案。另外，您的呼叫示例应该传递一个号码，而不是

n

。如果你想知道的话，这可能就是投反对票的原因。我不投反对票，我更喜欢发表评论，这样大家都会受益。@RacilHilan谢谢，我真的错过了分号并键入了）比我快了7秒！；-）我很惊讶你在7秒后发布了答案，然后在5秒后发布了@Tim:）这是一个很好的答案，但与下面类似，我不知道为什么Range方法有用（除了在问题中使用它的事实）。它是为递增列表而设计的，这似乎非常适合这个用例。您的第一个答案甚至不会编译。函数

NewRange

后缺少分号和类型。有关正确的语法，请参见其他答案。还有你的电话e