码迷，mamicode.com
首页 > 其他好文 > 详细

Core源码（五）IQueryable（转）

时间：2019-12-09 13:42:48      阅读：68      评论：0      收藏：0      [点我收藏+]

标签：细节   方法   处理   pil   action   结果   数据结构   相关   复杂   

　　如果要对Iqueryable进行深入的学习，那么对于拉姆达表达式、委托需要有一定了解。这里面拉姆达表达式就是匿名函数的一种写法，而委托我们常用FUNC和ACTION，这个都是对于delegate委托的一种简便写法，具体内容可以参考

C#进阶之路（四）：拉姆达 

C#进阶之路（一）：委托

　　本文介绍IQueryable，本来想自己写篇文章，但是写作过程中，在网上看到了一篇很好的文章，介绍类似内容，就决定不再重复的造轮子了，直接引用下篇内容，大家可以点击下面链接阅读原文。原文100多个赞，非常经典。

再讲IQueryable<T>，揭开表达式树的神秘面纱

 

System.Linq.Expressions

lambda表达式和表达式树的区别：

Lambda表达式：

Func<Student, bool> func = t => t.Name == "农码一生";

表达式树：

Expression<Func<Student, bool>> expression = t => t.Name == "农码一生";

咋一看，没啥区别啊。表达式只是用Expression包了一下而已。那你错了，这只是Microsoft给我们展示的障眼法，我们看编译后的C#代码：

技术图片

　　第一个lambda表达式编译成了匿名函数，第二个表达式树编译成一了一堆我们不认识的东西，远比我们原来写的lambda复杂得多。

结论：

　　我们平时使用的表达式树，是编写的lambda表达式然后编译成的表达式树，也就是说平时一般情况使用的表达式树都是编译器帮我们完成的。（当然，我们可以可以手动的主动的去创表达式树。只是太麻烦，不是必要情况没有谁愿意去干这个苦活呢）

我们来看看表达式树到底有什么神奇的地方：

 技术图片

　　有没有看出点感觉来？Body里面有Right、Left，Right里面又有Right、Left，它们的类型都是继承自Expression。这种节点下面有节点，可以无限附加下去的数据结构我们称为树结构数据。也就是我们的表达式树。

补：上面的Student实体类：

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Address { get; set; }
    public string Sex { get; set; }
}

解析表达式树

　　上面我们看到了所谓的表达式树，其他也没有想象的那么复杂嘛。不就是一个树结构数据嘛。如果我们要实现自己的orm，免不了要解析表达式树。一般说到解析树结构数据都会用到递归算法。下面我们开始解析表达式树。

先定义解析方法：

//表达式解析
public static class AnalysisExpression
{
    public static void VisitExpression(Expression expression)
    {
        switch (expression.NodeType)
        {
            case ExpressionType.Call://执行方法
                MethodCallExpression method = expression as MethodCallExpression;
                Console.WriteLine("方法名:" + method.Method.Name);
                for (int i = 0; i < method.Arguments.Count; i++)
                    VisitExpression(method.Arguments[i]);
                break;
            case ExpressionType.Lambda://lambda表达式
                LambdaExpression lambda = expression as LambdaExpression;
                VisitExpression(lambda.Body);
                break;
            case ExpressionType.Equal://相等比较
            case ExpressionType.AndAlso://and条件运算
                BinaryExpression binary = expression as BinaryExpression;
                Console.WriteLine("运算符:" + expression.NodeType.ToString());
                VisitExpression(binary.Left);
                VisitExpression(binary.Right);
                break;
            case ExpressionType.Constant://常量值
                ConstantExpression constant = expression as ConstantExpression;
                Console.WriteLine("常量值:" + constant.Value.ToString());
                break;
            case ExpressionType.MemberAccess:
                MemberExpression Member = expression as MemberExpression;
                Console.WriteLine("字段名称:{0}，类型:{1}", Member.Member.Name, Member.Type.ToString());
                break;
            default:
                Console.Write("UnKnow");
                break;
        }
    }
}

调用解析方法：

Expression<Func<Student, bool>> expression = t => t.Name == "农码一生" && t.Sex == "男";

AnalysisExpression.VisitExpression(expression);

我们来看看执行过程： 

一层一层的往子节点递归，直到遍历完所有的节点。最后打印效果如下：

 技术图片

基本上我们想要的元素和值都取到了，接着怎么组装就看你自己的心情了。是拼成sql，还是生成url，请随意！

