为了在函数中创建泛型类型的实例，必须使用"new"标志约束它。

public static string GetAllItems<T>(...) where T : new()

但是，只有当你想调用没有参数的构造函数时，这才会起作用。这里不是这样。相反，您必须提供另一个参数，允许基于参数创建对象。最简单的是函数。

public static string GetAllItems<T>(..., Func<ListItem,T> del) {
  ...
  List<T> tabListItems = new List<T>();
  foreach (ListItem listItem in listCollection) 
  {
    tabListItems.Add(del(listItem));
  }
  ...
}

然后你可以这样称呼它

GetAllItems<Foo>(..., l => new Foo(l));

因为没有人愿意发表“反思”的答案(我个人认为这是最好的答案)，下面是:

public static string GetAllItems<T>(...) where T : new()
{
   ...
   List<T> tabListItems = new List<T>();
   foreach (ListItem listItem in listCollection) 
   {
       Type classType = typeof(T);
       ConstructorInfo classConstructor = classType.GetConstructor(new Type[] { listItem.GetType() });
       T classInstance = (T)classConstructor.Invoke(new object[] { listItem });

       tabListItems.Add(classInstance);
   } 
   ...
}

编辑:由于. net 3.5的Activator，这个答案已弃用。CreateInstance，但是它在旧的。net版本中仍然有用。

这有点麻烦，当我说有点麻烦时，我可能是指讨厌，但假设你可以为你的参数化类型提供一个空构造函数，那么:

public static T GetTInstance<T>() where T: new()
{
    var constructorTypeSignature = new Type[] {typeof (object)};
    var constructorParameters = new object[] {"Create a T"};
    return (T) new T().GetType().GetConstructor(constructorTypeSignature).Invoke(constructorParameters);
}

将有效地允许您从带有参数的参数化类型构造一个对象。在这种情况下，我假设我想要的构造函数有一个类型object的参数。我们使用约束允许的空构造函数创建T的虚拟实例，然后使用反射获取它的其他构造函数之一。

我认为必须用where语句约束T，以只允许具有新构造函数的对象。

现在它接受任何东西，包括没有它的对象。

使用c# 11中的静态抽象接口方法特性，可以使用工厂模式构建一个变通方案。例如:

public interface IFactory<TSelf> where TSelf : IFactory<TSelf> {
  static abstract TSelf New(int i, string s);
}

public struct Foo : IFactory<Foo> {

  public static Foo New(int i, string s) {
    return new Foo(i, s);
  }

  public readonly int I;
  public readonly string S;

  public Foo(int i, string s) {
    I = i;
    S = s;
  }
}

public static class Maker {
  public static T Make<T>(int i, string s) where T : IFactory<T> {
    return T.New(i, s);
  }
}

这种方法的一个限制是它只能用于您拥有的类，因为您需要在目标类上实现特定的工厂接口。

我有时使用类似于使用属性注入的答案的方法，但使代码更简洁。 它没有一个带有一组属性的基类/接口，只包含一个(虚拟的)Initialize()方法，充当“穷人的构造函数”。 然后，您可以让每个类像构造函数一样处理自己的初始化，这也为处理继承链增加了一种方便的方式。

If经常发现自己处于这样的情况:我希望链中的每个类初始化其唯一属性，然后调用其父类的initialize()方法，该方法反过来初始化父类的唯一属性，以此类推。当具有不同的类，但具有相似的层次结构时，这尤其有用，例如映射到DTO:s的业务对象。

使用普通Dictionary进行初始化的示例:

void Main()
{
    var values = new Dictionary<string, int> { { "BaseValue", 1 }, { "DerivedValue", 2 } };

    Console.WriteLine(CreateObject<Base>(values).ToString());

    Console.WriteLine(CreateObject<Derived>(values).ToString());
}

public T CreateObject<T>(IDictionary<string, int> values)
    where T : Base, new()
{
    var obj = new T();
    obj.Initialize(values);
    return obj;
}

public class Base
{
    public int BaseValue { get; set; }

    public virtual void Initialize(IDictionary<string, int> values)
    {
        BaseValue = values["BaseValue"];
    }

    public override string ToString()
    {
        return "BaseValue = " + BaseValue;
    }
}

public class Derived : Base
{
    public int DerivedValue { get; set; }

    public override void Initialize(IDictionary<string, int> values)
    {
        base.Initialize(values);
        DerivedValue = values["DerivedValue"];
    }

    public override string ToString()
    {       
        return base.ToString() + ", DerivedValue = " + DerivedValue;
    }
}