Instanz eines generischen Typs erstellen, deren Konstruktor einen Parameter benötigt?

Wenn BaseFruitein Konstruktor einen akzeptiert int weight, kann ich ein Stück Obst in einer generischen Methode wie dieser instanziieren?

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

Ein Beispiel wird hinter Kommentaren hinzugefügt. Es scheint, dass ich dies nur tun kann, wenn ich BaseFruiteinen parameterlosen Konstruktor gebe und dann alles über Mitgliedsvariablen ausfülle. In meinem wirklichen Code (nicht über Obst) ist dies ziemlich unpraktisch.

-Update-
Es scheint also, dass es dann in keiner Weise durch Einschränkungen gelöst werden kann. Aus den Antworten ergeben sich drei mögliche Lösungen:

• Fabrikmuster
• Reflexion
• Aktivator

Ich neige dazu zu denken, dass Reflexion die am wenigsten saubere ist, aber ich kann mich nicht zwischen den beiden anderen entscheiden.

Zusätzlich ein einfacheres Beispiel:

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

Beachten Sie, dass die Verwendung der new () - Einschränkung für T nur dazu dient, dass der Compiler zur Kompilierungszeit nach einem öffentlichen parameterlosen Konstruktor sucht. Der tatsächliche Code, der zum Erstellen des Typs verwendet wird, ist die Activator-Klasse.

Sie müssen sich über den vorhandenen spezifischen Konstruktor informieren, und diese Art von Anforderung kann ein Codegeruch sein (oder eher etwas, das Sie in der aktuellen Version auf c # vermeiden sollten).

Sie können keinen parametrisierten Konstruktor verwenden. Sie können einen parameterlosen Konstruktor verwenden, wenn Sie eine " where T : new()" Einschränkung haben.

Es ist ein Schmerz, aber so ist das Leben :(

Dies ist eines der Dinge, die ich mit "statischen Schnittstellen" ansprechen möchte . Sie können T dann so einschränken, dass es statische Methoden, Operatoren und Konstruktoren enthält, und diese dann aufrufen.

Ja; Ändern Sie Ihren Aufenthaltsort:

where T:BaseFruit, new()

Dies funktioniert jedoch nur mit parameterlosen Konstruktoren. Sie müssen über andere Möglichkeiten zum Festlegen Ihrer Eigenschaft verfügen (Festlegen der Eigenschaft selbst oder ähnliches).

Einfachste Lösung Activator.CreateInstance<T>()

Wie Jon betonte, ist dies das Leben, um einen nicht parameterlosen Konstruktor einzuschränken. Eine andere Lösung besteht jedoch darin, ein Fabrikmuster zu verwenden. Dies ist leicht einschränkbar

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

Eine weitere Option ist die Verwendung eines funktionalen Ansatzes. Übergeben Sie eine Werksmethode.

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

Sie können dies mithilfe der Reflexion tun:

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

BEARBEITEN: Konstruktor == Nullprüfung hinzugefügt.

EDIT: Eine schnellere Variante mit einem 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) });
}

Als Ergänzung zum Vorschlag von user1471935:

Um eine generische Klasse mithilfe eines Konstruktors mit einem oder mehreren Parametern zu instanziieren, können Sie jetzt die Activator-Klasse verwenden.

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

Die Liste der Objekte sind die Parameter, die Sie angeben möchten. Laut Microsoft :

CreateInstance [...] erstellt eine Instanz des angegebenen Typs mit dem Konstruktor, der den angegebenen Parametern am besten entspricht.

Es gibt auch eine generische Version von CreateInstance ( CreateInstance<T>()), aber diese erlaubt es Ihnen auch nicht, Konstruktorparameter anzugeben .

Ich habe diese Methode erstellt:

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

Ich benutze das so:

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

Kürzlich bin ich auf ein sehr ähnliches Problem gestoßen. Ich wollte nur unsere Lösung mit Ihnen allen teilen. Ich wollte eine Instanz von a Car<CarA>aus einem json-Objekt erstellen, das eine Aufzählung hatte:

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

Mit hoher Leistung ist es immer noch möglich, Folgendes zu tun:

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

und

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

Die relevanten Klassen müssen dann von dieser Schnittstelle abgeleitet und entsprechend initialisiert werden. Bitte beachten Sie, dass dieser Code in meinem Fall Teil einer umgebenden Klasse ist, die bereits <T> als generischen Parameter hat. R ist in meinem Fall auch eine schreibgeschützte Klasse. IMO hat die öffentliche Verfügbarkeit von Initialize () -Funktionen keinen negativen Einfluss auf die Unveränderlichkeit. Der Benutzer dieser Klasse könnte ein anderes Objekt einfügen, dies würde jedoch die zugrunde liegende Sammlung nicht ändern.