如何从IQueryable获取where子句定义为接口

Question

  class Program
{
    static void Main(string[] args)
    {
        var c = new SampleClass<ClassString>();
        c.ClassStrings.Add(new ClassString{ Name1 = "1", Name2 = "1"});
        c.ClassStrings.Add(new ClassString{ Name1 = "2", Name2 = "2"});

        var result = c.Query<ClassString>().Where(s => s.Name1.Equals("2"));

        Console.WriteLine(result);
        Console.ReadLine();
    }
}

public class ClassString
{
    public string Name1 { get; set; }
    public string Name2 { get; set; }
}



public interface ISampleQ
{
    IQueryable<T> Query<T>() where T: class , new();
}
public class SampleClass<X> : ISampleQ
{
    public List<X> ClassStrings { get; private set; }

    public SampleClass()
    {
        ClassStrings = new List<X>();
    }


    public IQueryable<T> Query<T>() where T : class, new()
    {
        //Get the WHERE expression from here.
        return new EnumerableQuery<T>((IEnumerable<T>) ClassStrings);
    }
}

我调查了这个solution1，solution2和solution3似乎不适用于我的问题。由于where子句是在外部定义的，因此它是类的接口。如何在Query方法中获取表达式？因为没有变量通过。

目的是，我希望将检索并注入回目的地（作为IQueryable的DBContext）。因为我们有一个像ISampleQ这样的通用接口。

---

添加了新的示例代码，但情况相同：

 internal class Program
{
    private static void Main(string[] args)
    {
        var oracleDbContext = new OracleDbContext();
        var result = oracleDbContext.Query<Person>().Where(person => person.Name.Equals("username"));

        Console.WriteLine();
        Console.ReadLine();
    }
}

public interface IGenericQuery
{
    IQueryable<T> Query<T>() where T : class , new();
}

public class OracleDbContext : IGenericQuery
{
    public OracleDbContext()
    {
        //Will hold all oracle operations here. For brevity, only
        //Query are exposed.
    }

    public IQueryable<T> Query<T>() where T : class, new()
    {
        //Get the where predicate here. Since the where was defined outside of the
        //class. I want to retrieve since the IQueryable<T> is generic to both class
        //OracleDbContext and MssqlDbContext. I want to re-inject the where or add 
        //new expression before calling.
        //
        //For eg.
        //oracleDbContext.Query<T>(where clause from here)
        return null;
    }
}

public class MssqlDbContext : IGenericQuery
{
    public MssqlDbContext()
    {
        //Will hold all MSSQL operations here. For brevity, only
        //Query are exposed.
    }

    public IQueryable<T> Query<T>() where T : class, new()
    {
        //Get the where predicate here.
        return null;
    }
}

public class Person
{
    public int Id { get; set; }
    public int Name { get; set; }
}

Answer 1

这非常复杂...现在... Queryable.Where()这种方式的工作方式：

