Przekazywanie argumentów do C# generic new () typu template

W. Net 3.5 i po użyciu klasy aktywatora:

(T)Activator.CreateInstance(typeof(T), args)

Ponieważ nikt nie zadał sobie trudu, aby umieścić odpowiedź "refleksji" (która osobiście uważam za najlepszą odpowiedź), oto idzie:

public static string GetAllItems<T>(...) where T : new()
{
   ...
   List<T> tabListItems = new List<T>();
   foreach (ListItem listItem in listCollection) 
   {
       Type classType = typeof(T);
       ConstructorInfo classConstructor = classType.GetConstructor(new Type[] { listItem.GetType() });
       T classInstance = (T)classConstructor.Invoke(new object[] { listItem });

       tabListItems.Add(classInstance);
   } 
   ...
}

Edit: ta odpowiedź jest przestarzała z powodu aktywatora. NET 3.5.CreateInstance, jednak nadal jest przydatny w starszych wersjach. NET.

Obiekt initializer

Jeśli twój konstruktor z parametrem nie robi nic poza ustawieniem właściwości, możesz to zrobić w C# 3 lub lepiej używając object initializer zamiast wywoływać konstruktor (co jest niemożliwe, jak już wspomniano):

public static string GetAllItems<T>(...) where T : new()
{
   ...
   List<T> tabListItems = new List<T>();
   foreach (ListItem listItem in listCollection) 
   {
       tabListItems.Add(new T() { YourPropertyName = listItem } ); // Now using object initializer
   } 
   ...
}

Używając tego, zawsze możesz umieścić dowolną logikę konstruktora w domyślnym (pustym) konstruktorze.

Aktywator.CreateInstance()

Alternatywnie, możesz zadzwonić Aktywator.CreateInstance () Jak Tak:

public static string GetAllItems<T>(...) where T : new()
{
   ...
   List<T> tabListItems = new List<T>();
   foreach (ListItem listItem in listCollection) 
   {
        object[] args = new object[] { listItem };
        tabListItems.Add((T)Activator.CreateInstance(typeof(T), args)); // Now using Activator.CreateInstance
   } 
   ...
}

Zwróć uwagę na aktywator.CreateInstance może mieć pewien poziom wydajności , którego możesz unikać, jeśli szybkość wykonania jest priorytetem, a inna opcja jest dostępna dla ciebie.

To nie zadziała w twojej sytuacji. Możesz tylko określić ograniczenie, że ma on pusty konstruktor:

public static string GetAllItems<T>(...) where T: new()

Możesz użyć właściwości injection definiując ten interfejs:

public interface ITakesAListItem
{
   ListItem Item { set; }
}

Wtedy możesz zmienić swoją metodę na taką:

public static string GetAllItems<T>(...) where T : ITakesAListItem, new()
{
   ...
   List<T> tabListItems = new List<T>();
   foreach (ListItem listItem in listCollection) 
   {
       tabListItems.Add(new T() { Item = listItem });
   } 
   ...
}

Inną alternatywą jest Metoda Func opisana przez JaredPar.

Bardzo stare pytanie, ale nowa odpowiedź; -)

Wersja ekspresyjna: (myślę, że najszybsze i najczystsze rozwiązanie)

Jak Welly Tambunan powiedział, "możemy również użyć drzewa wyrażeń do zbudowania obiektu"

Spowoduje to wygenerowanie 'konstruktora' (funkcji) dla podanego typu/parametrów. Zwraca delegata i akceptuje typy parametrów jako tablicę obiektów.

Here it jest:

// this delegate is just, so you don't have to pass an object array. _(params)_
public delegate object ConstructorDelegate(params object[] args);

public static ConstructorDelegate CreateConstructor(Type type, params Type[] parameters)
{
    // Get the constructor info for these parameters
    var constructorInfo = type.GetConstructor(parameters);

    // define a object[] parameter
    var paramExpr = Expression.Parameter(typeof(Object[]));

    // To feed the constructor with the right parameters, we need to generate an array 
    // of parameters that will be read from the initialize object array argument.
    var constructorParameters = parameters.Select((paramType, index) =>
        // convert the object[index] to the right constructor parameter type.
        Expression.Convert(
            // read a value from the object[index]
            Expression.ArrayAccess(
                paramExpr,
                Expression.Constant(index)),
            paramType)).ToArray();

    // just call the constructor.
    var body = Expression.New(constructorInfo, constructorParameters);

    var constructor = Expression.Lambda<ConstructorDelegate>(body, paramExpr);
    return constructor.Compile();
}

