Utwórz wystąpienie typu ogólnego?

Question

Jeśli BaseFruit ma konstruktora, który akceptuje int weight, mogę utworzyć wystąpienie kawałek owoców w ogólnej metody, takie jak to?

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

Przykład jest dodawany za komentarzami. Wygląda na to, że mogę to zrobić, jeśli podam BaseFruit konstruktor bez parametrów, a następnie wypełnię wszystko przez zmienne składowe. W moim prawdziwym kodzie (nie o owocach) jest to raczej niepraktyczne.

-Update-
Wydaje się więc, że nie może być rozwiązany przez ograniczenia w jakikolwiek sposób wtedy. Z odpowiedzi są trzy rozwiązania kandydujące:

• Fabryka Wzór
• Odbicie
• Activator

staram się myśleć odbicie jest czyste najmniej jeden, ale nie mogę się zdecydować pomiędzy pozostałe dwie.

Answer 1

Dodatkowo prostszy przykład:

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

Należy pamiętać, że przy użyciu nowego() ograniczenia na T jest tylko, aby kompilator sprawdź publiczny konstruktor bez parametrów w czasie kompilacji, rzeczywisty kod użyty do utworzenia typu to klasa Activator.

Musisz się upewnić, że dany konstruktor istnieje, a tego rodzaju wymaganiami może być zapach kodu (lub raczej coś, czego powinieneś unikać w aktualnej wersji na C#).

Answer 2

Tak; zmienić gdzie się:

where T:BaseFruit, new() 

Jednak ta działa tylko z bez parametrów konstruktorów. Będziesz musiał mieć inne sposoby na ustawienie swojej nieruchomości (ustawienie samej nieruchomości lub coś podobnego).

Answer 3

Nie można użyć żadnego sparametryzowanego konstruktora. Możesz użyć konstruktora bez parametrów, jeśli masz ograniczenie "where T : new()".

Jest to ból, ale takie jest życie :(

Jest to jedna z rzeczy, chciałbym zająć się "static interfaces". Można by następnie móc ograniczyć T zawierać statyczne metody, operatorów i konstruktorów , a następnie połączyć je.

Answer 4

Jak Jon zauważył to jest życie dla ograniczający non-bez parametrów konstruktora. jednak inne rozwiązanie polega na zastosowaniu wzoru fabrycznego. to jest łatwo 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); 
} 

Jeszcze inna opcja jest użycie podejście funkcjonalne. Przekaż metodę fabryczną.

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

Answer 5

Można to zrobić za pomocą refleksji:

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: Dodany konstruktor == czek wartości null.

EDIT: Szybszy wariant użyciu 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

najprostsze rozwiązanie Activator.CreateInstance<T>()

Answer 7

Ostatnio natknąłem się na bardzo podobnym problemem. Chciałem tylko podzielić się z Wami naszym rozwiązaniem. Chciałem I stworzył instancję Car<CarA> z obiektu json za pomocą którego miał 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

Jest jeszcze możliwość, o wysokiej wydajności, wykonując następujące czynności:

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

i

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

Właściwe klasy muszą następnie wyprowadzić z tego interfejsu i odpowiednio zainicjować. Należy zauważyć, że w moim przypadku ten kod jest częścią otaczającej klasy, która ma już <T> jako parametr ogólny. R, w moim przypadku, również jest klasą tylko do odczytu. IMO, publiczna dostępność funkcji Initialize() nie ma negatywnego wpływu na niezmienność. Użytkownik tej klasy może umieścić inny obiekt, ale nie zmodyfikuje podstawowej kolekcji.