LINQ pour cartographier dynamiquement (ou construire des projections)

Question

Je sais que je peux mapper deux types d'objets avec LINQ à l'aide d'une projection si:

var destModel = from m in sourceModel 
       select new DestModelType {A = m.A, C = m.C, E = m.E} 

où

class SourceModelType 
{ 
    string A {get; set;} 
    string B {get; set;} 
    string C {get; set;} 
    string D {get; set;} 
    string E {get; set;} 
} 

class DestModelType 
{ 
    string A {get; set;} 
    string C {get; set;} 
    string E {get; set;} 
} 

Mais si je veux faire quelque chose comme un générique pour le faire, où je ne connais pas précisément les deux types que je traite. Donc, il marcherait le type "Dest" et correspondrait avec les types "Source" correspondants .. est-ce possible? Aussi, pour réaliser l'exécution différée, je voudrais juste renvoyer un IQueryable.

Par exemple:

public IQueryable<TDest> ProjectionMap<TSource, TDest>(IQueryable<TSource> sourceModel) 
{ 
    // dynamically build the LINQ projection based on the properties in TDest 

    // return the IQueryable containing the constructed projection 
} 

Je sais que cela est difficile, mais je l'espère pas impossible, car il me sauvera un tas de travail de cartographie explicite entre les modèles et viewmodels.

Answer 1

Vous devez générer un arbre d'expression, mais simple, il est donc pas si difficile ...

void Main() 
{ 
    var source = new[] 
    { 
     new SourceModelType { A = "hello", B = "world", C = "foo", D = "bar", E = "Baz" }, 
     new SourceModelType { A = "The", B = "answer", C = "is", D = "42", E = "!" } 
    }; 

    var dest = ProjectionMap<SourceModelType, DestModelType>(source.AsQueryable()); 
    dest.Dump(); 
} 

public static IQueryable<TDest> ProjectionMap<TSource, TDest>(IQueryable<TSource> sourceModel) 
    where TDest : new() 
{ 
    var sourceProperties = typeof(TSource).GetProperties().Where(p => p.CanRead); 
    var destProperties = typeof(TDest).GetProperties().Where(p => p.CanWrite); 
    var propertyMap = from d in destProperties 
         join s in sourceProperties on new { d.Name, d.PropertyType } equals new { s.Name, s.PropertyType } 
         select new { Source = s, Dest = d }; 
    var itemParam = Expression.Parameter(typeof(TSource), "item"); 
    var memberBindings = propertyMap.Select(p => (MemberBinding)Expression.Bind(p.Dest, Expression.Property(itemParam, p.Source))); 
    var newExpression = Expression.New(typeof(TDest)); 
    var memberInitExpression = Expression.MemberInit(newExpression, memberBindings); 
    var projection = Expression.Lambda<Func<TSource, TDest>>(memberInitExpression, itemParam); 
    projection.Dump(); 
    return sourceModel.Select(projection); 
} 

(testé dans LINQPad, d'où les Dump s)

L'expression de projection générée ressemble à ça:

item => new DestModelType() {A = item.A, C = item.C, E = item.E}