Передайте выражение LINQ другому QueryProvider

Question

Передайте выражение LINQ другому QueryProvider

У меня есть простой пользовательский QueryProvider, который принимает выражение, переводит его в SQL и запрашивает базу данных sql.

Я хочу создать небольшой кеш в QueryProvider, в котором хранятся общедоступные объекты, чтобы поиск мог происходить без попадания в базу данных.

QueryProvider имеет метод

public object Execute(System.Linq.Expressions.Expression expression)
{
    /// Builds an SQL statement from the expression, 
    /// executes it and returns matching objects
}

Кеш находится как поле в этом классе QueryProvider и представляет собой простой универсальный список.

Если я использую метод List.AsQueryable и передаю вышеприведенное выражение в метод Execute провайдера List.AsQueryable, он не работает должным образом. Похоже, что когда выражение компилируется, начальный QueryProvider становится неотъемлемой частью.

Можно ли передать выражение последующему QueryProvider и выполнить выражение по желанию?

Код вызова выглядит примерно так:

public class QueryProvider<Entity>()
{
    private List<TEntity> cache = new List<Entity>();

    public object Execute(System.Linq.Expressions.Expression expression)
    {
        /// check whether expression expects single or multiple result
        bool isSingle = true;

        if (isSingle)
        {
            var result = this.cache.AsQueryable<Entity>().Provider.Execute(expression);
            if (result != null) 
                return result;
        }

        /// cache failed, hit database
        var qt = new QueryTranslator();
        string sql = qt.Translate(expression);
        /// .... hit database
    }
}

Он не возвращает ошибку, вместо этого он застревает в цикле, где один и тот же провайдер вызывается снова и снова.

Вот еще немного кода, показывающего, что я пытаюсь сделать:

Коллекция:

class Collection<Entity>
{

    internal List<Entity> cacheOne { get; private set; }
    internal Dictionary<Guid, Entity> cacheTwo { get; private set; }

    internal Collection()
    {
        this.cacheOne = new List<Entity>();
        this.cacheTwo = new Dictionary<Guid, Entity>();
    }

    public IQueryable<Entity> Query()
    {
        return new Query<Entity>(this.cacheOne, this.cacheTwo);
    }

}

Запрос:

class Query<Entity> : IQueryable<Entity>
{
    internal Query(List<Entity> cacheOne, Dictionary<Guid, Entity> cacheTwo)
    {
        this.Provider = new QueryProvider<Entity>(cacheOne, cacheTwo);
        this.Expression = Expression.Constant(this);
    }

    internal Query(IQueryProvider provider, Expression expression)
    {
        this.Provider = provider;
        if (expression != null)
            this.Expression = expression;
    }

    public IEnumerator<Entity> GetEnumerator()
    {
        return this.Provider.Execute<IEnumerator<Entity>>(this.Expression);
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }

    public Type ElementType
    {
        get { return typeof(Entity); }
    }

    public System.Linq.Expressions.Expression Expression { get; private set; }

    public IQueryProvider Provider { get; private set; }
}

QueryProvider:

class QueryProvider<Entity> : IQueryProvider
{

    private List<Entity> cacheOne;
    private Dictionary<Guid, Entity> cacheTwo;

    internal QueryProvider(List<Entity> cacheOne, Dictionary<Guid, Entity> cacheTwo)
    {
        this.cacheOne = cacheOne;
        this.cacheTwo = cacheTwo;   
    }

    public IQueryable<TElement> CreateQuery<TElement>(System.Linq.Expressions.Expression expression)
    {
        return new Query<TElement>(this, expression);
    }

    public IQueryable CreateQuery(System.Linq.Expressions.Expression expression)
    {
        throw new NotImplementedException();
    }

    public TResult Execute<TResult>(System.Linq.Expressions.Expression expression)
    {
        return (TResult)this.Execute(expression);
    }

    public object Execute(System.Linq.Expressions.Expression expression)
    {
        Iterator<Entity> iterator = new Iterator<Entity>(expression, cacheOne, cacheTwo);
        return (iterator as IEnumerable<Entity>).GetEnumerator();
    }
}

Итератор:

class Iterator<Entity> : IEnumerable<Entity>
{
    private Expression expression;
    private List<Entity> cacheOne;
    private Dictionary<Guid, Entity> cacheTwo;

    internal Iterator(Expression expression, List<Entity> cacheOne, Dictionary<Guid, Entity> cacheTwo)
    {
        this.expression = expression;
        this.cacheOne = cacheOne;
        this.cacheTwo = cacheTwo;
    }

