Passando argumentos para C # genérico new () do tipo de modelo

Estou tentando criar um novo objeto do tipo T através de seu construtor ao adicionar à lista.

Estou recebendo um erro de compilação: A mensagem de erro é:

'T': não é possível fornecer argumentos ao criar uma instância de uma variável

Mas minhas classes têm um argumento construtor! Como posso fazer isso funcionar?

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

Para criar uma instância de um tipo genérico em uma função, você deve restringi-la com o sinalizador "novo".

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

No entanto, isso só funcionará quando você desejar chamar o construtor que não possui parâmetros. Não é o caso aqui. Em vez disso, você precisará fornecer outro parâmetro que permita a criação de objeto com base em parâmetros. O mais fácil é uma função.

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

Você pode então chamar assim

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

no .Net 3.5 e depois que você pudesse usar a classe ativator:

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

Como ninguém se preocupou em postar a resposta 'Reflexão' (que eu pessoalmente acho que é a melhor resposta), aqui vai:

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

Editar: esta resposta foi descontinuada devido ao Activator.CreateInstance do .NET 3.5, no entanto, ainda é útil em versões mais antigas do .NET.

Inicializador de objeto

Se o seu construtor com o parâmetro não estiver fazendo nada além de definir uma propriedade, você pode fazer isso no C # 3 ou melhor usando um inicializador de objeto em vez de chamar um construtor (o que é impossível, como já foi mencionado):

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

Usando isso, você sempre pode colocar qualquer lógica de construtor no construtor padrão (vazio) também.

Activator.CreateInstance ()

Como alternativa, você pode chamar Activator.CreateInstance () assim:

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

Observe que Activator.CreateInstance pode ter alguma sobrecarga de desempenho que você pode evitar se a velocidade de execução for uma prioridade e outra opção puder ser mantida por você.

Pergunta muito antiga, mas nova resposta ;-)

A versão ExpressionTree : (acho que a solução mais rápida e mais limpa)

Como Welly Tambunan disse, "também podemos usar a árvore de expressão para construir o objeto"

Isso irá gerar um 'construtor' (função) para o tipo / parâmetros fornecidos. Ele retorna um delegado e aceita os tipos de parâmetro como uma matriz de objetos.

Aqui está:

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

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

Uso:

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

Outro exemplo: passando os tipos como uma matriz

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 of Expression

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

Isso é equivalente ao código que é gerado:

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

Pequena desvantagem

Todos os parâmetros de tipos de valor são colocados em caixa quando são passados ​​como uma matriz de objetos.

Teste de desempenho simples:

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

Resultados:

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

Usar Expressionsé +/- 8 vezes mais rápido que Invocar ConstructorInfoe +/- 20 vezes mais rápido que usar oActivator

Isso não vai funcionar na sua situação. Você só pode especificar a restrição de que ele tenha um construtor vazio:

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

O que você pode fazer é usar a injeção de propriedade, definindo esta interface:

public interface ITakesAListItem
{
   ListItem Item { set; }
}

Então você pode alterar seu método para ser o seguinte:

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

A outra alternativa é o Funcmétodo descrito por JaredPar.

Você precisa adicionar onde T: new () para informar ao compilador que T é garantido para fornecer um construtor padrão.

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

Se você deseja simplesmente inicializar um campo ou propriedade membro com o parâmetro construtor, em C #> = 3, você pode fazer isso muito mais facilmente:

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

É a mesma coisa que Garry Shutler disse, mas eu gostaria de colocar uma nota adicional.

É claro que você pode usar um truque de propriedade para fazer mais coisas do que apenas definir um valor de campo. Uma propriedade "set ()" pode acionar qualquer processamento necessário para configurar seus campos relacionados e qualquer outra necessidade do próprio objeto, incluindo uma verificação para verificar se uma inicialização completa deve ocorrer antes do objeto ser usado, simulando uma construção completa ( sim, é uma solução feia, mas supera a nova limitação de M $ ().

Não posso ter certeza se é um buraco planejado ou um efeito colateral acidental, mas funciona.

É muito engraçado como as pessoas com esclerose múltipla adicionam novos recursos ao idioma e parecem não fazer uma análise completa dos efeitos colaterais. A coisa toda genérica é uma boa evidência disso ...

Descobri que estava recebendo um erro "não é possível fornecer argumentos ao criar uma instância do tipo parâmetro T", então eu precisava fazer isso:

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

Se você tiver acesso à classe que usará, poderá usar esta abordagem que eu usei.

Crie uma interface que tenha um criador alternativo:

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

Faça suas aulas com um criador vazio e implemente este método:

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

Agora use seus métodos genéricos:

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

Se você não tiver acesso, agrupe a classe de destino:

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

Isso é meio bobo, e quando digo meio bobo, posso significar revoltante, mas supondo que você possa fornecer seu tipo parametrizado com um construtor vazio, então:

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

Permite efetivamente construir um objeto a partir de um tipo parametrizado com um argumento. Neste caso, estou assumindo que o construtor que eu quero tem um único argumento do tipo object. Criamos uma instância fictícia de T usando o construtor vazio de restrição permitido e depois usamos a reflexão para obter um de seus outros construtores.

Às vezes, uso uma abordagem semelhante às respostas usando injeção de propriedade, mas mantém o código mais limpo. Em vez de ter uma classe / interface base com um conjunto de propriedades, ele contém apenas um método (virtual) Initialize () - que atua como um "construtor pobre". Em seguida, você pode permitir que cada classe lide com sua própria inicialização, como faria um construtor, o que também adiciona uma maneira conveniente de lidar com cadeias de herança.

Se muitas vezes me encontro em situações em que quero que cada classe na cadeia inicialize suas propriedades exclusivas e chame o método Initialize () dos pais, que por sua vez inicializa as propriedades exclusivas dos pais e assim por diante. Isso é especialmente útil quando se tem classes diferentes, mas com uma hierarquia semelhante, por exemplo, objetos de negócios que são mapeados para / de DTO: s.

Exemplo que usa um dicionário comum para inicialização:

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

Se tudo o que você precisa é de conversão de ListItem para seu tipo T, você pode implementar essa conversão na classe T como operador de conversão.

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

Eu acredito que você precisa restringir T com uma instrução where para permitir apenas objetos com um novo construtor.

Agora, ele aceita qualquer coisa, incluindo objetos sem ele.