diff --git a/Source/EntityFramework.Extended/Caching/Query/Evaluator.cs b/Source/EntityFramework.Extended/Caching/Query/Evaluator.cs
deleted file mode 100644
index 080f6c5..0000000
--- a/Source/EntityFramework.Extended/Caching/Query/Evaluator.cs
+++ /dev/null
@@ -1,138 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-
-namespace EntityFramework.Caching
-{
-    /// <summary>
-    /// Enables the partial evaluation of queries.
-    /// </summary>
-    /// <remarks>
-    /// From http://msdn.microsoft.com/en-us/library/bb546158.aspx
-    /// Copyright notice http://msdn.microsoft.com/en-gb/cc300389.aspx#O
-    /// </remarks>
-    internal static class Evaluator
-    {
-        /// <summary>
-        /// Performs evaluation and replacement of independent sub-trees
-        /// </summary>
-        /// <param name="expression">The root of the expression tree.</param>
-        /// <param name="fnCanBeEvaluated">A function that decides whether a given expression node can be part of the local function.</param>
-        /// <returns>A new tree with sub-trees evaluated and replaced.</returns>
-        public static Expression PartialEval(Expression expression, Func<Expression, bool> fnCanBeEvaluated)
-        {
-            return new SubtreeEvaluator(new Nominator(fnCanBeEvaluated).Nominate(expression)).Eval(expression);
-        }
-
-        /// <summary>
-        /// Performs evaluation and replacement of independent sub-trees
-        /// </summary>
-        /// <param name="expression">The root of the expression tree.</param>
-        /// <returns>A new tree with sub-trees evaluated and replaced.</returns>
-        public static Expression PartialEval(Expression expression)
-        {
-            return PartialEval(expression, Evaluator.CanBeEvaluatedLocally);
-        }
-
-        private static bool CanBeEvaluatedLocally(Expression expression)
-        {
-            return expression.NodeType != ExpressionType.Parameter;
-        }
-
-        /// <summary>
-        /// Evaluates and replaces sub-trees when first candidate is reached (top-down)
-        /// </summary>
-        class SubtreeEvaluator : ExpressionVisitor
-        {
-            HashSet<Expression> candidates;
-
-            internal SubtreeEvaluator(HashSet<Expression> candidates)
-            {
-                this.candidates = candidates;
-            }
-
-            internal Expression Eval(Expression exp)
-            {
-                return this.Visit(exp);
-            }
-
-            public override Expression Visit(Expression exp)
-            {
-                if (exp == null)
-                {
-                    return null;
-                }
-                if (this.candidates.Contains(exp))
-                {
-                    return this.Evaluate(exp);
-                }
-                return base.Visit(exp);
-            }
-
-            private Expression Evaluate(Expression e)
-            {
-                if (e.NodeType == ExpressionType.Constant)
-                {
-                    return e;
-                }
-                LambdaExpression lambda = Expression.Lambda(e);
-                Delegate fn = lambda.Compile();
-                return Expression.Constant(fn.DynamicInvoke(null), e.Type);
-            }
-
-            protected override Expression VisitMemberInit(MemberInitExpression node)
-            {
-                if (node.NewExpression.NodeType == ExpressionType.New)
-                    return node;
-
-                return base.VisitMemberInit(node);
-            }
-        }
-
-        /// <summary>
-        /// Performs bottom-up analysis to determine which nodes can possibly
-        /// be part of an evaluated sub-tree.
-        /// </summary>
-        class Nominator : ExpressionVisitor
-        {
-            Func<Expression, bool> fnCanBeEvaluated;
-            HashSet<Expression> candidates;
-            bool cannotBeEvaluated;
-
-            internal Nominator(Func<Expression, bool> fnCanBeEvaluated)
-            {
-                this.fnCanBeEvaluated = fnCanBeEvaluated;
-            }
-
-            internal HashSet<Expression> Nominate(Expression expression)
-            {
-                this.candidates = new HashSet<Expression>();
-                this.Visit(expression);
-                return this.candidates;
-            }
-
-            public override Expression Visit(Expression expression)
-            {
-                if (expression != null)
-                {
-                    bool saveCannotBeEvaluated = this.cannotBeEvaluated;
-                    this.cannotBeEvaluated = false;
-                    base.Visit(expression);
-                    if (!this.cannotBeEvaluated)
-                    {
-                        if (this.fnCanBeEvaluated(expression))
-                        {
-                            this.candidates.Add(expression);
-                        }
-                        else
-                        {
-                            this.cannotBeEvaluated = true;
-                        }
-                    }
-                    this.cannotBeEvaluated |= saveCannotBeEvaluated;
-                }
-                return expression;
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Source/EntityFramework.Extended/Caching/Query/LocalCollectionExpander.cs b/Source/EntityFramework.Extended/Caching/Query/LocalCollectionExpander.cs
deleted file mode 100644
index d05d7f8..0000000
--- a/Source/EntityFramework.Extended/Caching/Query/LocalCollectionExpander.cs
+++ /dev/null
@@ -1,82 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-
-namespace EntityFramework.Caching
-{
-    /// <summary>
-    /// Enables cache key support for local collection values.
-    /// </summary>
-    internal class LocalCollectionExpander : ExpressionVisitor
-    {
-        public static Expression Rewrite(Expression expression)
-        {
-            return new LocalCollectionExpander().Visit(expression);
-        }
-
-        protected override Expression VisitMethodCall(MethodCallExpression node)
-        {
-            // pair the method's parameter types with its arguments
-            var map = node.Method.GetParameters()
-                .Zip(node.Arguments, (p, a) => new { Param = p.ParameterType, Arg = a })
-                .ToLinkedList();
-
-            // deal with instance methods
-            var instanceType = node.Object == null ? null : node.Object.Type;
-            map.AddFirst(new { Param = instanceType, Arg = node.Object });
-
-            // for any local collection parameters in the method, make a
-            // replacement argument which will print its elements
-            var replacements = (from x in map
-                                where x.Param != null && x.Param.IsGenericType
-                                let g = x.Param.GetGenericTypeDefinition()
-                                where g == typeof(IEnumerable<>) || g == typeof(List<>)
-                                where x.Arg.NodeType == ExpressionType.Constant
-                                let elementType = x.Param.GetGenericArguments().Single()
-                                let printer = MakePrinter((ConstantExpression)x.Arg, elementType)
-                                select new { x.Arg, Replacement = printer }).ToList();
-
-            if (replacements.Any())
-            {
-                var args = map.Select(x => (from r in replacements
-                                            where r.Arg == x.Arg
-                                            select r.Replacement).SingleOrDefault() ?? x.Arg).ToList();
-
-                node = node.Update(args.First(), args.Skip(1));
-            }
-
-            return base.VisitMethodCall(node);
-        }
-
-        ConstantExpression MakePrinter(ConstantExpression enumerable, Type elementType)
-        {
-            var value = (IEnumerable)enumerable.Value;
-            var printerType = typeof(Printer<>).MakeGenericType(elementType);
-            var printer = Activator.CreateInstance(printerType, value);
-
-            return Expression.Constant(printer);
-        }
-
-        /// <summary>
-        /// Overrides ToString to print each element of a collection.
-        /// </summary>
-        /// <remarks>
-        /// Inherits List in order to support List.Contains instance method as well
-        /// as standard Enumerable.Contains/Any extension methods.
-        /// </remarks>
-        class Printer<T> : List<T>
-        {
-            public Printer(IEnumerable collection)
-            {
-                this.AddRange(collection.Cast<T>());
-            }
-
-            public override string ToString()
-            {
-                return "{" + this.ToConcatenatedString(t => t.ToString(), "|") + "}";
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Source/EntityFramework.Extended/Caching/Query/QueryCache.cs b/Source/EntityFramework.Extended/Caching/Query/QueryCache.cs
index dcb57ea..9d07d81 100644
--- a/Source/EntityFramework.Extended/Caching/Query/QueryCache.cs
+++ b/Source/EntityFramework.Extended/Caching/Query/QueryCache.cs
@@ -1,6 +1,5 @@
-using System;
-using System.Linq;
-using System.Linq.Expressions;
+using System.Linq;
+using EntityFramework.Extensions;
 
 namespace EntityFramework.Caching
 {
@@ -20,18 +19,10 @@ public static class QueryCache
         /// </summary>
         /// <param name="query">The query to get the key from.</param>
         /// <returns>A unique key for the specified <see cref="IQueryable"/></returns>
-        public static string GetCacheKey(this IQueryable query)
+        public static string GetCacheKey<TEntity>(this IQueryable<TEntity> query) where TEntity : class
         {
-            var expression = query.Expression;
-
-            // locally evaluate as much of the query as possible
-            expression = Evaluator.PartialEval(expression, QueryCache.CanBeEvaluatedLocally);
-
-            // support local collections
-            expression = LocalCollectionExpander.Rewrite(expression);
-
-            // use the string representation of the expression for the cache key
-            string key = expression.ToString();
+            // The key is made up of the SQL that will be executed, along with any parameters and their values
+            string key = query.ToTraceString();
 
             // the key is potentially very long, so use an md5 fingerprint
             // (fine if the query result data isn't critically sensitive)
@@ -39,24 +30,5 @@ public static string GetCacheKey(this IQueryable query)
 
             return key;
         }
-
-        static Func<Expression, bool> CanBeEvaluatedLocally
-        {
-            get
-            {
-                return expression =>
-                {
-                    // don't evaluate parameters
-                    if (expression.NodeType == ExpressionType.Parameter)
-                        return false;
-
-                    // can't evaluate queries
-                    if (typeof(IQueryable).IsAssignableFrom(expression.Type))
-                        return false;
-
-                    return true;
-                };
-            }
-        }
     }
 }
diff --git a/Source/EntityFramework.Extended/EntityFramework.Extended.net40.csproj b/Source/EntityFramework.Extended/EntityFramework.Extended.net40.csproj
index 948e605..6dfa3b0 100644
--- a/Source/EntityFramework.Extended/EntityFramework.Extended.net40.csproj
+++ b/Source/EntityFramework.Extended/EntityFramework.Extended.net40.csproj
@@ -86,8 +86,6 @@
     <Compile Include="Caching\ICacheProvider.cs" />
     <Compile Include="Caching\CacheTag.cs" />
     <Compile Include="Caching\MemoryCacheProvider.cs" />
-    <Compile Include="Caching\Query\Evaluator.cs" />
-    <Compile Include="Caching\Query\LocalCollectionExpander.cs" />
     <Compile Include="Caching\Query\QueryCache.cs" />
     <Compile Include="Caching\Query\Utility.cs" />
     <Compile Include="Future\IFutureRunner.cs" />
@@ -152,7 +150,6 @@
     <None Include="packages.config" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/Source/EntityFramework.Extended/EntityFramework.Extended.net45.csproj b/Source/EntityFramework.Extended/EntityFramework.Extended.net45.csproj
index 7c53a08..d955c2e 100644
--- a/Source/EntityFramework.Extended/EntityFramework.Extended.net45.csproj
+++ b/Source/EntityFramework.Extended/EntityFramework.Extended.net45.csproj
@@ -86,8 +86,6 @@
     <Compile Include="Caching\ICacheProvider.cs" />
     <Compile Include="Caching\CacheTag.cs" />
     <Compile Include="Caching\MemoryCacheProvider.cs" />
-    <Compile Include="Caching\Query\Evaluator.cs" />
-    <Compile Include="Caching\Query\LocalCollectionExpander.cs" />
     <Compile Include="Caching\Query\QueryCache.cs" />
     <Compile Include="Caching\Query\Utility.cs" />
     <Compile Include="Future\IFutureRunner.cs" />
@@ -152,7 +150,6 @@
     <None Include="packages.config" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/Source/EntityFramework.Extended/Extensions/ObjectQueryExtensions.cs b/Source/EntityFramework.Extended/Extensions/ObjectQueryExtensions.cs
index 66a7c31..47bf60b 100644
--- a/Source/EntityFramework.Extended/Extensions/ObjectQueryExtensions.cs
+++ b/Source/EntityFramework.Extended/Extensions/ObjectQueryExtensions.cs
@@ -1,9 +1,9 @@
 using System;
-using System.Collections.Generic;
 using System.Data.Entity.Core.Objects;
 using System.Data.Entity.Infrastructure;
 using System.Linq;
 using System.Linq.Expressions;
+using System.Text;
 using EntityFramework.Reflection;
 
 namespace EntityFramework.Extensions
@@ -11,116 +11,156 @@ namespace EntityFramework.Extensions
     /// <summary>
     /// Extension methods for for ObjectQuery.
     /// </summary>
-  public static class ObjectQueryExtensions
-  {
-      /// <summary>
-      /// Convert the query into an ObjectQuery.
-      /// </summary>
-      /// <typeparam name="TEntity">The type of the entity.</typeparam>
-      /// <param name="query">The query to convert.</param>
-      /// <returns>The converted ObjectQuery; otherwise null if it can't be converted.</returns>
-      public static ObjectQuery<TEntity> ToObjectQuery<TEntity>(this IQueryable<TEntity> query) where TEntity : class
-      {
-          // first try direct cast
-          var objectQuery = query as ObjectQuery<TEntity>;
-          if (objectQuery != null)
-              return objectQuery;
-
-          // next try case to DbQuery
-          var dbQuery = query as DbQuery<TEntity>;
-          if (dbQuery == null)
-              return null;
-
-          // access internal property InternalQuery
-          dynamic dbQueryProxy = new DynamicProxy(dbQuery);
-          dynamic internalQuery = dbQueryProxy.InternalQuery;
-          if (internalQuery == null)
-              return null;
-
-          // access internal property ObjectQuery
-          dynamic objectQueryProxy = internalQuery.ObjectQuery;
-          if (objectQueryProxy == null)
-              return null;
-
-          // convert dynamic to static type
-          objectQuery = objectQueryProxy;
-          return objectQuery;
-      }
-
-      /// <summary>
-      /// Convert the query into an ObjectQuery.
-      /// </summary>
-      /// <param name="query">The query to convert.</param>
-      /// <returns>The converted ObjectQuery; otherwise null if it can't be converted.</returns>
-      public static ObjectQuery ToObjectQuery(this IQueryable query)
-      {
-          // first try direct cast
-          var objectQuery = query as ObjectQuery;
-          if (objectQuery != null)
-              return objectQuery;
-
-          // next try case to DbQuery
-          var dbQuery = query as DbQuery;
-          if (dbQuery == null)
-              return null;
-
-          // access internal property InternalQuery
-          dynamic dbQueryProxy = new DynamicProxy(dbQuery);
-          dynamic internalQuery = dbQueryProxy.InternalQuery;
-          if (internalQuery == null)
-              return null;
-
-          // access internal property ObjectQuery
-          dynamic objectQueryProxy = internalQuery.ObjectQuery;
-          if (objectQueryProxy == null)
-              return null;
-
-          // convert dynamic to static type
-          objectQuery = objectQueryProxy;
-          return objectQuery;
-      }
-
-      /// <summary>
-      /// Creates an ObjectQuery from an expression.
-      /// </summary>
-      /// <param name="source">The source.</param>
-      /// <param name="expression">The expression.</param>
-      /// <param name="type">The type.</param>
-      /// <returns>An ObjectQuery created from the expression.</returns>
-      public static ObjectQuery CreateQuery(this IQueryable source, Expression expression, Type type)
-      {
-          // first convert to object query to get the correct provider
-          ObjectQuery sourceQuery = source.ToObjectQuery();
-          if (sourceQuery == null)
-              return null;
-
-          IQueryProvider provider = ((IQueryable)sourceQuery).Provider;
-
-          // create query from expression using internal ObjectQueryProvider
-          dynamic providerProxy = new DynamicProxy(provider);
-          IQueryable expressionQuery = providerProxy.CreateQuery(expression, type);
-          if (expressionQuery == null)
-              return null;
-
-          // convert back to ObjectQuery
-          ObjectQuery resultQuery = expressionQuery.ToObjectQuery();
-          return resultQuery;
-      }
-
-      /// <summary>
-      /// Gets the ObjectContext for the specifed query.
-      /// </summary>
-      /// <typeparam name="TEntity">The type of the entity.</typeparam>
-      /// <param name="query">The query.</param>
-      /// <returns>The ObjectContext for the query.</returns>
-      public static ObjectContext GetContext<TEntity>(this IQueryable<TEntity> query) where TEntity : class
-      {
-          var objectQuery = query.ToObjectQuery();
-          if (objectQuery != null)
-              return objectQuery.Context;
-
-          return null;
-      }
-
-  }
+    public static class ObjectQueryExtensions
+    {
+        /// <summary>
+        /// Get the SQL that the query will run, along with the parameter values
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <param name="query">The query to get the SQL for.</param>
+        /// <returns>The SQL that the query will run, along with the parameter values</returns>
+        public static string ToTraceString<TEntity>(this IQueryable<TEntity> query) where TEntity : class
+        {
+            var sb = new StringBuilder();
+            var objectQuery = query.ToObjectQuery();
+
+            sb.AppendLine(query.ToString());
+
+            foreach (var parm in objectQuery.Parameters)
+            {
+                sb.AppendFormat("{0}: {1}", parm.Name, parm.Value).AppendLine();
+            }
+
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Convert the query into an ObjectQuery.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <param name="query">The query to convert.</param>
+        /// <returns>The converted ObjectQuery; otherwise null if it can't be converted.</returns>
+        public static ObjectQuery<TEntity> ToObjectQuery<TEntity>(this IQueryable<TEntity> query) where TEntity : class
+        {
+            // first try direct cast
+            var objectQuery = query as ObjectQuery<TEntity>;
+            if (objectQuery != null)
+                return objectQuery;
+
+            // next try case to DbQuery
+            var dbQuery = query as DbQuery<TEntity>;
+
+            // next look for an ObjectQuery property
+            if (dbQuery == null)
+            {
+                var queryType = query.GetType();
+                var prop = queryType.GetProperties().FirstOrDefault(p => p.PropertyType == typeof(ObjectQuery));
+
+                if (prop == null)
+                    return null;
+
+                return (ObjectQuery<TEntity>)prop.GetValue(query, null);
+            }
+
+            // access internal property InternalQuery
+            dynamic dbQueryProxy = new DynamicProxy(dbQuery);
+            dynamic internalQuery = dbQueryProxy.InternalQuery;
+            if (internalQuery == null)
+                return null;
+
+            // access internal property ObjectQuery
+            dynamic objectQueryProxy = internalQuery.ObjectQuery;
+            if (objectQueryProxy == null)
+                return null;
+
+            // convert dynamic to static type
+            objectQuery = objectQueryProxy;
+            return objectQuery;
+        }
+
+        /// <summary>
+        /// Convert the query into an ObjectQuery.
+        /// </summary>
+        /// <param name="query">The query to convert.</param>
+        /// <returns>The converted ObjectQuery; otherwise null if it can't be converted.</returns>
+        public static ObjectQuery ToObjectQuery(this IQueryable query)
+        {
+            // first try direct cast
+            var objectQuery = query as ObjectQuery;
+            if (objectQuery != null)
+                return objectQuery;
+
+            // next try case to DbQuery
+            var dbQuery = query as DbQuery;
+
+            // next look for an ObjectQuery property
+            if (dbQuery == null)
+            {
+                var queryType = query.GetType();
+                var prop = queryType.GetProperties().FirstOrDefault(p => p.PropertyType == typeof(ObjectQuery));
+
+                if (prop == null)
+                    return null;
+
+                return (ObjectQuery)prop.GetValue(query, null);
+            }
+
+            // access internal property InternalQuery
+            dynamic dbQueryProxy = new DynamicProxy(dbQuery);
+            dynamic internalQuery = dbQueryProxy.InternalQuery;
+            if (internalQuery == null)
+                return null;
+
+            // access internal property ObjectQuery
+            dynamic objectQueryProxy = internalQuery.ObjectQuery;
+            if (objectQueryProxy == null)
+                return null;
+
+            // convert dynamic to static type
+            objectQuery = objectQueryProxy;
+            return objectQuery;
+        }
+
+        /// <summary>
+        /// Creates an ObjectQuery from an expression.
+        /// </summary>
+        /// <param name="source">The source.</param>
+        /// <param name="expression">The expression.</param>
+        /// <param name="type">The type.</param>
+        /// <returns>An ObjectQuery created from the expression.</returns>
+        public static ObjectQuery CreateQuery(this IQueryable source, Expression expression, Type type)
+        {
+            // first convert to object query to get the correct provider
+            ObjectQuery sourceQuery = source.ToObjectQuery();
+            if (sourceQuery == null)
+                return null;
+
+            IQueryProvider provider = ((IQueryable)sourceQuery).Provider;
+
+            // create query from expression using internal ObjectQueryProvider
+            dynamic providerProxy = new DynamicProxy(provider);
+            IQueryable expressionQuery = providerProxy.CreateQuery(expression, type);
+            if (expressionQuery == null)
+                return null;
+
+            // convert back to ObjectQuery
+            ObjectQuery resultQuery = expressionQuery.ToObjectQuery();
+            return resultQuery;
+        }
+
+        /// <summary>
+        /// Gets the ObjectContext for the specifed query.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <param name="query">The query.</param>
+        /// <returns>The ObjectContext for the query.</returns>
+        public static ObjectContext GetContext<TEntity>(this IQueryable<TEntity> query) where TEntity : class
+        {
+            var objectQuery = query.ToObjectQuery();
+            if (objectQuery != null)
+                return objectQuery.Context;
+
+            return null;
+        }
+    }
 }