构建属于自己的ORM框架之二--IQueryable的奥秘
上篇文章标题乱起，被吐槽了，这次学乖了。
上篇文章中介绍了如何解析Expression生成对应的SQL语句，以及IQueryable的一些概念，以及我们所搭建的框架的思想等。但还没把它们结合并应用起来。这一篇文章将更黄更暴力，揭露IQueryable在实际使用中延迟加载的实现原理，结合上篇对Expression的解析，我们来实现一个自己的“延迟加载”
如果还不太了解如何解析Expression和IQueryable的一些基本概念，可以先看看我的上篇文章
我们先来做些基本工作，定义一个IDataBase接口，里面可以定义些查询，删除，修改，新增等方法，为了节约时间，我们就定义一个查询和删除的方法，再定义一个获取IQueryable<T>实例的方法
public interface IDataBase { List<T> FindAs<T>(Expression<Func<T, bool>> lambdawhere); int Remove<T>(Expression<Func<T, bool>> lambdawhere); IQueryable<T> Source<T>(); }
再添加一个类DBSql，实现我们上面的IDataBase接口，这个类是负责提供对sql数据库的操作
public class DBSql : IDataBase { public List<T> FindAs<T>(Expression<Func<T, bool>> lambdawhere) { throw new NotImplementedException(); } public int Remove<T>(Expression<Func<T, bool>> lambdawhere) { throw new NotImplementedException(); } public IQueryable<T> Source<T>() { throw new NotImplementedException(); } }
IQueryable<T>
上篇文章中有个朋友的回复对IQueryable的解释十分到位，“IQueryable只存贮条件，不立即运行，从而可以实现延迟加载。”那它是如何存贮条件，如何延迟加载的？
这时我们为了提供 public IQueryable<T> Source<T>() 所需的对象。我们再来建一个SqlQuery类，实现IQueryable<T>。
public class SqlQuery<T> : IQueryable<T> { public IEnumerator<T> GetEnumerator() { throw new NotImplementedException(); } System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw new NotImplementedException(); } public Type ElementType { get { throw new NotImplementedException(); } } public Expression Expression { get { throw new NotImplementedException(); } } public IQueryProvider Provider { get { throw new NotImplementedException(); } } }
看到这里大家都不陌生吧？
GetEnumerator()是IEnumerable<T>里的。有了它我们就能foreach了。有泛型和非泛型版本，所以有2个
Type提供访问当前对象的类型（反正由你定义。。。）
Expression是贮存查询条件的
IQueryProvider简单的翻译过来就是查询提供者，它是负责创建查询条件和执行查询的。我们写一个SqlProvider类来实现它
public class SqlProvider<T> : IQueryProvider { public IQueryable<TElement> CreateQuery<TElement>(Expression expression) { throw new NotImplementedException(); } public IQueryable CreateQuery(Expression expression) { throw new NotImplementedException(); } public TResult Execute<TResult>(Expression expression) { throw new NotImplementedException(); } public object Execute(Expression expression) { throw new NotImplementedException(); } }
CreateQuery是创建查询条件。。
平时我们
IQueryable query=xxx源;
query=query.Where(x=>x.Name=="123");
这时Where方法里做的其实就是将前面query的Expression属性和Where里的(x=>x.Name=="123")相并，并且调用Provider属性里的CreateQuery方法。我们可以把我们的代码改成这样，来看看到底是不是这么回事。
public class DBSql : IDataBase { public IQueryable<T> Source<T>() { return new SqlQuery<T>(); } public List<T> FindAs<T>(Expression<Func<T, bool>> lambdawhere) { throw new NotImplementedException(); } public int Remove<T>(Expression<Func<T, bool>> lambdawhere) { throw new NotImplementedException(); } } public class SqlQuery<T> : IQueryable<T> { private Expression _expression; private IQueryProvider _provider; public SqlQuery() { _provider = new SqlProvider<T>(); _expression = Expression.Constant(this); } public SqlQuery(Expression expression, IQueryProvider provider) { _expression = expression; _provider = provider; } public IEnumerator<T> GetEnumerator() { throw new NotImplementedException(); } System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw new NotImplementedException(); } public Type ElementType { get { return typeof(SqlQuery<T>); } } public Expression Expression { get { return _expression; } } public IQueryProvider Provider { get { return _provider; } } } public class SqlProvider<T> : IQueryProvider { public IQueryable<TElement> CreateQuery<TElement>(Expression expression) { IQueryable<TElement> query = new SqlQuery<TElement>(expression, this); return query; } public IQueryable CreateQuery(Expression expression) { throw new NotImplementedException(); } public TResult Execute<TResult>(Expression expression) { throw new NotImplementedException(); } public object Execute(Expression expression) { throw new NotImplementedException(); } }
public class Staff { public int ID { get; set; } public string Code { get; set; } public string Name { get; set; } public DateTime? Birthday { get; set; } public bool Deletion { get; set; } } static void Main(string[] args) { IDataBase db = new DBSql(); IQueryable<Staff> query = db.Source<Staff>(); string name = "张三"; Expression express = null; query = query.Where(x => x.Name == "赵建华"); express = query.Expression; query = query.Where(x => x.Name == name); express = query.Expression; }
段点打在
public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
每次query.Where都会跑这里来。并且Expression都是前后相并的结果。
到了这一步，相信大家都明白了IQueryable只存贮条件这个概念了吧。
那延迟加载呢？什么时候加载啊！当我们foreach或者ToList/ToArray时啊。这时你想到了什么？GetEnumerator()。在调用GetEnumerator()时。我们再调用Provider里的Execute(Expression)。里面解析Expression，生成SQL语句，通过反射的方式生成实例，再一个个返回回去。完成！下面我直接给代码了。解析Expression的类我也改了，这个更黄更暴力。
public class ResolveExpression { public Dictionary<string, object> Argument; public string SqlWhere; public SqlParameter[] Paras; private int index = 0; /// <summary> /// 解析lamdba，生成Sql查询条件 /// </summary> /// <param name="expression"></param> /// <returns></returns> public void ResolveToSql(Expression expression) { this.index = 0; this.Argument = new Dictionary<string, object>(); this.SqlWhere = Resolve(expression); this.Paras = Argument.Select(x => new SqlParameter(x.Key, x.Value)).ToArray(); } private object GetValue(Expression expression) { if (expression is ConstantExpression) return (expression as ConstantExpression).Value; if (expression is UnaryExpression) { UnaryExpression unary = expression as UnaryExpression; LambdaExpression lambda = Expression.Lambda(unary.Operand); Delegate fn = lambda.Compile(); return fn.DynamicInvoke(null); } if (expression is MemberExpression) { MemberExpression member = expression as MemberExpression; string name = member.Member.Name; var constant = member.Expression as ConstantExpression; if (constant == null) throw new Exception("取值时发生异常" + member); return constant.Value.GetType().GetFields().First(x => x.Name == name).GetValue(constant.Value); } throw new Exception("无法获取值" + expression); } private string Resolve(Expression expression) { if (expression is LambdaExpression) { LambdaExpression lambda = expression as LambdaExpression; expression = lambda.Body; return Resolve(expression); } if (expression is BinaryExpression)//解析二元运算符 { BinaryExpression binary = expression as BinaryExpression; if (binary.Left is MemberExpression) { object value = GetValue(binary.Right); return ResolveFunc(binary.Left, value, binary.NodeType); } if (binary.Left is MethodCallExpression && (binary.Right is UnaryExpression || binary.Right is MemberExpression)) { object value = GetValue(binary.Right); return ResolveLinqToObject(binary.Left, value, binary.NodeType); } } if (expression is UnaryExpression)//解析一元运算符 { UnaryExpression unary = expression as UnaryExpression; if (unary.Operand is MethodCallExpression) { return ResolveLinqToObject(unary.Operand, false); } if (unary.Operand is MemberExpression) { return ResolveFunc(unary.Operand, false, ExpressionType.Equal); } } if (expression is MethodCallExpression)//解析扩展方法 { return ResolveLinqToObject(expression, true); } if (expression is MemberExpression)//解析属性。。如x.Deletion { return ResolveFunc(expression, true, ExpressionType.Equal); } var body = expression as BinaryExpression; if (body == null) throw new Exception("无法解析" + expression); var Operator = GetOperator(body.NodeType); var Left = Resolve(body.Left); var Right = Resolve(body.Right); string Result = string.Format("({0} {1} {2})", Left, Operator, Right); return Result; } /// <summary> /// 根据条件生成对应的sql查询操作符 /// </summary> /// <param name="expressiontype"></param> /// <returns></returns> private string GetOperator(ExpressionType expressiontype) { switch (expressiontype) { case ExpressionType.And: return "and"; case ExpressionType.AndAlso: return "and"; case ExpressionType.Or: return "or"; case ExpressionType.OrElse: return "or"; case ExpressionType.Equal: return "="; case ExpressionType.NotEqual: return "<>"; case ExpressionType.LessThan: return "<"; case ExpressionType.LessThanOrEqual: return "<="; case ExpressionType.GreaterThan: return ">"; case ExpressionType.GreaterThanOrEqual: return ">="; default: throw new Exception(string.Format("不支持{0}此种运算符查找！" + expressiontype)); } } private string ResolveFunc(Expression left, object value, ExpressionType expressiontype) { string Name = (left as MemberExpression).Member.Name; string Operator = GetOperator(expressiontype); string Value = value.ToString(); string CompName = SetArgument(Name, Value); string Result = string.Format("({0} {1} {2})", Name, Operator, CompName); return Result; } private string ResolveLinqToObject(Expression expression, object value, ExpressionType? expressiontype = null) { var MethodCall = expression as MethodCallExpression; var MethodName = MethodCall.Method.Name; switch (MethodName)//这里其实还可以改成反射调用，不用写switch { case "Contains": if (MethodCall.Object != null) return Like(MethodCall); return In(MethodCall, value); case "Count": return Len(MethodCall, value, expressiontype.Value); case "LongCount": return Len(MethodCall, value, expressiontype.Value); default: throw new Exception(string.Format("不支持{0}方法的查找！", MethodName)); } } private string SetArgument(string name, string value) { name = "@" + name; string temp = name; while (Argument.ContainsKey(temp)) { temp = name + index; index = index + 1; } Argument[temp] = value; return temp; } private string In(MethodCallExpression expression, object isTrue) { var Argument1 = expression.Arguments[0]; var Argument2 = expression.Arguments[1] as MemberExpression; var fieldValue = GetValue(Argument1); object[] array = fieldValue as object[]; List<string> SetInPara = new List<string>(); for (int i = 0; i < array.Length; i++) { string Name_para = "InParameter" + i; string Value = array[i].ToString(); string Key = SetArgument(Name_para, Value); SetInPara.Add(Key); } string Name = Argument2.Member.Name; string Operator = Convert.ToBoolean(isTrue) ? "in" : " not in"; string CompName = string.Join(",", SetInPara); string Result = string.Format("{0} {1} ({2})", Name, Operator, CompName); return Result; } private string Like(MethodCallExpression expression) { Expression argument = expression.Arguments[0]; object Temp_Vale = GetValue(argument); string Value = string.Format("%{0}%", Temp_Vale); string Name = (expression.Object as MemberExpression).Member.Name; string CompName = SetArgument(Name, Value); string Result = string.Format("{0} like {1}", Name, CompName); return Result; } private string Len(MethodCallExpression expression, object value, ExpressionType expressiontype) { object Name = (expression.Arguments[0] as MemberExpression).Member.Name; string Operator = GetOperator(expressiontype); string CompName = SetArgument(Name.ToString(), value.ToString()); string Result = string.Format("len({0}){1}{2}", Name, Operator, CompName); return Result; } }
public interface IDataBase { List<T> FindAs<T>(Expression<Func<T, bool>> lambdawhere); int Remove<T>(Expression<Func<T, bool>> lambdawhere); IQueryable<T> Source<T>(); }
namespace Data.DataBase { public class DBSql : IDataBase { private readonly static string ConnectionString = @"Data Source=.;Initial Catalog=btmmcms-Standard;Persist Security Info=True;User ID=sa;Password=sa;"; public IQueryable<T> Source<T>() { return new SqlQuery<T>(); } public List<T> FindAs<T>(Expression<Func<T, bool>> lambdawhere) { using (SqlConnection Conn = new SqlConnection(ConnectionString)) { using (SqlCommand Command = new SqlCommand()) { try { Command.Connection = Conn; Conn.Open(); string sql = string.Format("select * from {0}", typeof(T).Name); if (lambdawhere != null) { ResolveExpression resolve = new ResolveExpression(); resolve.ResolveToSql(lambdawhere); sql = string.Format("{0} where {1}", sql, resolve.SqlWhere); Command.Parameters.AddRange(resolve.Paras); } //为了测试，就在这里打印出sql语句了 Console.WriteLine(sql); Command.CommandText = sql; SqlDataReader dataReader = Command.ExecuteReader(); List<T> ListEntity = new List<T>(); while (dataReader.Read()) { var constructor = typeof(T).GetConstructor(new Type[] { }); T Entity = (T)constructor.Invoke(null); foreach (var item in Entity.GetType().GetProperties()) { var value = dataReader[item.Name]; if (value == null) continue; if (value is DBNull) value = null; item.SetValue(Entity, value, null); } ListEntity.Add(Entity); } if (ListEntity.Count == 0) return null; return ListEntity; } catch (Exception ex) { throw ex; } finally { Conn.Close(); } } } } public int Remove<T>(Expression<Func<T, bool>> lambdawhere) { throw new NotImplementedException(); } } public class SqlQuery<T> : IQueryable<T> { private Expression _expression; private IQueryProvider _provider; public SqlQuery() { _provider = new SqlProvider<T>(); _expression = Expression.Constant(this); } public SqlQuery(Expression expression, IQueryProvider provider) { _expression = expression; _provider = provider; } public IEnumerator<T> GetEnumerator() { var result = _provider.Execute<List<T>>(_expression); if (result == null) yield break; foreach (var item in result) { yield return item; } } System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw new NotImplementedException(); } public Type ElementType { get { return typeof(SqlQuery<T>); } } public Expression Expression { get { return _expression; } } public IQueryProvider Provider { get { return _provider; } } } public class SqlProvider<T> : IQueryProvider { public IQueryable<TElement> CreateQuery<TElement>(Expression expression) { IQueryable<TElement> query = new SqlQuery<TElement>(expression, this); return query; } public IQueryable CreateQuery(Expression expression) { throw new NotImplementedException(); } public TResult Execute<TResult>(Expression expression) { MethodCallExpression methodCall = expression as MethodCallExpression; Expression<Func<T, bool>> result = null; while (methodCall != null) { Expression method = methodCall.Arguments[0]; Expression lambda = methodCall.Arguments[1]; LambdaExpression right = (lambda as UnaryExpression).Operand as LambdaExpression; if (result == null) { result = Expression.Lambda<Func<T, bool>>(right.Body, right.Parameters); } else { Expression left = (result as LambdaExpression).Body; Expression temp = Expression.And(right.Body, left); result = Expression.Lambda<Func<T, bool>>(temp, result.Parameters); } methodCall = method as MethodCallExpression; } var source = new DBSql().FindAs<T>(result); dynamic _temp = source; TResult t = (TResult)_temp; return t; } public object Execute(Expression expression) { throw new NotImplementedException(); } } }
搞定，这时可以改下数据库连接，连到自己的数据库，然后像下面这样，添加一个实体类（要与数据库表对应），就可以使用了
class Program { public class Staff { public int ID { get; set; } public string Code { get; set; } public string Name { get; set; } public DateTime? Birthday { get; set; } public bool Deletion { get; set; } } static void Main(string[] args) { IDataBase db = new DBSql(); IQueryable<Staff> query = db.Source<Staff>(); query = query.Where(x => x.Name == "张三"); foreach (var item in query) { } } }
是不是很简单？
虽然信息量有点大，但慢慢理清并消化，我相信会对你又很大帮助！