实现自己的IQueryable<T>、IqueryProvider

首先我们看下接口Iqueryable

//
// 摘要:
//     提供针对特定数据源（其中数据类型未指定）评估查询的功能。
public interface IQueryable : IEnumerable
{
    //
    // 摘要:
    //     获取与实例相关联的表达式目录树 System.Linq.IQueryable。
    //
    // 返回结果:
    //     System.Linq.Expressions.Expression 的此实例与该键相关联 System.Linq.IQueryable。
    Expression Expression { get; }
    //
    // 摘要:
    //     获取与此实例关联的表达式树时返回的元素的类型 System.Linq.IQueryable 执行。
    //
    // 返回结果:
    //     一个 System.Type ，表示执行与此对象关联的表达式树时返回的元素的类型。
    Type ElementType { get; }
    //
    // 摘要:
    //     获取与此数据源相关联的查询提供程序。
    //
    // 返回结果:
    //     System.Linq.IQueryProvider 此数据源与该键相关联。
    IQueryProvider Provider { get; }
}

仅仅解析了表达式树就可以捣鼓自己的orm了？不行，起码也要基于IQueryable<T>接口来编码吧。

接着我们自定义个类MyQueryable<T>继承接口IQueryable<T>：

public class MyQueryable<T> : IQueryable<T>
{
    public IEnumerator<T> GetEnumerator()
    {
        throw new NotImplementedException();
    }
    IEnumerator 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(); }
    }
}

　　我们看到其中有个接口属性IQueryProvider，这个接口的作用大着呢，主要作用是在执行查询操作符的时候重新创建IQueryable<T>并且最后遍历的时候执行sql远程取值。我们还看见了Expression属性。

　　现在我们明白了IQueryable<T>和Expression（表达式树）的关系：IQueryable<T>最主要的作用就是用来存储Expression（表达式树）

下面我们也自定义现实了IQueryProvider接口的类MyQueryProvider：

public class MyQueryProvider : 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();
    }
}

上面全是自动生成的伪代码，下面我们来填充具体的实现：

public class MyQueryProvider : IQueryProvider
{
    public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
    {
        return new MyQueryable<TElement>(expression);
    }
    public IQueryable CreateQuery(Expression expression)
    {
        throw new NotImplementedException();
    }
    public TResult Execute<TResult>(Expression expression)
    {
        return default(TResult);
    }
    public object Execute(Expression expression)
    {
        return new List<object>();
    } 
}  
public class MyQueryable<T> : IQueryable<T>
{
    public MyQueryable()
    {
        _provider = new MyQueryProvider();
        _expression = Expression.Constant(this);
    }
    public MyQueryable(Expression expression)
    {
        _provider = new MyQueryProvider();
        _expression = expression;
    }
    public Type ElementType
    {
        get { return typeof(T); }
    }
    private Expression _expression;
    public Expression Expression
    {
        get { return _expression; }
    }
    private IQueryProvider _provider;
    public IQueryProvider Provider
    {
        get { return _provider; }
    }
    public IEnumerator GetEnumerator()
    {
        return (Provider.Execute(Expression) as IEnumerable).GetEnumerator();
    }
    IEnumerator<T> IEnumerable<T>.GetEnumerator()
    {
        var result = _provider.Execute<List<T>>(_expression);
        if (result == null)
            yield break;
        foreach (var item in result)
        {
            yield return item;
        }
    }
}

执行代码：

var aa = new MyQueryable<Student>();
var bb = aa.Where(t => t.Name == "农码一生");
var cc = bb.Where(t => t.Sex == "男");
var dd = cc.AsEnumerable();
var ee = cc.ToList();

结论：

1 每次在执行 Where 查询操作符的时候 IQueryProvider 会为我们创建一个新的 IQueryable<T>

2 调用 AsEnumerable() 方法的时候并不会去实际取值（只是得到一个IEnumerable）[注意：在EF里面查询不要先取IEnumerable后滤筛，因为AsEnumerable()会生成查询全表的sql]

3 执行 ToList() 方法时才去真正调用迭代器 GetEnumerator() 取值

4 真正取值的时候，会去执行 IQueryProvider 中的 Execute 方法。（就是在调用这个方法的时候解析表达式数，然后执行取得结果）

我们看到真正应该办实事的 Execute  我们却让他返回默认值了。

 技术图片

　　现在估计有人不爽了，你到是具体实现下Execute。好吧！（其实通过上面说的解析表达式树，你可以自己在这里做想做的任何事了。）