public static IQueryable<TSource> Where<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
{
    return source.Provider.CreateQuery<TSource>(Expression.Call(null, ... 

所以Queryable.Where调用source.Provider.CreateQuery()该retuns一个新的IQueryable<>。因此，如果您希望能够在添加过程中“看到” Where()（并对其进行操作），则必须“成为” IQueryable<>.Provider，并拥有CreateQuery()，因此您必须创建一个实现的类IQueryProvider（并且可能要实现的类IQueryable<T>） 。

另一种方法（简单得多）是拥有一个简单的查询“转换器”：一种接受a IQueryable<>并返回一个被操纵的方法IQueryable<>：

var result = c.Query<ClassString>().Where(s => s.Name1.Equals("2")).FixMyQuery();

就像我说的那样，整个路线相当长：

namespace Utilities
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.Data.Entity;
    using System.Data.Entity.Infrastructure;
    using System.Linq;
    using System.Linq.Expressions;
    using System.Reflection;
    using System.Threading;
    using System.Threading.Tasks;

    public class ProxyDbContext : DbContext
    {
        protected static readonly MethodInfo ProxifySetsMethod = typeof(ProxyDbContext).GetMethod("ProxifySets", BindingFlags.Instance | BindingFlags.NonPublic);

        protected static class ProxyDbContexSetter<TContext> where TContext : ProxyDbContext
        {
            public static readonly Action<TContext> Do = x => { };

            static ProxyDbContexSetter()
            {
                var properties = typeof(TContext).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);

                ParameterExpression context = Expression.Parameter(typeof(TContext), "context");

                FieldInfo manipulatorField = typeof(ProxyDbContext).GetField("Manipulator", BindingFlags.Instance | BindingFlags.Public);
                Expression manipulator = Expression.Field(context, manipulatorField);

                var sets = new List<Expression>();

                foreach (PropertyInfo property in properties)
                {
                    if (property.GetMethod == null)
                    {
                        continue;
                    }

                    MethodInfo setMethod = property.SetMethod;
                    if (setMethod != null && !setMethod.IsPublic)
                    {
                        continue;
                    }

                    Type type = property.PropertyType;
                    Type entityType = GetIDbSetTypeArgument(type);

                    if (entityType == null)
                    {
                        continue;
                    }

                    if (!type.IsAssignableFrom(typeof(DbSet<>).MakeGenericType(entityType)))
                    {
                        continue;
                    }

                    Type dbSetType = typeof(DbSet<>).MakeGenericType(entityType);

                    ConstructorInfo constructor = typeof(ProxyDbSet<>)
                        .MakeGenericType(entityType)
                        .GetConstructor(new[] 
                    { 
                        dbSetType, 
                        typeof(Func<bool, Expression, Expression>) 
                    });

                    MemberExpression property2 = Expression.Property(context, property);
                    BinaryExpression assign = Expression.Assign(property2, Expression.New(constructor, Expression.Convert(property2, dbSetType), manipulator));

                    sets.Add(assign);
                }

                Expression<Action<TContext>> lambda = Expression.Lambda<Action<TContext>>(Expression.Block(sets), context);
                Do = lambda.Compile();
            }

            // Gets the T of IDbSetlt;T&gt;
            private static Type GetIDbSetTypeArgument(Type type)
            {
                IEnumerable<Type> interfaces = type.IsInterface ?
                    new[] { type }.Concat(type.GetInterfaces()) :
                    type.GetInterfaces();

                Type argument = (from x in interfaces
                                 where x.IsGenericType
                                 let gt = x.GetGenericTypeDefinition()
                                 where gt == typeof(IDbSet<>)
                                 select x.GetGenericArguments()[0]).SingleOrDefault();
                return argument;
            }
        }

        public readonly Func<bool, Expression, Expression> Manipulator;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="manipulator">First parameter: true for Execute, false for CreateQuery.</param>
        /// <param name="resetSets">True to have all the DbSet&lt;TEntity&gt; and IDbSet&lt;TEntity&gt; proxified</param>
        public ProxyDbContext(Func<bool, Expression, Expression> manipulator, bool resetSets = true)
        {
            Manipulator = manipulator;

            if (resetSets)
            {
                ProxifySetsMethod.MakeGenericMethod(GetType()).Invoke(this, null);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="nameOrConnectionString"></param>
        /// <param name="manipulator">First parameter: true for Execute, false for CreateQuery.</param>
        /// <param name="resetSets">True to have all the DbSet&lt;TEntity&gt; and IDbSet&lt;TEntity&gt; proxified</param>
        public ProxyDbContext(string nameOrConnectionString, Func<bool, Expression, Expression> manipulator, bool resetSets = true)
            : base(nameOrConnectionString)
        {
            Manipulator = manipulator;

            if (resetSets)
            {
                ProxifySetsMethod.MakeGenericMethod(GetType()).Invoke(this, null);
            }
        }

        protected void ProxifySets<TContext>() where TContext : ProxyDbContext
        {
            ProxyDbContexSetter<TContext>.Do((TContext)this);
        }

        public override DbSet<TEntity> Set<TEntity>()
        {
            return new ProxyDbSet<TEntity>(base.Set<TEntity>(), Manipulator);
        }

        public override DbSet Set(Type entityType)
        {
            DbSet set = base.Set(entityType);
            ConstructorInfo constructor = typeof(ProxyDbSetNonGeneric<>)
                .MakeGenericType(entityType)
                .GetConstructor(new[] 
                { 
                    typeof(DbSet), 
                    typeof(Func<bool, Expression, Expression>) 
                });

            return (DbSet)constructor.Invoke(new object[] { set, Manipulator });
        }
    }

    /// <summary>
    /// The DbSet, that is implemented as InternalDbSet&lt&gt; by EF.
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public class ProxyDbSetNonGeneric<TEntity> : DbSet, IQueryable<TEntity>, IEnumerable<TEntity>, IDbAsyncEnumerable<TEntity>, IQueryable, IEnumerable, IDbAsyncEnumerable where TEntity : class
    {
        protected readonly DbSet BaseDbSet;
        protected readonly IQueryable<TEntity> ProxyQueryable;

        public readonly Func<bool, Expression, Expression> Manipulator;

        protected readonly FieldInfo InternalSetField = typeof(DbSet).GetField("_internalSet", BindingFlags.Instance | BindingFlags.NonPublic);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="baseDbSet"></param>
        /// <param name="manipulator">First parameter: true for Execute, false for CreateQuery.</param>
        public ProxyDbSetNonGeneric(DbSet baseDbSet, Func<bool, Expression, Expression> manipulator)
        {
            BaseDbSet = baseDbSet;

            IQueryProvider provider = ((IQueryable)baseDbSet).Provider;
            ProxyDbProvider proxyDbProvider = new ProxyDbProvider(provider, manipulator);

            ProxyQueryable = proxyDbProvider.CreateQuery<TEntity>(((IQueryable)baseDbSet).Expression);
            Manipulator = manipulator;

            if (InternalSetField != null)
            {
                InternalSetField.SetValue(this, InternalSetField.GetValue(baseDbSet));
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="baseDbSet"></param>
        /// <param name="proxyQueryable"></param>
        /// <param name="manipulator">First parameter: true for Execute, false for CreateQuery.</param>
        public ProxyDbSetNonGeneric(DbSet baseDbSet, ProxyQueryable<TEntity> proxyQueryable, Func<bool, Expression, Expression> manipulator)
        {
            BaseDbSet = baseDbSet;

            ProxyQueryable = proxyQueryable;
            Manipulator = manipulator;

            if (InternalSetField != null)
            {
                InternalSetField.SetValue(this, InternalSetField.GetValue(baseDbSet));
            }
        }

        public override object Add(object entity)
        {
            return BaseDbSet.Add(entity);
        }

        public override IEnumerable AddRange(IEnumerable entities)
        {
            return BaseDbSet.AddRange(entities);
        }

        public override DbQuery AsNoTracking()
        {
            return new ProxyDbSetNonGeneric<TEntity>(BaseDbSet, new ProxyQueryable<TEntity>((ProxyDbProvider)ProxyQueryable.Provider, (IQueryable<TEntity>)BaseDbSet.AsNoTracking()), Manipulator);
        }

        [Obsolete]
        public override DbQuery AsStreaming()
        {
#pragma warning disable 618
            return new ProxyDbSetNonGeneric<TEntity>(BaseDbSet, new ProxyQueryable<TEntity>((ProxyDbProvider)ProxyQueryable.Provider, (IQueryable<TEntity>)BaseDbSet.AsStreaming()), Manipulator);
#pragma warning restore 618
        }

        public override object Attach(object entity)
        {
            return BaseDbSet.Attach(entity);
        }

        public override object Create(Type derivedEntityType)
        {
            return BaseDbSet.Create(derivedEntityType);
        }

        public override object Create()
        {
            return BaseDbSet.Create();
        }

        public override object Find(params object[] keyValues)
        {
            return BaseDbSet.Find(keyValues);
        }

        public override Task<object> FindAsync(CancellationToken cancellationToken, params object[] keyValues)
        {
            return BaseDbSet.FindAsync(cancellationToken, keyValues);
        }

        public override Task<object> FindAsync(params object[] keyValues)
        {
            return BaseDbSet.FindAsync(keyValues);
        }

        public override DbQuery Include(string path)
        {
            return new ProxyDbSetNonGeneric<TEntity>(BaseDbSet, new ProxyQueryable<TEntity>((ProxyDbProvider)ProxyQueryable.Provider, (IQueryable<TEntity>)BaseDbSet.Include(path)), Manipulator);
        }

        public override IList Local
        {
            get
            {
                return BaseDbSet.Local;
            }
        }

        public override object Remove(object entity)
        {
            return BaseDbSet.Remove(entity);
        }

        public override IEnumerable RemoveRange(IEnumerable entities)
        {
            return BaseDbSet.RemoveRange(entities);
        }

        public override DbSqlQuery SqlQuery(string sql, params object[] parameters)
        {
            return BaseDbSet.SqlQuery(sql, parameters);
        }

        IEnumerator<TEntity> IEnumerable<TEntity>.GetEnumerator()
        {
            return ProxyQueryable.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)ProxyQueryable).GetEnumerator();
        }

        Type IQueryable.ElementType
        {
            get { return ProxyQueryable.ElementType; }
        }

        Expression IQueryable.Expression
        {
            get { return ProxyQueryable.Expression; }
        }

        IQueryProvider IQueryable.Provider
        {
            get { return ProxyQueryable.Provider; }
        }

        IDbAsyncEnumerator<TEntity> IDbAsyncEnumerable<TEntity>.GetAsyncEnumerator()
        {
            return ((IDbAsyncEnumerable<TEntity>)ProxyQueryable).GetAsyncEnumerator();
        }

        IDbAsyncEnumerator IDbAsyncEnumerable.GetAsyncEnumerator()
        {
            return ((IDbAsyncEnumerable)ProxyQueryable).GetAsyncEnumerator();
        }

        public override string ToString()
        {
            return ProxyQueryable.ToString();
        }
    }

    public class ProxyDbSet<TEntity> : DbSet<TEntity>, IQueryable<TEntity>, IEnumerable<TEntity>, IDbAsyncEnumerable<TEntity>, IQueryable, IEnumerable, IDbAsyncEnumerable where TEntity : class
    {
        protected readonly DbSet<TEntity> BaseDbSet;
        protected readonly IQueryable<TEntity> ProxyQueryable;

        public readonly Func<bool, Expression, Expression> Manipulator;

        protected readonly FieldInfo InternalSetField = typeof(DbSet<TEntity>).GetField("_internalSet", BindingFlags.Instance | BindingFlags.NonPublic);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="baseDbSet"></param>
        /// <param name="manipulator">First parameter: true for Execute, false for CreateQuery.</param>
        public ProxyDbSet(DbSet<TEntity> baseDbSet, Func<bool, Expression, Expression> manipulator)
        {
            BaseDbSet = baseDbSet;

            IQueryProvider provider = ((IQueryable)baseDbSet).Provider;
            ProxyDbProvider proxyDbProvider = new ProxyDbProvider(provider, manipulator);

            ProxyQueryable = proxyDbProvider.CreateQuery<TEntity>(((IQueryable)baseDbSet).Expression);
            Manipulator = manipulator;

            if (InternalSetField != null)
            {
                InternalSetField.SetValue(this, InternalSetField.GetValue(baseDbSet));
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="baseDbSet"></param>
        /// <param name="proxyQueryable"></param>
        /// <param name="manipulator">First parameter: true for Execute, false for CreateQuery.</param>
        public ProxyDbSet(DbSet<TEntity> baseDbSet, ProxyQueryable<TEntity> proxyQueryable, Func<bool, Expression, Expression> manipulator)
        {
            BaseDbSet = baseDbSet;

            ProxyQueryable = proxyQueryable;
            Manipulator = manipulator;

            if (InternalSetField != null)
            {
                InternalSetField.SetValue(this, InternalSetField.GetValue(baseDbSet));
            }
        }

        public override TEntity Add(TEntity entity)
        {
            return BaseDbSet.Add(entity);
        }

        public override IEnumerable<TEntity> AddRange(IEnumerable<TEntity> entities)
        {
            return BaseDbSet.AddRange(entities);
        }

        public override DbQuery<TEntity> AsNoTracking()
        {
            return new ProxyDbSet<TEntity>(BaseDbSet, new ProxyQueryable<TEntity>((ProxyDbProvider)ProxyQueryable.Provider, BaseDbSet.AsNoTracking()), Manipulator);
        }

        [Obsolete]
        public override DbQuery<TEntity> AsStreaming()
        {
#pragma warning disable 618
            return new ProxyDbSet<TEntity>(BaseDbSet, new ProxyQueryable<TEntity>((ProxyDbProvider)ProxyQueryable.Provider, BaseDbSet.AsStreaming()), Manipulator);
#pragma warning restore 618
        }

        public override TEntity Attach(TEntity entity)
        {
            return BaseDbSet.Attach(entity);
        }

        public override TDerivedEntity Create<TDerivedEntity>()
        {
            return BaseDbSet.Create<TDerivedEntity>();
        }

        public override TEntity Create()
        {
            return BaseDbSet.Create();
        }

        public override TEntity Find(params object[] keyValues)
        {
            return BaseDbSet.Find(keyValues);
        }

        public override Task<TEntity> FindAsync(CancellationToken cancellationToken, params object[] keyValues)
        {
            return BaseDbSet.FindAsync(cancellationToken, keyValues);
        }

        public override Task<TEntity> FindAsync(params object[] keyValues)
        {
            return BaseDbSet.FindAsync(keyValues);
        }

        public override DbQuery<TEntity> Include(string path)
        {
            return new ProxyDbSet<TEntity>(BaseDbSet, new ProxyQueryable<TEntity>((ProxyDbProvider)ProxyQueryable.Provider, BaseDbSet.Include(path)), Manipulator);
        }

        public override ObservableCollection<TEntity> Local
        {
            get
            {
                return BaseDbSet.Local;
            }
        }

        public override TEntity Remove(TEntity entity)
        {
            return BaseDbSet.Remove(entity);
        }

        public override IEnumerable<TEntity> RemoveRange(IEnumerable<TEntity> entities)
        {
            return BaseDbSet.RemoveRange(entities);
        }

        public override DbSqlQuery<TEntity> SqlQuery(string sql, params object[] parameters)
        {
            return BaseDbSet.SqlQuery(sql, parameters);
        }

        IEnumerator<TEntity> IEnumerable<TEntity>.GetEnumerator()
        {
            return ProxyQueryable.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)ProxyQueryable).GetEnumerator();
        }

        Type IQueryable.ElementType
        {
            get { return ProxyQueryable.ElementType; }
        }

        Expression IQueryable.Expression
        {
            get { return ProxyQueryable.Expression; }
        }

        IQueryProvider IQueryable.Provider
        {
            get { return ProxyQueryable.Provider; }
        }

        IDbAsyncEnumerator<TEntity> IDbAsyncEnumerable<TEntity>.GetAsyncEnumerator()
        {
            return ((IDbAsyncEnumerable<TEntity>)ProxyQueryable).GetAsyncEnumerator();
        }

        IDbAsyncEnumerator IDbAsyncEnumerable.GetAsyncEnumerator()
        {
            return ((IDbAsyncEnumerable)ProxyQueryable).GetAsyncEnumerator();
        }

        public override string ToString()
        {
            return ProxyQueryable.ToString();
        }

        // Note that the operator isn't virtual! If you do:
        // DbSet<Foo> foo = new ProxyDbSet<Foo>(...)
        // DbSet foo2 = (DbSet)foo;
        // Then you'll have a non-proxed DbSet!
        public static implicit operator ProxyDbSetNonGeneric<TEntity>(ProxyDbSet<TEntity> entry)
        {
            return new ProxyDbSetNonGeneric<TEntity>((DbSet)entry.BaseDbSet, entry.Manipulator);
        }
    }

    public class ProxyDbProvider : IQueryProvider, IDbAsyncQueryProvider
    {
        protected readonly IQueryProvider BaseQueryProvider;
        public readonly Func<bool, Expression, Expression> Manipulator;

        /// <summary>
        /// 
        /// </summary>
        /// <param nam