コンストラクターにパラメーターが必要なジェネリック型のインスタンスを作成しますか？

BaseFruitを受け入れるコンストラクターがある場合、int weightこのようなジェネリックメソッドで果物の一部をインスタンス化できますか？

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

コメントの後ろに例が追加されています。BaseFruitパラメーターなしのコンストラクターを指定し、メンバー変数を使用してすべてを入力する場合にのみ、これを行うことができるようです。私の実際のコードでは（果物についてではなく）、これはかなり実用的ではありません。

-更新-
だから、それはそれではどのような方法でも制約によって解決できないようです。回答から3つの候補ソリューションがあります。

• 工場パターン
• 反射
• 活性剤

反射は最もクリーンなものだと思う傾向がありますが、他の2つを決定することはできません。

さらに簡単な例：

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

Tでnew（）制約を使用するのは、コンパイラーがコンパイル時にパラメーターなしのパブリックコンストラクターをチェックするためだけであることに注意してください。型の作成に使用される実際のコードは、Activatorクラスです。

特定のコンストラクターが存在することを確認する必要があります。この種の要件は、コードの匂い（または、c＃の現在のバージョンでは回避しようとするべきもの）かもしれません。

パラメーター化されたコンストラクターは使用できません。" where T : new()"制約がある場合は、パラメーターなしのコンストラクターを使用できます。

それは苦痛ですが、それは人生です:(

これは、「静的インターフェイス」で対処したいことの1つです。その後、静的メソッド、演算子、コンストラクターを含めるように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);
}

編集：コンストラクタ== nullチェックを追加しました。

編集：キャッシュを使用したより高速なバリアント：

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の提案への追加として：

1つ以上のパラメーターを持つコンストラクターを使用してジェネリッククラスをインスタンス化するために、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（）関数のパブリックアベイラビリティは、不変性に悪影響を及ぼしません。このクラスのユーザーは別のオブジェクトを配置できますが、これにより、基になるコレクションは変更されません。