Comment utiliser Expression pour créer un type anonyme?

Question

En C# 3.0, vous pouvez utiliser l'expression pour créer une classe avec la syntaxe suivante:

var exp = Expression.New(typeof(MyClass)); 
var lambda = LambdaExpression.Lambda(exp); 
object myObj = lambda.Compile().DynamicInvoke(); 

Mais comment utilisez-vous Expression pour créer une classe anonyme?

//anonymousType = typeof(new{ Name="abc", Num=123}); 
Type anonymousType = Expression.NewAnonymousType??? <--How to do ? 
var exp = Expression.New(anonymousType); 
var lambda = LambdaExpression.Lambda(exp); 
object myObj = lambda.Compile().DynamicInvoke(); 

Answer 1

Vous êtes proche, mais vous devez savoir que les types anonymes ne sont pas des constructeurs par défaut. Les impressions de code suivant: { Name = def, Num = 456 }

Type anonType = new { Name = "abc", Num = 123 }.GetType(); 
var exp = Expression.New(
      anonType.GetConstructor(new[] { typeof(string), typeof(int) }), 
      Expression.Constant("def"), 
      Expression.Constant(456)); 
var lambda = LambdaExpression.Lambda(exp); 
object myObj = lambda.Compile().DynamicInvoke(); 
Console.WriteLine(myObj); 

Si vous ne disposez pas de créer de nombreux cas de ce type, Activator.CreateInstance fera tout aussi bien (il est pour beaucoup plus rapide pour quelques cas, mais plus lent). Ce code imprime { Name = ghi, Num = 789 }:

Type anonType = new { Name = "abc", Num = 123 }.GetType(); 
object myObj = Activator.CreateInstance(anonType, "ghi", 789); 
Console.WriteLine(myObj); 

Answer 2

Comme un type anonyme ne dispose pas d'un défaut constructeur vide, vous ne pouvez pas utiliser la surcharge Expression.New(Type) ... vous devez fournir les ConstructorInfo et les paramètres à la méthode Expression.New. Pour ce faire, vous devez être en mesure d'obtenir le type ... donc vous devez créer une instance "stub" du type anonyme, et l'utiliser pour obtenir le Type, et le ConstructorInfo, puis passer les paramètres à la Expression.New méthode.

Comme ceci:

var exp = Expression.New(new { Name = "", Num = 0 }.GetType().GetConstructors()[0], 
         Expression.Constant("abc", typeof(string)), 
         Expression.Constant(123, typeof(int))); 
var lambda = LambdaExpression.Lambda(exp); 
object myObj = lambda.Compile().DynamicInvoke(); 

Answer 3

Vous pouvez éviter d'utiliser DynamicInvoke qui est douloureusement lent. Vous pouvez utiliser l'inférence de type en C# pour obtenir une instanciation générique de votre type anonyme. Quelque chose comme:

public static Func<object[], T> AnonymousInstantiator<T>(T example) 
{ 
    var ctor = typeof(T).GetConstructors().First(); 
    var paramExpr = Expression.Parameter(typeof(object[])); 
    return Expression.Lambda<Func<object[], T>> 
    (
     Expression.New 
     (
      ctor, 
      ctor.GetParameters().Select 
      (
       (x, i) => Expression.Convert 
       (
        Expression.ArrayIndex(paramExpr, Expression.Constant(i)), 
        x.ParameterType 
       ) 
      ) 
     ), paramExpr).Compile(); 
} 

Maintenant, vous pouvez appeler,

var instantiator = AnonymousInstantiator(new { Name = default(string), Num = default(int) }); 

var a1 = instantiator(new object[] { "abc", 123 }); // strongly typed 
var a2 = instantiator(new object[] { "xyz", 789 }); // strongly typed 
// etc. 

Vous pouvez utiliser la méthode AnonymousInstantiator pour générer des fonctions pour instancier tout type anonyme avec un certain nombre de propriétés, juste que vous devez passer un approprié exemple en premier. Les paramètres d'entrée doivent être transmis en tant que tableau d'objets. Si vous vous inquiétez des performances de boxe, alors vous devez écrire un instantiateur personnalisé qui accepte seulement string et int comme paramètres d'entrée, mais l'utilisation d'un tel instanciant sera un peu plus limitée.