Créer une instance de type générique?

En outre un exemple plus simple:

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

Notez que l'utilisation de la contrainte new() sur T est seulement pour faire le compilateur de vérifier pour un public constructeur sans paramètre au moment de la compilation, le code utilisé pour créer le type est la classe Activator.

Vous devez vous assurer vous-même quant à la spécificité du constructeur existant, et ce type de critère peut être une odeur de code (ou plutôt quelque chose que vous devez juste essayer d'éviter dans la version actuelle sur le c#).

Oui; changez d'où:

where T:BaseFruit, new()

Toutefois, cela ne fonctionne qu'avec sans paramètre constructeurs. Vous devez avoir un autre moyen de réglage de votre propriété (la définition de la propriété elle-même ou quelque chose de similaire).

Comme Jon l'a souligné, c'est la vie pour contraindre les non-constructeur sans paramètre. Cependant, une autre solution est d'utiliser un modèle de fabrique. Ceci est facilement constrainable

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

Encore une autre option est d'utiliser une approche fonctionnelle. Passer dans une méthode de fabrique.

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

Récemment je suis tombé sur un problème très similaire. Je voulais juste partager notre solution avec vous tous. J'ai voulu, j'ai créé une instance d'un Car<CarA> à partir d'un objet json à l'aide de ce qui avait 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) });

J'ai créé cette méthode:

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

- Je l'utiliser de cette façon:

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

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

Code:

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

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