¿Cómo puedo crear una propiedad multi-propiedad dinámica en un IEnumerable <T> en tiempo de ejecución?

Question

Ayer pregunté very similar question, pero no fue hasta hoy que me di cuenta de que la respuesta que acepté no resuelve todos mis problemas. Tengo el siguiente código:

public Expression<Func<TItem, object>> SelectExpression<TItem>(string fieldName) 
{ 
    var param = Expression.Parameter(typeof(TItem), "item"); 
    var field = Expression.Property(param, fieldName); 
    return Expression.Lambda<Func<TItem, object>>(field, 
     new ParameterExpression[] { param }); 
} 

que se utiliza de la siguiente manera:

string primaryKey = _map.GetPrimaryKeys(typeof(TOriginator)).Single(); 
var primaryKeyExpression = SelectExpression<TOriginator>(primaryKey); 
var primaryKeyResults = query.Select(primaryKeyExpression).ToList(); 

Esto me permite sacar las claves principales de una IQueryable<TUnknown>. El problema es que este código solo funciona con una sola clave principal y necesito agregar soporte para múltiples PK.

Entonces, ¿hay alguna manera de adaptar el método SelectExpression anterior para tomar un IEnumerable<string> (que es mi lista de nombres de propiedades de claves principales) y hacer que el método devuelva una expresión que seleccione esas claves?

I.e. Teniendo en cuenta lo siguiente:

var knownRuntimePrimaryKeys = new string[] { "CustomerId", "OrderId" }` 

Mi Selecto tiene que hacer lo siguiente (en tiempo de ejecución):

var primaryKeys = query.Select(x=> new { x.CustomerId, x.OrderId }); 

Answer 1

usted podría utilizar Tuple<> porque los tipos anónimos deben ser conocidas en tiempo de compilación:

public Expression<Func<TItem, object>> SelectExpression<TItem>(params string[] fieldNames) 
{ 
    var param = Expression.Parameter(typeof(TItem), "item"); 
    var fields = fieldNames.Select(x => Expression.Property(param, x)).ToArray(); 
    var types = fields.Select(x => x.Type).ToArray(); 
    var type = Type.GetType("System.Tuple`" + fields.Count() + ", mscorlib", true); 
    var tuple = type.MakeGenericType(types); 
    var ctor = tuple.GetConstructor(types); 
    return Expression.Lambda<Func<TItem, object>>(
     Expression.New(ctor, fields), 
     param 
    ); 
} 

y luego:

var primaryKeyExpression = SelectExpression<TOriginator>("CustomerId", "OrderId"); 

generará la siguiente expresión:

item => new Tuple<string, string>(item.CustomerId, item.OrderId) 

Answer 2

Como alguien ya se ha señalado, se está intentando conseguir esencialmente un tipo anónimo construido en tiempo de ejecución, que no se va a trabajar.

¿Hay alguna alternativa al uso de un tipo anónimo y aún así lograr lo que necesito?

Esto realmente depende de lo que usted diga. Las respuestas obvias son usar construcciones en tiempo de ejecución, como un diccionario, una tupla, etc. Pero es probable que usted sea totalmente consciente de esto, así que supongo que quiere un resultado en tiempo de compilación con nombres de campos reales, para que cualquier mal uso de primaryKeys queda atrapado durante la compilación.

Si es así, me temo que su única opción es generar el código relevante antes de la compilación. Esto no es tan malo como podría parecer, pero no es completamente transparente: cuando cambia el esquema, tiene que volver a ejecutar la generación de código de alguna manera.

En nuestra empresa hemos hecho exactamente eso, inspirándonos en SubSonic pero descubriendo que SubSonic en sí mismo no era lo que queríamos. Funcionó bastante bien en mi opinión.

Answer 3

No hay una manera fácil de hacer exactamente lo que quiere, porque requeriría crear dinámicamente un nuevo tipo (el compilador crea los tipos anónimos cuando se conocen estáticamente). Si bien es ciertamente factible, probablemente no sea la opción más fácil ...

Puede lograr un resultado similar usando tuples:

public Expression<Func<TItem, object>> SelectExpression<TItem>(string[] propertyNames) 
{ 
    var properties = propertyNames.Select(name => typeof(TItem).GetProperty(name)).ToArray(); 
    var propertyTypes = properties.Select(p => p.PropertyType).ToArray(); 
    var tupleTypeDefinition = typeof(Tuple).Assembly.GetType("System.Tuple`" + properties.Length); 
    var tupleType = tupleTypeDefinition.MakeGenericType(propertyTypes); 
    var constructor = tupleType.GetConstructor(propertyTypes); 
    var param = Expression.Parameter(typeof(TItem), "item"); 
    var body = Expression.New(constructor, properties.Select(p => Expression.Property(param, p))); 
    var expr = Expression.Lambda<Func<TItem, object>>(body, param); 
    return expr; 
}