创建其构造函数需要参数的泛型类型的实例？

如果BaseFruit有一个接受的构造函数，int weight我可以用这种通用方法实例化一块水果吗？

public void AddFruit<T>()where T: BaseFruit{
    BaseFruit fruit = new T(weight); /*new Apple(150);*/
    fruit.Enlist(fruitManager);
}

在注释后面添加了一个示例。似乎只有提供BaseFruit无参数构造函数，然后通过成员变量填写所有内容，我才能做到这一点。用我的真实代码（不是关于水果），这是不切实际的。

-更新-
因此，看来无论如何都无法通过约束来解决。从答案中可以找到三种候选解决方案：

• 工厂模式
• 反射
• 活化剂

我倾向于认为反射是最不干净的一种，但是我无法在其他两种之间做出选择。

另外一个简单的例子：

return (T)Activator.CreateInstance(typeof(T), new object[] { weight });

请注意，在T上使用new（）约束只是使编译器在编译时检查公共的无参数构造函数，用于创建该类型的实际代码是Activator类。

您将需要确保自己与现有的特定构造函数有关，并且这种要求可能是代码气味（或者，您应该在c＃的当前版本中尝试避免这种情况）。

您不能使用任何参数化的构造函数。如果有“ where T : new()”约束，则可以使用无参数构造函数。

这很痛苦，但是生活就是这样：(

这是我想通过“静态接口”解决的事情之一。然后，您可以限制T包含静态方法，运算符和构造函数，然后调用它们。

是; 更改您的位置：

where T:BaseFruit, new()

但是，这仅适用于无参数构造函数。您将不得不通过其他方式设置属性（设置属性本身或类似属性）。

最简单的解决方案 Activator.CreateInstance<T>()

正如Jon指出的那样，这是约束非参数化构造函数的生命。但是，另一种解决方案是使用工厂模式。这很容易约束

interface IFruitFactory<T> where T : BaseFruit {
  T Create(int weight);
}

public void AddFruit<T>( IFruitFactory<T> factory ) where T: BaseFruit {    
  BaseFruit fruit = factory.Create(weight); /*new Apple(150);*/    
  fruit.Enlist(fruitManager);
}

另一个选择是使用功能性方法。传入工厂方法。

public void AddFruit<T>(Func<int,T> factoryDel) where T : BaseFruit { 
  BaseFruit fruit = factoryDel(weight); /* new Apple(150); */
  fruit.Enlist(fruitManager);
}

您可以使用反射来做：

public void AddFruit<T>()where T: BaseFruit
{
  ConstructorInfo constructor = typeof(T).GetConstructor(new Type[] { typeof(int) });
  if (constructor == null)
  {
    throw new InvalidOperationException("Type " + typeof(T).Name + " does not contain an appropriate constructor");
  }
  BaseFruit fruit = constructor.Invoke(new object[] { (int)150 }) as BaseFruit;
  fruit.Enlist(fruitManager);
}

编辑：添加了构造函数==空检查。

编辑：使用缓存的更快变体：

public void AddFruit<T>()where T: BaseFruit
{
  var constructor = FruitCompany<T>.constructor;
  if (constructor == null)
  {
    throw new InvalidOperationException("Type " + typeof(T).Name + " does not contain an appropriate constructor");
  }
  var fruit = constructor.Invoke(new object[] { (int)150 }) as BaseFruit;
  fruit.Enlist(fruitManager);
}
private static class FruitCompany<T>
{
  public static readonly ConstructorInfo constructor = typeof(T).GetConstructor(new Type[] { typeof(int) });
}

作为对user1471935的建议的补充：

若要通过使用带有一个或多个参数的构造函数实例化泛型类，现在可以使用Activator类。

T instance = Activator.CreateInstance(typeof(T), new object[] {...}) 

对象列表是您要提供的参数。根据微软的说法：

CreateInstance [...]使用与指定参数最匹配的构造函数创建指定类型的实例。

还有一个通用版本的CreateInstance（CreateInstance<T>()），但该版本也不允许您提供构造函数参数。

我创建了这种方法：

public static V ConvertParentObjToChildObj<T,V> (T obj) where V : new()
{
    Type typeT = typeof(T);
    PropertyInfo[] propertiesT = typeT.GetProperties();
    V newV = new V();
    foreach (var propT in propertiesT)
    {
        var nomePropT = propT.Name;
        var valuePropT = propT.GetValue(obj, null);

        Type typeV = typeof(V);
        PropertyInfo[] propertiesV = typeV.GetProperties();
        foreach (var propV in propertiesV)
        {
            var nomePropV = propV.Name;
            if(nomePropT == nomePropV)
            {
                propV.SetValue(newV, valuePropT);
                break;
            }
        }
    }
    return newV;
}

我用这种方式：

public class A 
{
    public int PROP1 {get; set;}
}

public class B : A
{
    public int PROP2 {get; set;}
}

码：

A instanceA = new A();
instanceA.PROP1 = 1;

B instanceB = new B();
instanceB = ConvertParentObjToChildObj<A,B>(instanceA);

最近，我遇到了一个非常相似的问题。只想与大家分享我们的解决方案。我想Car<CarA>从一个有枚举的json对象创建一个实例：

Dictionary<MyEnum, Type> mapper = new Dictionary<MyEnum, Type>();

mapper.Add(1, typeof(CarA));
mapper.Add(2, typeof(BarB)); 

public class Car<T> where T : class
{       
    public T Detail { get; set; }
    public Car(T data)
    {
       Detail = data;
    }
}
public class CarA
{  
    public int PropA { get; set; }
    public CarA(){}
}
public class CarB
{
    public int PropB { get; set; }
    public CarB(){}
}

var jsonObj = {"Type":"1","PropA":"10"}
MyEnum t = GetTypeOfCar(jsonObj);
Type objectT = mapper[t]
Type genericType = typeof(Car<>);
Type carTypeWithGenerics = genericType.MakeGenericType(objectT);
Activator.CreateInstance(carTypeWithGenerics , new Object[] { JsonConvert.DeserializeObject(jsonObj, objectT) });

通过执行以下操作，仍然可能具有高性能：

    //
    public List<R> GetAllItems<R>() where R : IBaseRO, new() {
        var list = new List<R>();
        using ( var wl = new ReaderLock<T>( this ) ) {
            foreach ( var bo in this.items ) {
                T t = bo.Value.Data as T;
                R r = new R();
                r.Initialize( t );
                list.Add( r );
            }
        }
        return list;
    }

和

    //
///<summary>Base class for read-only objects</summary>
public partial interface IBaseRO  {
    void Initialize( IDTO dto );
    void Initialize( object value );
}

然后，相关类必须从该接口派生并进行相应的初始化。请注意，就我而言，此代码是周围类的一部分，该类已经具有<T>作为通用参数。就我而言，R也是一个只读类。IMO，Initialize（）函数的公共可用性对不变性没有负面影响。此类的用户可以放入另一个对象，但这不会修改基础集合。