Passer des arguments à C # générique new () de type modèle

J'essaie de créer un nouvel objet de type T via son constructeur lors de l'ajout à la liste.

Je reçois une erreur de compilation: Le message d'erreur est:

'T': ne peut pas fournir d'arguments lors de la création d'une instance d'une variable

Mais mes classes ont un argument constructeur! Comment puis-je faire fonctionner cela?

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

Afin de créer une instance d'un type générique dans une fonction, vous devez la contraindre avec le "nouveau" indicateur.

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

Cependant, cela ne fonctionnera que si vous souhaitez appeler le constructeur qui n'a pas de paramètres. Pas le cas ici. Au lieu de cela, vous devrez fournir un autre paramètre qui permet la création d'objet basé sur des paramètres. Le plus simple est une fonction.

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

Vous pouvez alors l'appeler ainsi

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

dans .Net 3.5 et après, vous pouvez utiliser la classe d'activateur:

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

Étant donné que personne n'a pris la peine de publier la réponse «Réflexion» (que je pense personnellement être la meilleure réponse), voici:

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

Modifier: cette réponse est obsolète en raison de Activator.CreateInstance de .NET 3.5, mais elle est toujours utile dans les anciennes versions de .NET.

Initialiseur d'objet

Si votre constructeur avec le paramètre ne fait rien d'autre que de définir une propriété, vous pouvez le faire en C # 3 ou mieux en utilisant un initialiseur d'objet plutôt qu'en appelant un constructeur (ce qui est impossible, comme cela a été mentionné):

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

En utilisant cela, vous pouvez également toujours placer n'importe quelle logique de constructeur dans le constructeur par défaut (vide).

Activator.CreateInstance ()

Alternativement, vous pouvez appeler Activator.CreateInstance () comme ceci:

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

Notez qu'Activator.CreateInstance peut avoir une surcharge de performances que vous voudrez peut-être éviter si la vitesse d'exécution est une priorité absolue et qu'une autre option peut être maintenue.

Très vieille question, mais nouvelle réponse ;-)

La version ExpressionTree : (je pense que la solution la plus rapide et la plus propre)

Comme l'a dit Welly Tambunan , "nous pourrions également utiliser l'arbre d'expression pour construire l'objet"

Cela générera un «constructeur» (fonction) pour le type / les paramètres donnés. Il renvoie un délégué et accepte les types de paramètres comme un tableau d'objets.

C'est ici:

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

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

Usage:

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

Un autre exemple: passer les types sous forme de tableau

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

C'est équivalent au code qui est généré:

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

Petit inconvénient

Tous les paramètres des types de valeurs sont encadrés lorsqu'ils sont transmis comme un tableau d'objets.

Test de performance simple:

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

Résultats:

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

L'utilisation Expressionsest +/- 8 fois plus rapide que l'invocation de ConstructorInfoet +/- 20 fois plus rapide que l'utilisation de laActivator

Cela ne fonctionnera pas dans votre situation. Vous ne pouvez spécifier que la contrainte qu'il a un constructeur vide:

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

Ce que vous pourriez faire, c'est utiliser l'injection de propriétés en définissant cette interface:

public interface ITakesAListItem
{
   ListItem Item { set; }
}

Ensuite, vous pouvez modifier votre méthode comme suit:

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

L'autre alternative est la Funcméthode décrite par JaredPar.

Vous devez ajouter où T: new () pour que le compilateur sache que T est garanti pour fournir un constructeur par défaut.

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

Si vous souhaitez simplement initialiser un champ membre ou une propriété avec le paramètre constructeur, en C #> = 3, vous pouvez le faire très facilement:

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

C'est la même chose que Garry Shutler a dit, mais j'aimerais ajouter une note supplémentaire.

Bien sûr, vous pouvez utiliser une astuce de propriété pour faire plus de choses que simplement définir une valeur de champ. Une propriété "set ()" peut déclencher tout traitement nécessaire pour configurer ses champs associés et tout autre besoin pour l'objet lui-même, y compris une vérification pour voir si une initialisation complète doit avoir lieu avant que l'objet ne soit utilisé, simulant une construction complète ( oui, c'est une solution de contournement laide, mais elle surmonte la nouvelle limitation de M $).

Je ne peux pas être sûr s'il s'agit d'un trou planifié ou d'un effet secondaire accidentel, mais cela fonctionne.

C'est très drôle de voir comment les personnes atteintes de SEP ajoutent de nouvelles fonctionnalités au langage et ne semblent pas faire une analyse complète des effets secondaires. La chose générique entière en est une bonne preuve ...

J'ai trouvé que j'obtenais une erreur «ne peut pas fournir d'arguments lors de la création d'une instance de type paramètre T», j'ai donc dû faire ceci:

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

Si vous avez accès à la classe que vous allez utiliser, vous pouvez utiliser cette approche que j'ai utilisée.

Créez une interface qui a un créateur alternatif:

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

Créez vos classes avec un créateur vide et implémentez cette méthode:

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

Utilisez maintenant vos méthodes génériques:

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

Si vous n'y avez pas accès, encapsulez la classe cible:

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

C'est un peu mucky, et quand je dis un peu mucky, je peux vouloir dire révoltant, mais en supposant que vous pouvez fournir votre type paramétré avec un constructeur vide, alors:

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

Vous permettra effectivement de construire un objet à partir d'un type paramétré avec un argument. Dans ce cas, je suppose que le constructeur que je veux a un seul argument de type object. Nous créons une instance fictive de T en utilisant le constructeur vide de contrainte autorisée, puis utilisons la réflexion pour obtenir l'un de ses autres constructeurs.

J'utilise parfois une approche qui ressemble aux réponses en utilisant l'injection de propriété, mais garde le code plus propre. Au lieu d'avoir une classe / interface de base avec un ensemble de propriétés, elle ne contient qu'une méthode (virtuelle) Initialize () - qui agit comme un "constructeur du pauvre". Ensuite, vous pouvez laisser chaque classe gérer sa propre initialisation comme le ferait un constructeur, ce qui ajoute également un moyen pratique de gérer les chaînes d'héritage.

Si je me retrouve souvent dans des situations où je veux que chaque classe de la chaîne initialise ses propriétés uniques, puis appelle la méthode Initialize () de son parent, qui à son tour initialise les propriétés uniques du parent, etc. Cela est particulièrement utile lorsque vous avez différentes classes, mais avec une hiérarchie similaire, par exemple des objets métier qui sont mappés vers / depuis DTO: s.

Exemple qui utilise un dictionnaire commun pour l'initialisation:

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

Si tout ce dont vous avez besoin est une conversion de ListItem vers votre type T, vous pouvez implémenter cette conversion dans la classe T comme opérateur de conversion.

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

Je crois que vous devez contraindre T avec une instruction where pour autoriser uniquement les objets avec un nouveau constructeur.

Maintenant, il accepte tout, y compris les objets sans lui.