Buat instance tipe generik yang konstruktornya memerlukan parameter?

Jika BaseFruitmemiliki konstruktor yang menerima int weight, bisakah saya instantiate sepotong buah dengan metode generik seperti ini?

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

Contoh ditambahkan di balik komentar. Sepertinya saya hanya dapat melakukan ini jika saya memberikan BaseFruitkonstruktor tanpa parameter dan kemudian mengisi semuanya melalui variabel anggota. Dalam kode asli saya (bukan tentang buah) ini agak tidak praktis.

-Perbaharui-
Jadi sepertinya itu tidak bisa diselesaikan dengan kendala dengan cara apa pun. Dari jawaban ada tiga solusi kandidat:

• Pola Pabrik
• Refleksi
• Penggerak

Saya cenderung berpikir refleksi adalah yang paling bersih, tetapi saya tidak bisa memutuskan di antara keduanya.

Selain itu contoh yang lebih sederhana:

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

Perhatikan bahwa menggunakan batasan baru () pada T hanya untuk membuat pemeriksaan kompiler untuk konstruktor tanpa parameter publik pada waktu kompilasi, kode aktual yang digunakan untuk membuat tipe adalah kelas Activator.

Anda perlu memastikan diri Anda mengenai konstruktor spesifik yang ada, dan persyaratan semacam ini mungkin berupa bau kode (atau lebih tepatnya sesuatu yang harus Anda coba hindari dalam versi saat ini di c #).

Anda tidak dapat menggunakan konstruktor parameterised apa pun. Anda dapat menggunakan konstruktor tanpa parameter jika Anda memiliki where T : new()batasan " ".

Ini menyebalkan, tapi begitulah hidup :(

Ini adalah salah satu hal yang ingin saya bahas dengan "antarmuka statis" . Anda kemudian dapat membatasi T untuk memasukkan metode statis, operator dan konstruktor, dan kemudian memanggil mereka.

Iya; ubah tempat Anda menjadi:

where T:BaseFruit, new()

Namun, ini hanya berfungsi dengan konstruktor tanpa parameter . Anda harus memiliki cara lain untuk menyetel properti Anda (menyetel properti itu sendiri atau yang serupa).

Solusi paling sederhana Activator.CreateInstance<T>()

Seperti yang ditunjukkan Jon, ini adalah masa pakai untuk membatasi konstruktor yang tidak memiliki parameter. Namun solusi yang berbeda adalah dengan menggunakan pola pabrik. Ini mudah dibatasi

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);
}

Namun pilihan lain adalah menggunakan pendekatan fungsional. Lewati metode pabrik.

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

Anda dapat melakukannya dengan menggunakan refleksi:

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);
}

EDIT: Menambahkan konstruktor == cek kosong.

EDIT: Varian yang lebih cepat menggunakan cache:

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) });
}

Sebagai tambahan untuk saran pengguna1471935:

Untuk membuat instance kelas generik dengan menggunakan konstruktor dengan satu atau lebih parameter, Anda sekarang dapat menggunakan kelas Activator.

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

Daftar objek adalah parameter yang ingin Anda berikan. Menurut Microsoft :

CreateInstance [...] membuat turunan dari tipe yang ditentukan menggunakan konstruktor yang paling cocok dengan parameter yang ditentukan.

Ada juga versi generik dari CreateInstance ( CreateInstance<T>()) tetapi yang satu itu juga tidak memungkinkan Anda untuk menyediakan parameter konstruktor.

Saya membuat metode ini:

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;
}

Saya menggunakannya dengan cara ini:

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

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

Kode:

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

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

Baru-baru ini saya menemukan masalah yang sangat mirip. Hanya ingin berbagi solusi kami dengan Anda semua. Saya ingin saya membuat contoh dari Car<CarA>menggunakan objek json yang memiliki enum:

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) });

Itu masih mungkin, dengan kinerja tinggi, dengan melakukan hal berikut:

    //
    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;
    }

dan

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

Kelas-kelas yang relevan kemudian harus berasal dari antarmuka ini dan menginisialisasi sesuai. Harap dicatat, bahwa dalam kasus saya, kode ini adalah bagian dari kelas di sekitarnya, yang sudah memiliki <T> sebagai parameter generik. R, dalam kasus saya, juga adalah kelas read-only. IMO, ketersediaan publik dari fungsi Initialize () tidak memiliki efek negatif pada imutabilitas. Pengguna kelas ini bisa memasukkan objek lain, tetapi ini tidak akan mengubah koleksi yang mendasarinya.