Строгое сравнение выражений для кеша запросов в Entity Framework

Question

Я искал, и этот ответ помогает мне пройти часть пути =

Хотя до express моя проблема уходит Чтобы дать немного контекста, дело в том, что я внедряю систему запросов кэша внутри Entity Framework, код, который я сейчас использую, таков:

    public class ConnectionDataBank
    {
        public ProjectDataContext dc { set; get; }

        public ConnectionDataBank(ProjectDataContext item)
        {
            dc = item;
        }

        public interface CacheList
        {
            void Execute(ProjectDataContext dc);
        }

        private class ActualCacheList<x> : CacheList where x : class
        {
            public Type parameterType { set; get; }
            public List<x> cacheList { set; get; }
            public Expression<Func<x, bool>> expression { set; get; }

            public ActualCacheList(Expression<Func<x, bool>> expression)
            {
                parameterType   = typeof(x);
                this.expression = expression;
            }

            public void Execute(ProjectDataContext dc)
            {
                DbSet<x> Set = dc.Set<x>();

                cacheList = Set.Where(expression).ToList();
            }
        }

        List<CacheList> cacheItems { get; set; } = new List<CacheList>();

        private CacheList RecuperarElementoCache<x>(Expression<Func<x, bool>> expression) where x : class
        {
            CacheList itemList = cacheItems.SingleOrDefault
            (
                l =>
                ((ActualCacheList<x>)l).parameterType == typeof(x)
                &&
                LambdaCompare.Eq<x, bool>(((ActualCacheList<x>)l).expression, expression)
            );

            if (itemList == null)
            {
                itemList = new ActualCacheList<x>(expression);
                itemList.Execute(dc);
                cacheItems.Add(itemList);
            }

            return itemList;
        }

        public List<x> CacheQuery<x>(Expression<Func<x, bool>> expression) where x : class
        {
            return ((ActualCacheList<x>)RecuperarElementoCache(expression)).cacheList;
        }
    }          

(LambdaCompare - это разработанный код by neleus (https://www.nuget.org/packages/Neleus.LambdaCompare/))

Этот код находится внутри datacontext, и он вроде работает, для примера давайте создадим этот метод

public void SearchByGUUID(GUUID)
{
    using(ProjectDataContext dc)
    {
        dc.dataBank.CacheQuery<DataBaseItem>(b => b.GUUID == GUUID).Any();
    }
}

Если я попытаюсь чтобы выполнить его так, он работает.

SearchByGUUID("a");
SearchByGUUID("a");    // The cache list is being recovered successfully! :)

, но если я запустил его так, он получит предыдущий список кэша:

SearchByGUUID("b");    // The cache list isn't being recovered successfully :( 

Проблема, как я ее вижу в том, что выражение правильно определяется как одно и то же, а параметры - нет.

Что можно сделать, чтобы определить значения и синтаксис выражения?

Заранее спасибо