    public IEnumerator<Entity> GetEnumerator()
    {
        foreach (var result in (IEnumerable<Entity>)this.cacheOne.AsQueryable<Entity>().Provider.Execute(expression))
        {
            yield return result;
        }

        foreach (var more in (IEnumerable<Entity>)this.cacheTwo.Values.AsQueryable<Entity>().Provider.Execute(expression))
        {
            yield return more;
        }
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

Программа:

class Program
{
    static void Main(string[] args)
    {
        /// Create collection + caches
        var collection = new Collection<Giraffe>();
        collection.cacheOne.AddRange(new Giraffe[] {
            new Giraffe() { Id = Guid.NewGuid(), DateOfBirth = new DateTime(2011, 03, 21), Height = 192, Name = "Percy" },
            new Giraffe() { Id = Guid.NewGuid(), DateOfBirth = new DateTime(2005, 12, 25), Height = 188, Name = "Santa" },
            new Giraffe() { Id = Guid.NewGuid(), DateOfBirth = new DateTime(1999, 04, 01), Height=144, Name="Clown" }
        });
        var cachetwo = new List<Giraffe>(new Giraffe[] {
            new Giraffe() { Id = Guid.NewGuid(), DateOfBirth = new DateTime(1980, 03,03), Height = 599, Name="Big Ears" },
            new Giraffe() { Id = Guid.NewGuid(), DateOfBirth = new DateTime(1985, 04, 02), Height= 209, Name="Pug" }
        });
        foreach (var giraffe in cachetwo)
            collection.cacheTwo.Add(giraffe.Id, giraffe);

        /// Iterate through giraffes born before a certain date
        foreach (var result in collection.Query().Where(T => T.DateOfBirth < new DateTime(2006, 01, 01)))
        {
            Console.WriteLine(result.Name);
        }

    }
}

Жирафа:

class Giraffe
{
    public Guid Id { get; set; }
    public string Name { get; set;  }
    public long Height { get; set; }
    public DateTime DateOfBirth { get; set; }
}

Особые случаи, например, SingleAndDefault и т. Д., Не учитываются. Часть, которую я хочу работать, происходит в Iterator, где он в первую очередь выполняет QueryProvider для List перед выполнением Dictionary.

Одним из двух объектов Queryable может быть база данных или что-то еще.

14

c# linq linq-expressions

Источник

user259343 22 май '12 в 14:23

1 ответ

Решение

Другие вопросы по тегам c# linq linq-expressions

user143854 25 май '12 в 15:03 2012-05-25 15:03 · Accepted Answer · 2012-05-25 15:03

Нет, запрос не становится связанным с поставщиком. Вот почему у вас есть интерфейс IQueryable: он предоставляет и выражение, и поставщика, поэтому LINQ может вызвать поставщика для выполнения выражения.

Проблема в вашей реализации заключается в том, Query<Entity> представляет себя: вы устанавливаете корневое выражение Expression.Constant(this), где this это запрос (не коллекция).

Поэтому, когда вы выполняете запрос с LINQ-to-Objects, он вызовет GetEnumerator на Query<>, который затем вызывает LINQ-to-Objects для выполнения Expression, который имеет корневое выражение Expression.Constant(this) (типа Query<>), а затем LINQ-to-Objects выполняет итерацию этого корневого выражения, вызывая GetEnumerator на этом Query<>, так далее.

Проблема заключается в

(IEnumerable<Entity>)this.cacheOne.AsQueryable<Entity>().Provider.Execute(expression)

который в основном равен

new Entity[0].AsQueryable().Provider.Execute(expression)

или же

linqToObjectsProvider.Execute(expression)

Поставщик, возвращенный запросом, не связан с источником (this.cacheOne), так что вы просто выполняете выражение, а не запрашиваете кеш.

Что не так со следующим?

class Collection<Entity>
{
    ...

    public IQueryable<Entity> Query()
    {
        return this.cacheOne.Concat(this.cacheTwo.Values).AsQueryable();
    }
}

Обратите внимание, что Concat использует отложенную оценку, поэтому только при выполнении запроса cacheOne и cacheTwo объединяются, а затем обрабатываются с помощью дополнительных операторов LINQ.

(В этом случае я бы сделал Collection<Entity> IQueryablewithвыражениеequal toExpression.Constant(this.cacheOne.Concat(this.cacheTwo.Values))`. Я думаю, что вы можете покончить со всеми другими классами.)

Оригинальный ответ

Однако я не думаю, что такой способ поддержки LINQ to Objects когда-либо сможет сделать то, что, как вы думаете, должно.

По крайней мере, вы должны сохранить исходный поставщик запросов, чтобы вы могли вызывать его, если у вас отсутствует кэш. Если вы этого не сделаете и используете свой собственный провайдер запросов (вы не показали код, который используете для выполнения фактического вызова), ваш провайдер запросов будет вызывать себя снова и снова.

Поэтому вам нужно создать CachingQueryProvider и CachingQuery:

class CachingQuery<T> : IQueryable<T>
{
    private readonly CachingQueryProvider _provider;
    private readonly Expression _expression;

    public CachingQuery(CachingQueryProvider provider, Expression expression)
    {
        _provider = provider;
        _expression = expression;
    }

    // etc.
}

class CachingQueryProvider : IQueryProvider
{
    private readonly IQueryProvider _original;

    public CachingQueryProvider(IQueryProvider original)
    {
        _original = original;
    }

    // etc.
}

public static class CachedQueryable
{
    public static IQuerable<T> AsCached(this IQueryable<T> source)
    {
        return new CachingQuery<T>(
             new CachingQueryProvider(source.Provider), 
             source.Expression);
    }
}

Также, если вы хотите кешировать результат, вам нужно его материализовать, прежде чем вы его кешируете, иначе вы кешируете запрос, а не результат. И сам результат никогда не должен выполняться снова, так как это уже данные, которые вы должны вернуть.

Направление, в которое я направлюсь, следующее:

class CachingQueryProvider : IQueryProvider
{
    public object Execute(Expression expression)
    {
        var key = TranslateExpressionToCacheKey(expression);

        object cachedValue;
        if (_cache.TryGetValue(key, out cachedValue))
            return cachedValue;

        object result = _originalProvider.Execute(expression);

        // Won't compile because we don't know T at compile time
        IEnumerable<T> sequence = result as IEnumerable<T>;
        if (sequence != null && !(sequence is ICollection<T>)) 
        {
            result = sequence.ToList<T>();
        }

        _cache[key] = result; 

        return result;
    }
}

Для части, отмеченной как Won't compile, вам придется сделать некоторые хитрости отражения.

И осторожно: строка реализует IEnumerable, поэтому будьте осторожны, чтобы не пытаться материализовать одно значение строки.