Yapıcısı bir parametre gerektiren genel tip örneği mi oluşturuyor?

Kabul BaseFruiteden bir kurucu varsa , int weightböyle bir jenerik yöntemle bir parça meyve başlatabilir miyim?

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

Yorumların arkasına bir örnek eklenmiştir. Bunu sadece BaseFruitparametresiz bir kurucu verir ve sonra üye değişkenler aracılığıyla her şeyi doldurursam yapabilirim. Gerçek kodumda (meyve ile ilgili değil) bu oldukça pratik değildir.

-Güncelleme-
Öyle görünüyor ki, o zaman hiçbir şekilde kısıtlamalar ile çözülemez. Cevaplardan üç aday çözüm var:

• Fabrika Desen
• yansıma
• aktivatör

Yansımanın en az temiz olduğunu düşünmeye eğilimliyim, ancak diğer ikisi arasında karar veremiyorum.

Ayrıca daha basit bir örnek:

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

T üzerinde new () kısıtlamasını kullanmanın, derleyiciyi derleme zamanında bir genel parametresiz yapıcı için kontrol etmesini sağlamak olduğunu unutmayın, türü oluşturmak için kullanılan gerçek kod Activator sınıfıdır.

Mevcut belirli kurucu ile ilgili olarak kendinizi güvence altına almanız gerekir ve bu tür bir gereksinim bir kod kokusu olabilir (ya da c # 'daki mevcut sürümde kaçınmaya çalışmanız gereken bir şey olabilir).

Parametreli herhangi bir kurucu kullanamazsınız. " where T : new()" Kısıtlamanız varsa parametresiz bir kurucu kullanabilirsiniz .

Bu bir acı, ama hayat böyle :(

Bu "statik arayüzler" ile ele almak istediğim şeylerden biri . Daha sonra, statik yöntemleri, operatörleri ve yapıcıları dahil etmek için T'yi kısıtlayabilir ve sonra bunları çağırabilirsiniz.

Evet; nerede olduğunuzu değiştirin:

where T:BaseFruit, new()

Ancak, bu yalnızca parametresiz kurucularla çalışır . Mülkünüzü ayarlamak için başka bazı araçlara sahip olmanız gerekir (mülkün kendisini veya benzer bir şeyi ayarlamak).

En basit çözüm Activator.CreateInstance<T>()

Jon'un işaret ettiği gibi, bu parametresiz bir kurucuyu sınırlamak için hayattır. Ancak farklı bir çözüm, fabrika düzeni kullanmaktır. Bu kolayca kısıtlanabilir

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

Yine bir başka seçenek de fonksiyonel bir yaklaşım kullanmaktır. Fabrika yöntemiyle geçin.

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

Yansımayı kullanarak yapabilirsiniz:

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: Eklendi yapıcı == boş denetim.

EDIT: Önbellek kullanan daha hızlı bir varyant:

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

User1471935'in önerisine ek olarak:

Bir veya daha fazla parametreye sahip bir kurucu kullanarak genel bir sınıfı başlatmak için artık Activator sınıfını kullanabilirsiniz.

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

Nesne listesi sağlamak istediğiniz parametrelerdir. Microsoft'a göre :

CreateInstance [...], belirtilen parametrelerle en iyi eşleşen yapıcıyı kullanarak belirtilen türde bir örnek oluşturur.

Ayrıca CreateInstance ( CreateInstance<T>()) ' ın genel bir sürümü vardır, ancak bu da yapıcı parametreleri sağlamanıza izin vermez.

Bu yöntemi oluşturdum:

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

Bunu şu şekilde kullanıyorum:

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

Son zamanlarda çok benzer bir sorunla karşılaştım. Çözümümüzü hepinizle paylaşmak istedim. Ben Car<CarA>bir enum vardı kullanarak bir json nesneden bir örneği oluşturmak istedi :

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

Yüksek performansla aşağıdakileri yaparak hala mümkündür:

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

ve

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

İlgili sınıflar daha sonra bu arayüzden türetilmeli ve buna göre başlatılmalıdır. Benim durumumda, bu kodun genel parametre olarak zaten <T> olan çevreleyen bir sınıfın parçası olduğunu lütfen unutmayın. R, benim durumumda, aynı zamanda salt okunur bir sınıftır. IMO, Initialize () işlevlerinin genel kullanılabilirliğinin değişmezlik üzerinde olumsuz bir etkisi yoktur. Bu sınıfın kullanıcısı başka bir nesneyi yerleştirebilir, ancak bu temeldeki koleksiyonu değiştirmez.