Факторинговые из выражений в LINQ запросов

Question

Допустим, у меня есть следующий Linq2Entities запрос для некоторого метода обслуживания:

public IQueryable<CustomerProjection>() 
{ 
    return 
     from i in this.DbContext.Customers 
     select new CustomerProjection() 
     { 
      Reference = new EntityReference() 
      { 
       Id = i.Id, 
       Name = i.Name 
      } 
     } 
} 

Все мои модели объектов, в том числе клиентов, все поддерживают следующий интерфейс:

interface INamedEntity 
{ 
    String Name { get; set; } 
    Guid Id { get; set; } 
} 

так что в принципе у меня возникает соблазн провести рефакторинг:

public IQueryable<CustomerProjection>() 
{ 
    return 
     from i in this.DbContext.Customers 
     select new CustomerProjection() 
     { 
      // I want something something like this: 
      Reference = GetReference(i) 
     } 
} 

Очевидно, я не могу наивно определить GetRefe Renče таким образом:

public EntityReference GetReference<E>(E i) 
    where E : INamedEntity 
{ 
    return new EntityReference() 
    { 
     Id = i.Id, 
     Name = i.Name, 
    }; 
} 

Что мне нужно вынесем логика создать выражение для запроса, а не как EntityReference непосредственно. Итак, давайте определим его таким образом:

public Expression<Func<INamedEntity, EntityReference>> GetReferenceExpression() 
    where E : INamedEntity 
{ 
    return i => new EntityReference() 
    { 
     Id = i.Id, 
     Name = i.Name, 
    }; 
} 

Это правильно отводит логику. Тем не менее, я не могу использовать его в основном запросе:

public IQueryable<CustomerProjection>() 
{ 
    return 
     from i in this.DbContext.Customers 
     select new CustomerProjection() 
     { 
      // Something like "Invoke" doesn't exist! 
      Reference = GetReferenceExpression().Invoke(i) 
     } 
} 

мне нужно что-то вроде этого метода «Invoke» расширения поддерживаемых Linq2Entities, чтобы помочь мне на самом деле использовать мою преобразованную выход логику.

Обратите внимание, что это примерный сценарий со сниженной сложностью. Я понимаю, что факторинг в этом простом экземпляре действительно не нужен, но у меня были случаи более сложные, когда я хотел бы сделать что-то подобное.

Кроме того, есть второй, связанный сценарий, в котором не только хочет использовать преобразованная выход кода в более чем один запрос, но оценить его непосредственно:

GetReferenceExpression().Compile()(myEntity); 

Это особенно интересно, если factored-out code является предикатом для фильтра.

Так что мой вопрос:

1. Поддерживает ли Linq2Entities что-то вроде этого? Если да, то как?
2. Есть ли другой провайдер linq независимый способ разложения выражений?

Answer 1

Вы можете сделать это:

Интерфейсы:

public interface IReference 
{ 
    int ID { get; } 
    string Name { get; } 
} 

Бетонные классы, реализующие интерфейсы

public class Reference : IReference 
{ 
    public int ID { get; set; } 
    public string Name { get; set; } 
} 

public class ReferenceAndEntity<T> 
{ 
    public Reference Reference { get; set; } 
    public T Entity { get; set } 
} 

IQueryable

public static IQueryable<ReferenceAndEntity<T>> GetReferenceAndEntityQuery<T>(IQueryable<T> set) where T: class, IReference 
{ 
    var query = from x in set 
       select new ReferenceAndEntity<T>() 
       { 
       Reference = new Reference() 
       { 
        ID = x.ID, 
        Name = x.Name 
       }, 
       Entity = x 
       }; 
    return query; 
} 

Использование

using(DbContext context = new Context()) 
{ 
    var query = from x in GetReferenceAndEntityQuery(context.dataSet) 
       select new 
       { 
       Reference = x.Reference, 
       EntityProperty1 = x.Entity.Property1, 
       }; 
} 

Answer 2

Вы можете использовать поставщика LINQ прокси, который сидит перед поставщиком LINQ EF в. Вы можете сделать любое переписывание, которое вы хотите в этом месте.

Я сделал это. Это много работы, но это, безусловно, можно сделать. Можно, например, сделать ваш провайдер переписать так:

Expression<Func<MyEntity, bool>> someFilter = e => e.SomeProperty == 1234; 
... 
from e in db.Entities 
where MyCustomLINQProvider.CallExpression(someFilter, e) 
select e 

к этому:

from e in db.Entities 
where e.SomeProperty == 1234 
select e 

который является приемлемым для поставщика LINQ EF в. MyCustomLINQProvider.CallExpression будет помощником, который никогда не вызывается во время выполнения. Это просто как маркер вашего механизма перезаписи, чтобы встроить данное выражение. Без этого помощника код не будет компилироваться.

Для этого вам необходимо реализовать пользовательский IQueryable. Этот интерфейс определяется как:

public interface IQueryable : IEnumerable 
{ 
    Type ElementType { get; } 
    Expression Expression { get; } 
    IQueryProvider Provider { get; } 
} 

public interface IQueryProvider 
{ 
    IQueryable CreateQuery(Expression expression); 
    IQueryable<TElement> CreateQuery<TElement>(Expression expression); 
    object Execute(Expression expression); 
    TResult Execute<TResult>(Expression expression); 
} 

В IQueryProvider.Execute вы выполняете перезапись и передать запрос на EF-х IQueryProvider.

---

Вы могли бы сделать MyCustomLINQProvider.CallExpression расширение, так что это менее неудобно использовать:

static bool Call<TTarget, TArg0>(
    this Expression<Func<TArg0, TReturn>> target, TArg0 arg0) { 
throw new NotSupportedException("cannot call this statically"); 
} 
... 
where someFilter.Call(e) //looks almost like a func 

Вам нужен слой выше EF абстрагироваться от поставщика LINQ:

ObjectContext objectContext; 
IQueryable<T> Query<T>() { 
return new MyCustomQueryable<T>(objectContext.CreateObjectSet<T>()); 
} 

Так DON» t спросить EF для запроса, спросите свой код, чтобы вы могли передать прокси.

В вашем переписывающем устройстве вы не должны много делать. Вы ищете правильный шаблон и просто замените предикат ParameterExpression тем, что было передано как аргумент Call. Вот эскиз:

protected virtual Expression VisitMethodCall(MethodCallExpression node) 
{ 
    if (IsCall(node)) { 
    var expressionToInline = GetExpressionToInline(node.Arguments[0]); 
    var arg0 = node.Arguments[1]; 
    var parameter = expressionToInline.Parameters[0]; 
    var predicateExpression = ReplaceExpression(original: expressionToInline.Body, toReplace: parameter, replaceWith: arg0); 
    return predicateExpression; 
    } 

    return base.VisitMethodCall(node); 
} 

Там пример кода для ReplaceExpression доступны в Интернете.