Come posso creare una proprietà multi-selezione dinamica su un oggetto IEnumerable <T> in fase di runtime?

Question

Ho chiesto un very similar question ieri, ma non è stato fino a oggi ho capito che la risposta che ho accettato non risolve tutti i miei problemi. Ho il seguente codice:

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

che viene utilizzato come segue:

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

Questo mi permette di tirare fuori le chiavi primarie da un IQueryable<TUnknown>. Il problema è che questo codice funziona solo con una singola chiave primaria e ho bisogno di aggiungere il supporto per più PK.

Quindi, c'è un modo per adattare il metodo SelectExpression in precedenza per prendere un IEnumerable<string> (che è il mio elenco di nomi di proprietà di chiave primaria) e il metodo restituire un'espressione che seleziona quelle chiavi?

I.e. Dato il seguente:

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

mio Select ha bisogno di fare quanto segue (in fase di esecuzione):

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

Answer 1

si potrebbe usare Tuple<> perché i tipi anonimi devono essere noti al momento della compilazione:

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

e quindi:

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

genererà la seguente espressione:

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

Answer 2

Come qualcuno ha già fatto notare, si sono essenzialmente cercando di ottenere un tipo anonimo costruito a runtime, che non sta andando a lavorare.

Esiste un'alternativa all'utilizzo di un tipo Anonimo e ottenere comunque ciò che richiedo?

Questo dipende molto da cosa intendi. Le risposte ovvie sono usare costrutti di runtime, come un dizionario, una tupla, ecc. Ma probabilmente ne sei pienamente consapevole, quindi presumo che tu voglia un risultato tipizzato in fase di compilazione con nomi di campi reali, così che qualsiasi l'errato utilizzo di primaryKeys viene rilevato durante la compilazione.

Se è così, allora temo che la tua unica opzione sia generare il codice rilevante prima della compilazione. Non è così male come potrebbe sembrare, ma non è completamente trasparente: quando si modifica lo schema, è necessario rieseguire la generazione del codice in qualche modo.

Nella nostra azienda abbiamo fatto esattamente questo, ispirato allo SubSonic ma trovando che la stessa SubSonic non era esattamente quello che volevamo. Ha funzionato piuttosto bene secondo me.

Answer 3

Non esiste un modo semplice per eseguire esattamente ciò che si desidera, poiché richiederebbe la creazione di un nuovo tipo in modo dinamico (i tipi anonimi vengono creati dal compilatore quando sono noti staticamente). Anche se è certamente fattibile, probabilmente non è l'opzione più semplice ...

È possibile ottenere un risultato simile 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; 
}