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

Podczas dodawania do listy próbuję utworzyć nowy obiekt typu T za pomocą jego konstruktora.

Otrzymuję błąd kompilacji: Komunikat o błędzie to:

„T”: nie można podać argumentów podczas tworzenia instancji zmiennej

Ale moje klasy mają argument konstruktorski! Jak mogę to zrobić?

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

Aby utworzyć instancję typu ogólnego w funkcji, musisz ograniczyć ją flagą „new”.

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

Działa to jednak tylko wtedy, gdy chcesz wywołać konstruktor, który nie ma parametrów. Nie w tym przypadku. Zamiast tego musisz podać inny parametr, który pozwala na tworzenie obiektu na podstawie parametrów. Najłatwiejsza jest funkcja.

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

Możesz to tak nazwać

GetAllItems<Foo>(..., l => new Foo(l));

w .Net 3.5 i po tym, jak można użyć klasy aktywatora:

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

Ponieważ nikt nie zadał sobie trudu opublikowania odpowiedzi „Refleksja” (którą osobiście uważam za najlepszą odpowiedź), oto:

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

Edycja: Ta odpowiedź jest nieaktualna z powodu Activator.CreateInstance .NET 3.5, jednak nadal jest przydatna w starszych wersjach .NET.

Inicjator obiektu

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 inicjatora obiektu zamiast wywoływać konstruktor (co jest niemożliwe, jak 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
   } 
   ...
}

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

Activator.CreateInstance ()

Alternatywnie możesz wywołać Activator.CreateInstance () w następujący sposób:

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

Należy pamiętać, że Activator.CreateInstance może mieć pewne narzuty wydajności , których można uniknąć, jeśli szybkość wykonywania jest najwyższym priorytetem, a inna opcja jest możliwa do utrzymania.

Bardzo stare pytanie, ale nowa odpowiedź ;-)

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

Jak powiedział Welly Tambunan , „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.

Oto on:

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

Stosowanie:

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

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

Kolejny przykład: przekazywanie typów jako tablic

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

Debuguj widok wyrażenia

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

Jest to równoważne z generowanym kodem:

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

Mały minus

Wszystkie parametry typów wartości są umieszczane w ramkach, 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żywanie Expressionsjest +/- 8 razy szybsze niż Wywołanie ConstructorInfoi +/- 20 razy szybsze niż używanieActivator

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

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

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

public interface ITakesAListItem
{
   ListItem Item { set; }
}

Następnie możesz zmienić swoją metodę na:

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 Funcmetoda opisana przez JaredPar.

Musisz dodać gdzie T: new (), aby poinformować kompilator, że T zapewnia domyślny konstruktor.

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

Jeśli chcesz po prostu zainicjować pole członka lub właściwość za pomocą parametru konstruktora, w C #> = 3 możesz to zrobić bardzo łatwo:

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

To samo powiedział Garry Shutler, ale chciałbym dodać dodatkową notatkę.

Oczywiście możesz użyć sztuczki właściwości, aby zrobić więcej rzeczy niż tylko ustawienie wartości pola. Właściwość „set ()” może wyzwalać dowolne przetwarzanie potrzebne do ustawienia powiązanych pól i wszelkie inne potrzeby samego obiektu, w tym sprawdzenie, czy pełna inicjalizacja ma nastąpić przed użyciem obiektu, symulując pełną konstrukcję ( tak, jest to brzydkie obejście, ale pokonuje nowe () ograniczenie M $).

Nie mogę się upewnić, czy jest to planowana dziura, czy przypadkowy efekt uboczny, ale działa.

To bardzo zabawne, jak stwardnienie rozsiane dodaje nowe funkcje do języka i wydaje się, że nie wykonuje pełnej analizy skutków ubocznych. Cała ogólna rzecz jest dobrym dowodem na to ...

Stwierdziłem, że pojawia się błąd „nie można podać argumentów podczas tworzenia wystąpienia 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 będziesz korzystać, możesz skorzystać z tego podejścia, którego użyłem.

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

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

Twórz zajęcia z pustym twórcą 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żyj ogólnych metod:

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

Jest to trochę paskudne, a kiedy mówię trochę paskudne, mam na myśli zbuntowane, ale zakładając, że możesz dostarczyć sparametryzowany typ pustemu konstruktorowi:

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

Skutecznie pozwoli ci zbudować obiekt ze sparametryzowanego typu z argumentem. W tym przypadku zakładam, że konstruktor, którego chcę, ma jeden argument typu object. Tworzymy atrapę instancji T, używając dozwolonego pustego konstruktora, a następnie używamy odbicia, aby uzyskać jeden z jej innych konstruktorów.

Czasami używam podejścia, które przypomina odpowiedzi przy użyciu wstrzykiwania właściwości, ale utrzymuje czystość kodu. Zamiast mieć klasę bazową / interfejs z zestawem właściwości, zawiera on tylko (wirtualną) metodę Initialize () - która działa jak „konstruktor biedaka”. Następnie możesz pozwolić każdej klasie zająć się własną inicjalizacją, tak jak zrobiłby to konstruktor, co dodaje także 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 zainicjowała swoje unikalne właściwości, a następnie wywołała metodę nadrzędną Initialize () - metodę, która z kolei inicjuje unikalne właściwości rodzica i tak dalej. Jest to szczególnie przydatne w przypadku różnych klas, ale o podobnej hierarchii, na przykład obiektów biznesowych odwzorowanych na / 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;
    }
}

Jeśli wszystko, czego potrzebujesz, to konwersja z ListItem na typ T, możesz zaimplementować tę konwersję w klasie T jako operator konwersji.

public class T
{
    public static implicit operator T(ListItem listItem) => /* ... */;
}

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

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

Teraz akceptuje wszystko, w tym przedmioty bez niego.