Przykład MyClass:

public class MyClass
{
    public int TestInt { get; private set; }
    public string TestString { get; private set; }

    public MyClass(int testInt, string testString)
    {
        TestInt = testInt;
        TestString = testString;
    }
}

Użycie:

// you should cache this 'constructor'
var myConstructor = CreateConstructor(typeof(MyClass), typeof(int), typeof(string));

// Call the `myConstructor` fucntion to create a new instance.
var myObject = myConstructor(10, "test message");

inny przykład: przekazywanie typów jako tablicy

var type = typeof(MyClass);
var args = new Type[] { typeof(int), typeof(string) };

// you should cache this 'constructor'
var myConstructor = CreateConstructor(type, args);

// Call the `myConstructor` fucntion to create a new instance.
var myObject = myConstructor(10, "test message");

DebugView wyrażenia

.Lambda #Lambda1<TestExpressionConstructor.MainWindow+ConstructorDelegate>(System.Object[] $var1) {
    .New TestExpressionConstructor.MainWindow+MyClass(
        (System.Int32)$var1[0],
        (System.String)$var1[1])
}

Jest to odpowiednik wygenerowanego kodu:

public object myConstructor(object[] var1)
{
    return new MyClass(
        (System.Int32)var1[0],
        (System.String)var1[1]);
}

Mały minus

Wszystkie parametry valuetypes są pudełkowe, gdy są przekazywane jak tablica obiektów.

Prosty test wydajności:

private void TestActivator()
{
    Stopwatch sw = Stopwatch.StartNew();
    for (int i = 0; i < 1024 * 1024 * 10; i++)
    {
        var myObject = Activator.CreateInstance(typeof(MyClass), 10, "test message");
    }
    sw.Stop();
    Trace.WriteLine("Activator: " + sw.Elapsed);
}

private void TestReflection()
{
    var constructorInfo = typeof(MyClass).GetConstructor(new[] { typeof(int), typeof(string) });

    Stopwatch sw = Stopwatch.StartNew();
    for (int i = 0; i < 1024 * 1024 * 10; i++)
    {
        var myObject = constructorInfo.Invoke(new object[] { 10, "test message" });
    }

    sw.Stop();
    Trace.WriteLine("Reflection: " + sw.Elapsed);
}

private void TestExpression()
{
    var myConstructor = CreateConstructor(typeof(MyClass), typeof(int), typeof(string));

    Stopwatch sw = Stopwatch.StartNew();

    for (int i = 0; i < 1024 * 1024 * 10; i++)
    {
        var myObject = myConstructor(10, "test message");
    }

    sw.Stop();
    Trace.WriteLine("Expression: " + sw.Elapsed);
}

TestActivator();
TestReflection();
TestExpression();

Wyniki:

Activator: 00:00:13.8210732
Reflection: 00:00:05.2986945
Expression: 00:00:00.6681696

Użycie Expressions jest +/- 8 razy szybsze niż wywołanie ConstructorInfo i +/- 20 razy szybsze niż użycie Activator

Musisz dodać where t: new (), aby poinformować kompilator, że t ma gwarancję dostarczenia domyślnego konstruktora.

public static string GetAllItems<T>(...) where T: new()

Jeśli po prostu chcesz zainicjować pole lub właściwość z parametrem konstruktora, w C# >= 3 możesz to zrobić bardzo łatwiej:

public static string GetAllItems<T>(...) where T : InterfaceOrBaseClass, new() 
{ 
   ... 
   List<T> tabListItems = new List<T>(); 
   foreach (ListItem listItem in listCollection)  
   { 
       tabListItems.Add(new T{ BaseMemberItem = listItem }); // No error, BaseMemberItem owns to InterfaceOrBaseClass. 
   }  
   ... 
} 

Oczywiście można użyć sztuczki właściwości, aby zrobić więcej rzeczy niż tylko ustawienie wartości pola. Właściwość " set ()" może wywołać dowolne przetwarzanie potrzebne do skonfigurowania powiązanych z nią pól oraz wszelkie inne potrzeby samego obiektu, w tym sprawdzenie, czy pełny inicjalizacja ma nastąpić przed użyciem obiektu, symulując pełną kontrukcję (tak, jest to brzydkie obejście, ale pokonuje ograniczenie m$new ()).

