Expressão lambda para Expression <T> Tree (Slice 2 - Join)

Question

Como você coloca um elefante na geladeira? Você corta ... Então, como você traduz uma consulta lambda para a árvore de expressão? Você corta ...

Esta é uma série de 3 fatias de expressão lambda para a árvore de expressão.

Slice 1. Aqui , como fazer .join () usando o exemplo da Microsoft.

Fatia 2 (esta fatia). Carregamento rápido com parâmetros diferentes daqueles usados ​​no Slice 1.

Fatia 3. Aqui , como terminar a consulta com .where () e .Select ().

Neste Slice, estou tentando converter a seguinte consulta em sintaxe de árvore de expressão:

IQueryable<A> As = db.A
                     .Join(
                           db.B,
                           _a => _a.bID,
                           _b => _b.ID,
                           (a, b) => new { a, b })
                     //The next two statements are going to next slice.
                     .Where(s=> s.b.Name == "xpto")
                     .Select(s => s.a);

Na fatia 1, tive:

Exemplo anterior de transformação:

var query = people.AsQueryable().Join(pets,
                person => person,
                pet => pet.Owner,
                (person, pet) =>
                    new { OwnerName = person.Name, Pet = pet.Name });

Isso resultou em uma resposta @NetMage, que funcionou com:

// Build Queryable.Join<TOuter,TInner,TKey,TResult> and use as query expression

// IQueryable<TOuter>
var arg0 = Expression.Constant(people.AsQueryable());

// IEnumerable<TInner>
var arg1 = Expression.Constant(pets);

// TOuter person
var arg2p = Expression.Parameter(people.GetType().GetGenericArguments()[0], "person");
// also TKey person
// Expression<Func<TOuter,TKey>>: person => person
var arg2 = Expression.Quote(Expression.Lambda(arg2p, arg2p));

// TInner pet
var arg3p = Expression.Parameter(pets.GetType().GetGenericArguments()[0], "pet");
// TKey pet.Owner
var arg3body = Expression.Property(arg3p, "Owner");
// Expression<Func<TInner,TKey>>: pet => pet.Owner
var arg3 = Expression.Quote(Expression.Lambda(arg3body, arg3p));

// TResult = typeof(new { string OwnerName , string Pet })
var anonymousType = (new { OwnerName = default(string), Pet = default(string) }).GetType();
// .ctor
var arg4Constructor = anonymousType.GetConstructors()[0];
// person.Name
var arg4PersonName = Expression.Property(arg2p, "Name");
// pet.Name
var arg4PetName = Expression.Property(arg3p, "Name");
var arg4Args = new[] { arg4PersonName, arg4PetName };
// new[] { .OwnerName, .Pet }
var arg4Members = anonymousType.GetProperties();
// new { OwnerName = person.Name, Pet = pet.Name }
var arg4body = Expression.New(arg4Constructor, arg4Args, arg4Members);
// Expression<Func<TOuter,TInner,TResult>>: (person,pet) => new { OwnerName = person.Name, Pet = pet.Name }
var arg4 = Expression.Quote(Expression.Lambda(arg4body, arg2p, arg3p));

var joinGenericMI = typeof(Queryable).GetMethod("Join", 5);
var joinMI = joinGenericMI.MakeGenericMethod(new[] { arg2p.Type, arg3p.Type, arg2.ReturnType, anonymousType });
var qExpr = Expression.Call(joinMI, arg0, arg1, arg2, arg3, arg4);

Para esta fatia, a seguinte declaração - apresentada na fatia anterior - precisava ser alterada:

// TResult = typeof(new { string OwnerName , string Pet })
    var anonymousType = (new { OwnerName = default(string), Pet = default(string) }).GetType();

@NetMage adaptou para genéricos A e B:

// TResult = typeof(new { A , B })
var anonymousType = (new { A = db.A.FirstOrDefault(), db.B = B.FirstOrDefault() }).GetType();

e

var arg4Constructor = anonymousType.GetConstructors()[0];
// person.Name
var arg4PersonName = Expression.Property(arg2p, "Name");
// pet.Name
var arg4PetName = Expression.Property(arg3p, "Name");

tornou-se (adaptado para A e B genéricos):

// object A
var arg4A = arg2p;
// object B
var arg4B = arg3p;

Agora é necessário filtrar o resultado por b.Nome e Selecionar a (próxima fatia).

Answer 1

Para obter o tipo de retorno do Joinmétodo, faça o seguinte:

// TResult = typeof(new { A , B })
var anonymousType = (new { A = db.A.FirstOrDefault(), db.B = B.FirstOrDefault() }).GetType();

Você precisa criar um tipo anônimo onde o membro Atem tipo de db.Aentidade de tipo. Se você usar typeof(A), por exemplo , terá Acom tipo Type, completamente não relacionado ao Join. (Se você conhecesse o tipo de entidade de A, poderia apenas usar defaultcomo eu: por exemplo, if db.Ais DbSet<AClass>then use A = default(AClass).)

Como você não está referenciando nenhuma propriedade no Joinresultado, basta usar os parâmetros:

// object A
var arg4A = arg2p;
// object B
var arg4B = arg3p;