链式-父类中返回子类对象

一晃五年没写博客了，依旧再C#上耕耘，依旧没有啥建树，现在也不知道.net上还有多少人再使用，在这里分享一些自己觉得写的还算优雅的代码。

对于自己写着完的代码，我特别喜欢链式（来源于jQuery的影响吧），大部分时候链式就是将返回值为void类型的对象，返回this指针，直到我遇到一个特殊情况——在父类中返回子类类型。大部分情况父类都不知道子类有什么，根本没有返回子类的需求

但是由于链式调用父类的接口返回父类对象，就无法继续链式了。说明可能不清楚，直接show code

 public class OldWhereV2
    {
        protected Expressionbool>> expression = null;

        public OldWhereV2 Where(Expressionbool>> memberExpression)
        {
            return this;
        }

        public OldWhereV2 Or(Expressionbool>> memberExpression)
        {
            return this;
        }

        public OldWhereV2 Add(Expressionbool>> memberExpression)
        {
            return this;
        }
    }

    public class OldQeuryV2 : OldWhereV2
    {

        public OldQeuryV2 Select(Expressionobject>> memberExpression)
        {
            return this;
        }

        public OldQeuryV2 Take(int count)
        {
            return this;
        }

        public OldQeuryV2 Order(Expressionobject>> memberExpression, bool asc)
        {
            return this;
        }
    }

调用的时候，如果使用链式

 var query =new OldQeuryV2()
               .Select(x => x.Apply_Time)
               .Select(x => x.Apply_Time)
               .Select(x => x.Approval_OrgName)
               .Where(x => x.Create_Time > DateTime.Now)
               .Add(x => x.Approval_OrgName == "")
               .Order(x => x.Approval_OrgGID, true)
               .Order(x => x.Apply_Time, false)
               .Take(10);

 .Order(x => x.Approval_OrgGID, true) 这行代码会报错的。因为Where返回的是OldWhereV2类型，而Order方法要求OldQeuryV2类型

 这个问题困扰我一晚，后来我记得在哪里看过一本书，书中有泛型自包含的例子，但是当时完全看不懂，但是此处感觉使用完全没毛病所以就做了简单修改

 public abstract class Condition where M : Condition
    {
        protected Expressionbool>> expression = null;

        public M Where(Expressionbool>> memberExpression)
        {
            expression = memberExpression;
            return (M)this;
        }

        public M Or(Expressionbool>> memberExpression)
        {
            if (expression == null)
            {
                expression = memberExpression;
            }
            else
            {
                var invokedExpr = Expression.Invoke(memberExpression, expression.Parameters.Cast());
                expression = Expression.Lambdabool>>(Expression.OrElse(expression.Body, invokedExpr), expression.Parameters);
            }
            return (M)this;
        }

        public M Add(Expressionbool>> memberExpression)
        {
            if (expression == null)
            {
                expression = memberExpression;
            }
            else
            {
                var invokedExpr = Expression.Invoke(memberExpression, expression.Parameters.Cast());
                expression = Expression.Lambdabool>>(Expression.AndAlso(expression.Body, invokedExpr), expression.Parameters);
            }
            return (M)this;
        }
    }

    public class Qeury : Condition>
    {
        List selects = new List();
        Dictionarybool> orders = new Dictionarybool>();
        int count = 1000;

        public Qeury Select(Expressionobject>> memberExpression)
        {
            MemberInfo memberInfo = memberExpression.GetMemberInfo();
            if (!selects.Contains(memberInfo))
            {
                selects.Add(memberInfo);
            }
            return this;
        }

        public Qeury Take(int count)
        {
            this.count = count;
            return this;
        }

        public Qeury Order(Expressionobject>> memberExpression, bool asc)
        {
            MemberInfo memberInfo = memberExpression.GetMemberInfo();
            if (orders.ContainsKey(memberInfo))
            {
                orders[memberInfo] = asc;
            }
            else
            {
                orders.Add(memberInfo, asc);
            }
            return this;
        }

        public string QeurySql()
        {
            var queryInfo = new QueryInfo()
            {
                WhereExpression = this.expression,
                SelectFields = this.selects,
                Orders = this.orders,
                Count = this.count
            };

            return TableAnalysis.GetTableInfo(typeof(T)).QeurySql(queryInfo);
        }
    }

这里将Condition类修改为Condition 而M是Condition的子类，返回的时候只需要返回M类型就好了，当然由于Condition返回了子类，所以我把它设置成了抽象类，但是也可以不用。由于Qeury :实现了Condition>，所以子类就可以正常调用父类的方法了。

具体例子如下：

var query =new Qeury()
               .Select(x => x.Apply_Time)
               .Select(x => x.Apply_Time)
               .Select(x => x.Approval_OrgName)
               .Where(x => x.Create_Time > DateTime.Now)
               .Add(x => x.Approval_OrgName == "")
               .Order(x => x.Approval_OrgGID, true)
               .Order(x => x.Apply_Time, false)
               .Take(10);

这个算是奇技淫巧，发出来给大家看看，不过不链式不久没有烦恼了吗，正常如下面定义就好了

    public class OldCondition
    {
        public void Where(Expressionbool>> memberExpression)
        {

        }

        public void Or(Expressionbool>> memberExpression)
        {

        }

        public void Add(Expressionbool>> memberExpression)
        {

        }
    }

    public class OldQeury : OldCondition
    {
        public void Select(Expressionobject>> memberExpression)
        {

        }

        public void Take(int count)
        {

        }

        public void Order(Expressionobject>> memberExpression, bool asc)
        {

        }
    }