鏈式-父類中返回子類物件

一晃五年沒寫部落格了，依舊再C#上耕耘，依舊沒有啥建樹，現在也不知道.net上還有多少人再使用，在這裡分享一些自己覺得寫的還算優雅的程式碼。

對於自己寫著完的程式碼，我特別喜歡鏈式（來源於jQuery的影響吧），大部分時候鏈式就是將返回值為void型別的物件，返回this指標，直到我遇到一個特殊情況——在父類中返回子類型別。大部分情況父類都不知道子類有什麼，根本沒有返回子類的需求

但是由於鏈式呼叫父類的介面返回父類物件，就無法繼續鏈式了。說明可能不清楚，直接show code

 public class OldWhereV2<T>
    {
        protected Expression<Func<T, bool>> expression = null;

        public OldWhereV2<T> Where(Expression<Func<T, bool>> memberExpression)
        {
            return this;
        }

        public OldWhereV2<T> Or(Expression<Func<T, bool>> memberExpression)
        {
            return this;
        }

        public OldWhereV2<T> Add(Expression<Func<T, bool>> memberExpression)
        {
            return this;
        }
    }

    public class OldQeuryV2<T> : OldWhereV2<T>
    {

        public OldQeuryV2<T> Select(Expression<Func<T, object>> memberExpression)
        {
            return this;
        }

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

        public OldQeuryV2<T> Order(Expression<Func<T, object>> memberExpression, bool asc)
        {
            return this;
        }
    }

呼叫的時候，如果使用鏈式

 var query =new OldQeuryV2<Train>()
               .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<T>型別，而Order方法要求OldQeuryV2<T>型別

 這個問題困擾我一晚，後來我記得在哪裡看過一本書，書中有泛型自包含的例子，但是當時完全看不懂，但是此處感覺使用完全沒毛病所以就做了簡單修改

 public abstract class Condition<T, M> where M : Condition<T, M>
    {
        protected Expression<Func<T, bool>> expression = null;

        public M Where(Expression<Func<T, bool>> memberExpression)
        {
            expression = memberExpression;
            return (M)this;
        }

        public M Or(Expression<Func<T, bool>> memberExpression)
        {
            if (expression == null)
            {
                expression = memberExpression;
            }
            else
            {
                var invokedExpr = Expression.Invoke(memberExpression, expression.Parameters.Cast<Expression>());
                expression = Expression.Lambda<Func<T, bool>>(Expression.OrElse(expression.Body, invokedExpr), expression.Parameters);
            }
            return (M)this;
        }

        public M Add(Expression<Func<T, bool>> memberExpression)
        {
            if (expression == null)
            {
                expression = memberExpression;
            }
            else
            {
                var invokedExpr = Expression.Invoke(memberExpression, expression.Parameters.Cast<Expression>());
                expression = Expression.Lambda<Func<T, bool>>(Expression.AndAlso(expression.Body, invokedExpr), expression.Parameters);
            }
            return (M)this;
        }
    }

    public class Qeury<T> : Condition<T, Qeury<T>>
    {
        List<MemberInfo> selects = new List<MemberInfo>();
        Dictionary<MemberInfo, bool> orders = new Dictionary<MemberInfo, bool>();
        int count = 1000;

        public Qeury<T> Select(Expression<Func<T, object>> memberExpression)
        {
            MemberInfo memberInfo = memberExpression.GetMemberInfo();
            if (!selects.Contains(memberInfo))
            {
                selects.Add(memberInfo);
            }
            return this;
        }

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

        public Qeury<T> Order(Expression<Func<T, object>> 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<T>類修改為Condition<T,M> 而M是Condition<T,M>的子類，返回的時候只需要返回M型別就好了，當然由於Condition返回了子類，所以我把它設定成了抽象類，但是也可以不用。由於Qeury<T> :實現了Condition<T, Qeury<T>>，所以子類就可以正常呼叫父類的方法了。

具體例子如下：

var query =new Qeury<Train>()
               .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<T>
    {
        public void Where(Expression<Func<T, bool>> memberExpression)
        {

        }

        public void Or(Expression<Func<T, bool>> memberExpression)
        {

        }

        public void Add(Expression<Func<T, bool>> memberExpression)
        {

        }
    }

    public class OldQeury<T> : OldCondition<T>
    {
        public void Select(Expression<Func<T, object>> memberExpression)
        {

        }

        public void Take(int count)
        {

        }

        public void Order(Expression<Func<T, object>> memberExpression, bool asc)
        {

        }
    }