首先为了简单起见，我们用一个集合做为数据源：

//构造Student数组
public static List<Student> StudentArrary = new List<Student>()
{
        new Student(){Name="农码一生", Age=26, Sex="男", Address="长沙"},
        new Student(){Name="小明", Age=23, Sex="男", Address="岳阳"},
        new Student(){Name="嗨-妹子", Age=25, Sex="女", Address="四川"}
};

然后，重新写一个VisitExpression2方法：（和之前的区别： 现在目的是取表达式树中的表达式，而不是重新组装成sql或别的）

public static void VisitExpression2(Expression expression, ref List<LambdaExpression> lambdaOut)
{
    if (lambdaOut == null)
        lambdaOut = new List<LambdaExpression>();
    switch (expression.NodeType)
    {
        case ExpressionType.Call://执行方法
            MethodCallExpression method = expression as MethodCallExpression;
            Console.WriteLine("方法名:" + method.Method.Name);
            for (int i = 0; i < method.Arguments.Count; i++)
                VisitExpression2(method.Arguments[i], ref  lambdaOut);
            break;
        case ExpressionType.Lambda://lambda表达式
            LambdaExpression lambda = expression as LambdaExpression;
            lambdaOut.Add(lambda);
            VisitExpression2(lambda.Body, ref  lambdaOut);
            break;
        case ExpressionType.Equal://相等比较
        case ExpressionType.AndAlso://and条件运算
            BinaryExpression binary = expression as BinaryExpression;
            Console.WriteLine("运算符:" + expression.NodeType.ToString());
            VisitExpression2(binary.Left, ref  lambdaOut);
            VisitExpression2(binary.Right, ref  lambdaOut);
            break;
        case ExpressionType.Constant://常量值
            ConstantExpression constant = expression as ConstantExpression;
            Console.WriteLine("常量值:" + constant.Value.ToString());
            break;
        case ExpressionType.MemberAccess:
            MemberExpression Member = expression as MemberExpression;
            Console.WriteLine("字段名称:{0}，类型:{1}", Member.Member.Name, Member.Type.ToString());
            break;
        case ExpressionType.Quote:
            UnaryExpression Unary = expression as UnaryExpression;
            VisitExpression2(Unary.Operand, ref  lambdaOut);
            break;
        default:
            Console.Write("UnKnow");
            break;
    }
}

然后重新实现方法Execute：

public TResult Execute<TResult>(Expression expression)
{
    List<LambdaExpression> lambda = null;
    AnalysisExpression.VisitExpression2(expression, ref lambda);//解析取得表达式数中的表达式
    IEnumerable<Student> enumerable = null;
    for (int i = 0; i < lambda.Count; i++)
    {
        //把LambdaExpression转成Expression<Func<Student, bool>>类型
        //通过方法Compile()转成委托方法
        Func<Student, bool> func = (lambda[i] as Expression<Func<Student, bool>>).Compile(); 
        if (enumerable == null)
            enumerable = Program.StudentArrary.Where(func);//取得IEnumerable
        else
            enumerable = enumerable.Where(func);
    }
    dynamic obj = enumerable.ToList();//（注意：这个方法的整个处理过程，你可以换成解析sql执行数据库查询，或者生成url然后请求获取数据。）
    return (TResult)obj;
}

 

个人对 IQueryable 延迟加载的理解：

1 前段部分的查询操作符只是把逻辑分解存入表达式树，并没有远程执行sql。

2 foreache执行的是 IEnumerable<T> ，然而 IEnumerable<T> 同样具有延迟加载的特性。每次迭代的时候才真正的取数据。且在使用导航属性的时候会再次查询数据库。(下次说延迟加载不要忘记了 IEnumerable 的功劳哦！)

小知识：

表达式树转成Lambda表达式：

Expression<Func<Student, bool>> expression = t => t.Name == "码农";

Func<Student, bool> func = expression.Compile();

 

总结：

　　表达式树的分析就告一段落了，其中还有很多细节或重要的没有分析到。下次有新的心得再来总结。

　　感觉表达式树就是先把表达式打散存在树结构里（一般打散的过程是编译器完成），然后可以根据不同的数据源或接口重新组装成自己想要的任何形式，这也让我们实现自己的orm成为了可能。

 

Core源码（五）IQueryable（转）

标签：细节   方法   处理   pil   action   结果   数据结构   相关   复杂   

原文地址：https://www.cnblogs.com/qixinbo/p/12010431.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！