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

Question

Si BaseFruit a un constructeur qui 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 peux le faire que si je donne BaseFruit un constructeur sans paramètre et ensuite remplir tout à travers les variables membres. Dans mon vrai code (pas sur les fruits), c'est plutôt impraticable.

-Update-
Il semble donc qu'il ne peut pas être résolu par des contraintes de quelque façon alors. D'après les réponses, il y a trois solutions candidats:

• Motif usine
• de réflexion
• Activator

Je tends à penser la réflexion est la moins propre, mais je ne peux pas décider entre la deux autres.

Answer 1

De plus, un exemple plus simple:

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

Notez que l'utilisation de la nouvelle() contrainte sur T est seulement de faire le compilateur vérifier un constructeur public sans paramètre à 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 genre 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#).

Answer 2

Oui; changer votre où être:

where T:BaseFruit, new() 

Cependant, cela ne fonctionne qu'avec constructeurs parameterless. Vous devrez avoir d'autres moyens de définir votre propriété (définir la propriété elle-même ou quelque chose de similaire).

Answer 3

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

Il est une douleur, mais telle est la vie :(

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

Answer 4

Comme Jon a souligné c'est la vie pour contraindre un constructeur non parameterless. Cependant, une autre solution est d'utiliser un modèle d'usine. 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); 
} 

une autre option est d'utiliser une approche fonctionnelle. Passer 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); 
} 

Answer 5

Vous pouvez 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: constructeur Ajouté == null chèque.

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

Answer 6

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

Answer 7

Récemment, je suis tombé sur un problème très similaire. Je voulais juste partager notre solution avec vous tous. Je voulais que je créé une instance d'un Car<CarA> d'un objet JSON en utilisant ce qui avait un 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) }); 

Answer 8

Il est encore 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 concernées doivent ensuite 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. IMO, la disponibilité publique des fonctions Initialize() n'a aucun effet négatif sur l'immutabilité. L'utilisateur de cette classe pourrait placer un autre objet, mais cela ne modifierait pas la collection sous-jacente.