To bardzo zabawne, jak M$ people dodaje nowe funkcje do języka i wydaje się, że nie robi pełnej analizy skutków ubocznych. Cała ogólna rzecz jest tego dobrym dowodem...

Zauważyłem, że otrzymuję błąd "nie mogę podać argumentów podczas tworzenia instancji parametru typu T", więc musiałem to zrobić:

var x = Activator.CreateInstance(typeof(T), args) as T;

Jeśli masz dostęp do klasy, z której zamierzasz korzystać, możesz użyć tego podejścia, którego użyłem.

Utwórz interfejs, który ma alternatywnego twórcę:

public interface ICreatable1Param
{
    void PopulateInstance(object Param);
}

Stwórz swoje klasy z pustym kreatorem i zaimplementuj tę metodę:

public class MyClass : ICreatable1Param
{
    public MyClass() { //do something or nothing }
    public void PopulateInstance (object Param)
    {
        //populate the class here
    }
}

Teraz używaj metod ogólnych:

public void MyMethod<T>(...) where T : ICreatable1Param, new()
{
    //do stuff
    T newT = new T();
    T.PopulateInstance(Param);
}

Jeśli nie masz dostępu, zawiń klasę docelową:

public class MyClass : ICreatable1Param
{
    public WrappedClass WrappedInstance {get; private set; }
    public MyClass() { //do something or nothing }
    public void PopulateInstance (object Param)
    {
        WrappedInstance = new WrappedClass(Param);
    }
}

Czasami używam podejścia, które przypomina odpowiedzi za pomocą property injection, ale zachowuje czystość kodu. Zamiast bazowej klasy / interfejsu z zestawem właściwości, zawiera ona tylko (wirtualną) metodę Initialize (), która działa jako "konstruktor biednego człowieka". Następnie możesz pozwolić każdej klasie obsługiwać własną inicjalizację, tak jak zrobiłby to konstruktor, który również dodaje wygodny sposób obsługi łańcuchów dziedziczenia.

Jeśli często znajduję się w sytuacjach, w których chcę, aby każda klasa w łańcuchu inicjalizuje swoje unikalne właściwości, a następnie wywołuje metodę initialize () - rodzica, która z kolei inicjalizuje unikalne właściwości rodzica i tak dalej. Jest to szczególnie przydatne, gdy mają różne klasy, ale z podobną hierarchią, na przykład obiekty biznesowe, które są mapowane do / Z DTO: s.

Przykład, który używa Wspólnego Słownika do inicjalizacji:

void Main()
{
    var values = new Dictionary<string, int> { { "BaseValue", 1 }, { "DerivedValue", 2 } };

    Console.WriteLine(CreateObject<Base>(values).ToString());

    Console.WriteLine(CreateObject<Derived>(values).ToString());
}

public T CreateObject<T>(IDictionary<string, int> values)
    where T : Base, new()
{
    var obj = new T();
    obj.Initialize(values);
    return obj;
}

public class Base
{
    public int BaseValue { get; set; }

    public virtual void Initialize(IDictionary<string, int> values)
    {
        BaseValue = values["BaseValue"];
    }

    public override string ToString()
    {
        return "BaseValue = " + BaseValue;
    }
}

public class Derived : Base
{
    public int DerivedValue { get; set; }

    public override void Initialize(IDictionary<string, int> values)
    {
        base.Initialize(values);
        DerivedValue = values["DerivedValue"];
    }

    public override string ToString()
    {       
        return base.ToString() + ", DerivedValue = " + DerivedValue;
    }
}

To jest trochę brudne, a kiedy mówię trochę brudne, mogę mieć na myśli odrażające, ale przypuśćmy, że możesz podać swój parametryzowany Typ pustym konstruktorem, to:

public static T GetTInstance<T>() where T: new()
{
    var constructorTypeSignature = new Type[] {typeof (object)};
    var constructorParameters = new object[] {"Create a T"};
    return (T) new T().GetType().GetConstructor(constructorTypeSignature).Invoke(constructorParameters);
}

Pozwoli skutecznie skonstruować obiekt z parametryzowanego typu z argumentem. W tym przypadku zakładam, że konstruktor, którego chcę, ma pojedynczy argument typu object. Tworzymy dummy instancję T używając constraint permitted empty constructor, a następnie używamy reflection, aby uzyskać jedną z jej innych konstruktorów.

Uważam, że musisz ograniczyć t za pomocą instrukcji where, aby zezwalać tylko na obiekty z nowym konstruktorem.

W tej chwili akceptuje wszystko, w tym obiekty bez niego.