Utworzyć wystąpienie typu ogólnego, którego konstruktor wymaga parametru?

Jeśli BaseFruitma konstruktora, który akceptuje int weight, czy mogę utworzyć egzemplarz owocu za pomocą ogólnej metody takiej jak ta?

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

Przykład został dodany za komentarzami. Wydaje się, że mogę to zrobić tylko wtedy, gdy podam BaseFruitkonstruktor bez parametrów, a następnie wypełnię wszystko przez zmienne składowe. W moim prawdziwym kodzie (nie o owocach) jest to raczej niepraktyczne.

-Aktualizacja-
Wygląda więc na to, że nie można w żaden sposób rozwiązać ograniczeń. Z odpowiedzi istnieją trzy kandydujące rozwiązania:

• Wzór fabryczny
• Odbicie
• Aktywator

Wydaje mi się, że odbicie jest najmniej czyste, ale nie mogę się zdecydować między pozostałymi dwoma.

Dodatkowo prostszy przykład:

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

Zauważ, że użycie nowego ograniczenia () na T służy tylko do sprawdzania przez kompilator publicznego konstruktora bez parametrów w czasie kompilacji, rzeczywistym kodem użytym do utworzenia typu jest klasa Activator.

Musisz upewnić się co do konkretnego konstruktora, a tego rodzaju wymaganiem może być zapach kodu (a raczej coś, czego powinieneś po prostu unikać w obecnej wersji na c #).

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

To ból, ale takie jest życie :(

Jest to jedna z rzeczy, które chciałbym rozwiązać za pomocą „interfejsów statycznych” . Będziesz wtedy mógł ograniczyć T do włączenia metod statycznych, operatorów i konstruktorów, a następnie wywołać je.

Tak; zmień swoje miejsce pobytu:

where T:BaseFruit, new()

Działa to jednak tylko z konstruktorami bez parametrów . Będziesz musiał mieć inne sposoby na ustawienie swojej właściwości (ustawienie samej nieruchomości lub czegoś podobnego).

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

Jak zauważył Jon, jest to życie w ograniczaniu nieparametrycznego konstruktora. Jednak innym rozwiązaniem jest użycie wzorca fabrycznego. Można to łatwo ograniczyć

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 inną opcją jest zastosowanie podejścia funkcjonalnego. Przekaż metodę fabryczną.

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

Możesz to zrobić za pomocą odbicia:

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

EDYCJA: Dodano konstruktor == kontrola zerowa.

EDYCJA: Szybszy wariant wykorzystujący pamięć podręczną:

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

Jako dodatek do sugestii użytkownika1471935:

Aby utworzyć instancję klasy ogólnej za pomocą konstruktora z co najmniej jednym parametrem, możesz teraz użyć klasy Activator.

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

Lista obiektów to parametry, które chcesz podać. Według Microsoft :

CreateInstance [...] tworzy instancję określonego typu za pomocą konstruktora, który najlepiej pasuje do określonych parametrów.

Istnieje również ogólna wersja CreateInstance ( CreateInstance<T>()), ale ta również nie pozwala na podanie parametrów konstruktora.

Stworzyłem tę metodę:

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

Używam tego w ten sposób:

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

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

Kod:

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

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

Ostatnio natknąłem się na bardzo podobny problem. Chciałem tylko podzielić się z Wami naszym rozwiązaniem. Chciałem utworzyć instancję obiektu Car<CarA>z obiektu Json, który miał wyliczenie:

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

Nadal jest to możliwe, przy 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 );
}

Odpowiednie klasy muszą następnie wyprowadzić się z tego interfejsu i odpowiednio zainicjować. Proszę 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 jest także 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 to podstawowej kolekcji.