Création de types anonymes basés sur l'expression lambda

Question

J'essaie de créer une interface Fluent pour le format de données Winforms. Cela devrait me permettre d'utiliser une source de données typé et l'utilisation facile des propriétés des propriétés (Order.Custom.FullName)

J'ajoute les colonnes à l'initialisation et en essayant de définir la propriété d'y utiliser:

dgv.With<Order>().Column("Client Name").On(x => x.Client.FullName); 

la question initiale se pose alors lors de la mise DataSource:

dgv.SetTypedDatasource<T>(IList<Order> orders) 

Un gros problème ici est que les contrôles génériques ne sont pas possibles (je suppose), de sorte que T ne peut pas être spécifiée pour la classe, mais doit être spécifié par méthode ...

Je veux créer une liste des types anonymes, sur la base d'une propriété donnée dans une expression lambda:

quelque chose comme:

ProcessList<Client>(clientList, x => x.FullName); 

Est-il possible de faire quelque chose comme ceci:

[Modifier] Notez que dans la pratique, les expressions seront définies plus tôt, et seront récupérées ailleurs ...

public void ProcessList<T>(IList<T> sourceList, Expression<Func<T, object>> expression) 
{ 
    var list = 
     (from T x 
     in sourceList 
     select new { expression }) 
     .ToList(); 

    // process list .... grid.DataSource = list; 
} 

Donc, je voudrais créer des types anonymes basés sur l'expression donnée. Je sais que je peux évaluer cette expression pour récupérer les bonnes propriétés.

Je suis coincé, est-ce quelque chose comme ça possible?

Des idées?

Answer 1

Eh bien, avec un simple appel à Select vous pouvez venir très proche:

ProcessList(clientList.Select(x => new { x.FullName })); 

... 

public void ProcessList<T>(IEnumerable<T> list) 
{ 
    // process list ... T will be an anonymous type by now 
    grid.DataSource = list; 
} 

(cela suppose que vous ne avez pas besoin de la liste originale ProcessList ainsi Si vous le faites, déplacez la sélection. . en là)

Answer 2

est pas seulement grid.DataSource = sourceList.AsQueryable().Select(expression).ToList();

Notez qu'il serait préférable d'introduire un deuxième générique, de telle sorte que la liste est typée:

public static void ProcessList<TSource, TValue>(
     IList<TSource> sourceList, 
     Func<TSource, TValue> expression) 
    { 
     grid.DataSource = sourceList.Select(expression).ToList(); 
    } 

Remarque Je suis passé de Expression<...> juste Func<...>, car il semblait servir à rien.