Discussion :

[adrienfehr]

Bonjour,

Je cherche à coder une fonction générique.
La classe générique ici T est de type EntityClass.
EntityClass a uniquement un constructeur qui prend un paramètre : EntityClass(DataRow monParamètre)

Mon problème c'est que je n'arrive pas à écrire ma fonction générique . Comment faire dire au compilateur que le constructeur du générique T prend un paramètre ?

Ce code ne passe pas (partie en rouge pose problème):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
private List<T> GetListOfEntities<T>(string sSql, string sTableName) where T : EntityClass, new()
{
      ...
      T maVariable=new T(monParamètre);
      ...
}

J'ai trouvé un workaround mais pas très joli (consiste à ajouter une méthode setParameter, le code compile alors):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
private List<T> GetListOfEntities<T>(string sSql, string sTableName) where T : EntityClass, new()
{
      ...
      T maVariable=new T();
      maVariable.setParameter(monParamètre)
      ...
}

[Bluedeep]

Bonjour

Pour appeler un constructeur avec paramètre, il y a toujours la solution de passer par Activator.CreateInstance. (mais c'est moins performant car utilisant la Reflection).

Mais il faut dans ce cas virer la clause new() dans la contrainte de généricité car elle implique l'existence d'un constructeur SANS paramètres (sinon, la déclaration de la classe générique ne sera pas acceptée à la compil).

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
	class MyTest
	{
		private int _x;
		public MyTest(int x)
		{
			_x = x;
		}
	}
 
	class TestGen<T> where T : MyTest
	{
		T _myInstance;
		public TestGen()
		{
			_myInstance = (T)Activator.CreateInstance(typeof(T), 1);
		}
	}

Effectivement, c'est un peu casse-pied de ne pas pouvoir exprimer la contrainte new() avec des paramètres.

[tomlev]

En effet il n'est malheureusement pas possible de spécifier les paramètres du constructeur dans la contrainte... et la principale alternative, Activator.CreateInstance, est très lente (plus lente que de chercher le constructeur par réflexion et de l'invoquer, car la classe Activator gère aussi pleins d'autres choses, genre remoting, interop COM, etc).

Une solution peut être de générer dynamiquement une méthode qui crée l'objet, de la mettre en cache, et de la réutiliser à chaque fois pour gagner du temps. Petit exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
using System.Linq.Expressions;
...
 
 
T CreateInstance<T>(string param)
{
    return ConstructorCache<T, string>.Create(param);
}
 
private static class ConstructorCache<T, TParam>
{
    public static readonly Func<TParam, T> Create = CreateFactory();
 
    private static Func<TParam, T> CreateFactory()
    {
        Debug.Print("Type: {0}", typeof(T).FullName);
        Debug.Print("Parameter: {0}", typeof(TParam).FullName);
 
        var ctor = typeof(T).GetConstructor(new[] { typeof(TParam) });
        if (ctor == null)
            throw new InvalidOperationException(string.Format("Type '{0}' doesn't have a constructor with a parameter of type '{1}'", typeof(T).FullName, typeof(TParam).FullName));
 
        var prm = Expression.Parameter(typeof(TParam));
        var newExpr = Expression.New(ctor, prm);
        var lambda = Expression.Lambda<Func<TParam, T>>(newExpr, prm);
        return lambda.Compile();
    }   
}

La trace de debug sert juste à prouver que la génération de la méthode n'est faite qu'une seule fois (pour un couple T/TParam donné), quel que soit le nombre d'appels à CreateInstance

J'ai utilisé les expressions Linq, mais si tu as pas peur de mettre les mains dans le cambouis (ou que tu utilises une version de .NET antérieure à 3.5), tu peux aussi le faire directement en IL avec Reflection.Emit et DynamicMethod...

[Bluedeep]

Joli

J'aurais plutôt utilisé l'Emit (pour avoir choisi cette solution dans un cas similaire, mais en 2.0) mais je ne suis pas sur que cela soit beaucoup plus performant (en tous cas, ce l'était notablement vs la Reflection, mais je ne suis pas sur que cela l'est plus que ta solution).

[tomlev]

J'aurais plutôt utilisé l'Emit (pour avoir choisi cette solution dans un cas similaire, mais en 2.0) mais je ne suis pas sur que cela soit beaucoup plus performant

Avec Linq, c'est sans doute un peu plus long pour compiler la méthode, mais ça reste très raisonnable, surtout si ce n'est fait qu'une fois. Une fois que c'est compilé, a priori il n'y a pas de différence . Et puis c'est surtout plus facile avec Linq, enfin je trouve...

Je vais essayer de faire un petit benchmark pour comparer d'ailleurs...

[tomlev]

Je vais essayer de faire un petit benchmark pour comparer d'ailleurs...

Bon bah c'est à peu près comme j'avais dit : la génération de la méthode avec Emit est un peu plus rapide qu'avec Linq (de 10% environ), et pour l'exécution c'est pareil

Method generation - Linq (10000 iterations)
Elapsed: 00:00:05.1955450
Average: 00:00:00.0005195

Method generation - Emit (10000 iterations)
Elapsed: 00:00:04.5354479
Average: 00:00:00.0004535

Method execution - Linq (10000000 iterations)
Elapsed: 00:00:00.4527235
Average: 00:00:00

Method execution - Emit (10000000 iterations)
Elapsed: 00:00:00.4902423
Average: 00:00:00

(les temps d'exécution varie un peu d'un run à l'autre, parfois c'est la méthode générée par Emit est plus rapide, et parfois c'est celle avec Linq... donc en gros c'est kif kif)

A titre indicatif, le code de la méthode CreateFactory en utilisant Emit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using System.Reflection;
using System.Reflection.Emit;
...
 
    private static Func<TParam, T> CreateFactoryEmit()
    {
        Debug.Print("Type: {0}", typeof(T).FullName);
        Debug.Print("Parameter: {0}", typeof(TParam).FullName);
 
        var ctor = typeof(T).GetConstructor(new[] { typeof(TParam) });
        if (ctor == null)
            throw new InvalidOperationException(string.Format("Type '{0}' doesn't have a constructor with a parameter of type '{1}'", typeof(T).FullName, typeof(TParam).FullName));
 
        var dm = new DynamicMethod(
            "Create" + typeof(T).Name,
            typeof(T),
            new[] { typeof(TParam) },
            true);
        var il = dm.GetILGenerator();
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Newobj, ctor);
        il.Emit(OpCodes.Ret);
 
        return (Func<TParam, T>)dm.CreateDelegate(typeof(Func<TParam, T>));
    }

[adrienfehr]

Merci !