Créer une instance de type générique dont le constructeur nécessite un paramètre?

Si BaseFruitun constructeur accepte un int weight, puis-je instancier un fruit dans une méthode générique comme celle-ci?

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

Un exemple est ajouté derrière les commentaires. Il semble que je ne puisse le faire que si je donne BaseFruitun constructeur sans paramètre et que je remplis tout par le biais de variables membres. Dans mon vrai code (pas sur les fruits), c'est plutôt peu pratique.

-Update-
Il semble donc que cela ne puisse être résolu par aucune contrainte. D'après les réponses, il existe trois solutions possibles:

• Modèle d'usine
• Réflexion
• Activateur

J'ai tendance à penser que la réflexion est la moins nette, mais je ne peux pas choisir entre les deux autres.

De plus, un exemple plus simple:

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

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

Vous devrez vous assurer du constructeur spécifique existant, et ce type d'exigence peut être une odeur de code (ou plutôt quelque chose que vous devriez simplement essayer d'éviter dans la version actuelle sur c #).

Vous ne pouvez utiliser aucun constructeur paramétré. Vous pouvez utiliser un constructeur sans paramètre si vous avez une where T : new()contrainte " ".

C'est une douleur, mais telle est la vie :(

C'est une des choses que j'aimerais aborder avec les "interfaces statiques" . Vous seriez alors en mesure de contraindre T à inclure des méthodes statiques, des opérateurs et des constructeurs, puis à les appeler.

Oui; changez votre endroit:

where T:BaseFruit, new()

Cependant, cela ne fonctionne qu'avec des constructeurs sans paramètres . Vous devrez avoir un autre moyen de définir votre propriété (définir la propriété elle-même ou quelque chose de similaire).

La solution la plus simple Activator.CreateInstance<T>()

Comme Jon l'a souligné, c'est la vie pour contraindre un constructeur sans paramètre. Cependant, une solution différente consiste à utiliser un modèle d'usine. C'est facilement contraignable

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 consiste à utiliser une approche fonctionnelle. Passez dans une méthode d'usine.

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

Vous pouvez le faire en utilisant la réflexion:

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: ajout du constructeur == vérification nulle.

EDIT: Une variante plus rapide utilisant un 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) });
}

En complément de la suggestion de user1471935:

Pour instancier une classe générique à l'aide d'un constructeur avec un ou plusieurs paramètres, vous pouvez désormais utiliser la classe Activator.

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

La liste des objets sont les paramètres que vous souhaitez fournir. Selon Microsoft :

CreateInstance [...] crée une instance du type spécifié en utilisant le constructeur qui correspond le mieux aux paramètres spécifiés.

Il existe également une version générique de CreateInstance ( CreateInstance<T>()) mais celle-ci ne vous permet pas non plus de fournir des paramètres de constructeur.

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

J'utilise cela 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);

Récemment, je suis tombé sur un problème très similaire. Je voulais juste partager notre solution avec vous tous. Je voulais j'ai créé une instance d'un à Car<CarA>partir d'un objet json en utilisant qui avait une énumération:

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

Il est toujours possible, avec des performances élevées, en procédant comme suit:

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

et

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

Les classes pertinentes doivent alors dériver de cette interface et s'initialiser en conséquence. Veuillez noter que dans mon cas, ce code fait partie d'une classe environnante, qui a déjà <T> comme paramètre générique. R, dans mon cas, est également une classe en lecture seule. OMI, la disponibilité publique des fonctions Initialize () n'a aucun effet négatif sur l'immuabilité. L'utilisateur de cette classe pourrait placer un autre objet, mais cela ne modifierait pas la collection sous-jacente.