Tenho um repositório de pesquisa para o EntityFramework 4.0 usando o LinqKit com a seguinte função de pesquisa:

public IQueryable<T> Search<T>(Expression<Func<T, bool>> predicate) 
    where T : EntityObject
{
    return _unitOfWork.ObjectSet<T>().AsExpandable().Where(predicate);
}

E outra classe que usa o valor de retorno IQueryable para subconjunto da consulta de maneiras que não são possíveis usando as expressões Booleanas LinqKit PredicateBuilder:

public IQueryable<T> SubsetByUser<T>(IQueryable<T> set, User user) 
    where T : EntityObject
{
    return set.Join(_searcher.Search<Metadatum>((o) => o.UserGUID == user.GUID),
                    arc => arc.GUID,
                    meta => meta.ElementGUID,
                    (arc, meta) => arc);
}

O problema aqui é que 'T' como EntityObject não define GUID, então não posso usar isso. A resposta natural para isso é realmente definir o método SubsetByUser () para usar uma restrição com uma propriedade GUID:

public IQueryable<T> SubsetByUser<T>(IQueryable<T> set, User user) 
    where T : IHaveMetadata
{
    return set.Join(_searcher.Search<Metadatum>((o) => o.UserGUID == user.GUID),
                    arc => arc.GUID,
                    meta => meta.ElementGUID,
                    (arc, meta) => arc);
}

Mas isso não funciona. Estou usando o LinqKit e o método Expansível () resulta em:

System.NotSupportedException: Unable to cast the type 'Oasis.DataModel.Arc' to
type 'Oasis.DataModel.Interfaces.IHaveMetadata'. LINQ to Entities only supports 
casting Entity Data Model primitive types

Eu preciso que um IQueryable seja devolvido. Eu posso fazer uma falsificação assim:

public IQueryable<T> SubsetByUser<T>(IQueryable<T> set, User user) 
    where T : EntityObject
{
    return set.AsEnumerable()
              .Join(_searcher.Search<Metadatum>((o) => o.UserGUID == user.GUID),
                    arc => arc.GUID,
                    meta => meta.ElementGUID,
                    (arc, meta) => arc)
              .AsQueryable();
}

Que, é claro, funciona, mas que também é, obviamente, uma coisa louca de se fazer. (A razão pela qual desejo o IQueryable é não executar a consulta até que estejamos finais.

Eu até tentei isso:

public IQueryable<T> SubsetByUser<T>(IQueryable<T> set, User user) 
    where T : EntityObject
{
    return set.Join(_searcher.Search<Metadatum>((o) => o.UserGUID == user.GUID),
                    arc => arc.GetType().GetProperty("GUID").GetValue(arc,null),
                    meta => meta.ElementGUID,
                    (arc, meta) => arc);
}

Que usa a reflexão para obter a coleção Runs - contornando o erro do compilador. Eu pensei que era bastante inteligente, mas resulta na exceção LINQ:

System.NotSupportedException: LINQ to Entities does not recognize the 
method 'System.Object GetValue(System.Object, System.Object[])' method, 
and this method cannot be translated into a store expression.

Também poderia tentar alterar o método de pesquisa:

public IQueryable<T> Search<T>(Expression<Func<T, bool>> predicate) 
    where T : IRunElement
{
    return _unitOfWork.ObjectSet<T>().AsExpandable().Where(predicate);
}

Mas isso não será compilado, é claro, porque IRunElement não é um EntityObject e ObjectSet restringe T como uma class

A possibilidade final é simplesmente tornar todos os parâmetros e retornar valores IEnumerable:

public IEnumerable<T> SubsetByUser<T>(IEnumerable<T> set, User user) 
    where T : EntityObject
{
    return set.Join(_searcher.Search<Metadatum>((o) => o.UserGUID == user.GUID),
                    arc => arc.GetType().GetProperty("GUID").GetValue(arc,null),
                    meta => meta.ElementGUID,
                    (arc, meta) => arc);
}

O que também funciona, mas que, novamente, não nos permite adiar a instanciação até o fina

Então, parece que há pouco que eu possa fazer para fazer isso funcionar sem instanciar tudo como um IEnumerable e depois retorná-lo usando AsQueryable (). Existe alguma maneira de juntar isso que estou perdendo?