續接上編，本篇來講講俄羅斯套娃的設計與實作，
首先簡單地完善一下前面提到的例子，代碼如下：
- 測驗物體類
//測驗物體類
public class Table
{
public int A;
public int B;
}- 獨立條件類
//獨立條件：
public class Field
{
public Logical Logical { get; set; } //與其它條件之間的邏輯關系
public Comparer Comparer { get; set; } //條件比較符
public Type DataType { get; set; } //資料型別
public string FieldName { get; set; } //欄位名稱
public object QueryValue { get; set; } //條件值
}- 條件組類
//條件組：
public class Block
{
public Logical Logical { get; set; } //與其它條件組或獨立條件之間的邏輯關系
public List<Field> Fields { get; set;}=new List<Field>();
public List<Block> Blocks { get;set; }=new List<Block>();
}- 列舉
//邏輯
public enum Logical
{
And,
Or,
}
?
//比較
public enum Comparer
{
Equal,
GreatThan,
LessThan,
}
接下來,先構建查詢條件描述器物件，由于例子代碼比較簡略，僅用于方便說明設計思路和方法，如果哪位看官直接拿來實用，請先備好洗澡水，以備從坑里爬出來凈身之用，
代碼簡單就不作多說明了，就是添加一個獨立條件，兩個子組，子組里分別包含兩個獨立條件，以描述等效于
SQL=(Table1.A<3 OR Table1.A=3) Or (Table1.A>5 And Table1.B=3)) OR Table1.B>5的查詢子句，
Block CreaterDescriptor()
{
//SQL: (Table1.A<3 OR Table1.A=3) Or (Table1.A>5 And Table1.B=3)) OR Table1.B>5
var block = new Block() {Logical= Logical.Or};
block.Fields.AddRange(new[]{new Field(){ Comparer= Comparer.GreatThan, DataType= typeof(int), FieldName="B", Logical= Logical.Or, QueryValue=https://www.cnblogs.com/ls0001/p/5}});
block.Blocks.AddRange(new [] {
new Block(){
Logical= Logical.Or,
Fields=new List(new Field[]{
new Field(){ Comparer= Comparer.LessThan, DataType=typeof(int), FieldName="A", QueryValue= https://www.cnblogs.com/ls0001/p/3},
new Field(){ Comparer= Comparer.Equal, DataType=typeof(int), FieldName="A", Logical= Logical.Or, QueryValue= https://www.cnblogs.com/ls0001/p/3}
}),
},
new Block(){
Logical= Logical.Or,
Fields=new List(new Field[]{
new Field(){ Comparer= Comparer.GreatThan, DataType=typeof(int), FieldName="A", QueryValue= https://www.cnblogs.com/ls0001/p/5},
new Field(){ Comparer= Comparer.Equal, DataType=typeof(int), FieldName="B", Logical= Logical.And,QueryValue= https://www.cnblogs.com/ls0001/p/3}
}),
},
});
return block;
} 至此,已經拿到查詢條件描述物件,知道了需要以什么條件進行查詢了,一下步就是如何其轉換為查詢委托，
先來個手動組裝看看上篇的設想能不能行得通，
Expression<Func<Table,bool>> Manual()
{
//SQL: (Table1.A<3 OR Table1.A=3) Or (Table1.A>5 And Table1.B=3)) OR Table1.B>5
//老套路，先包裝
var Table1 = new Table();
var p = Expression.Parameter(typeof(Table), "Table1");
//將5、3這兩個常量包裝成ConstantExpression：
var num5 = Expression.Constant(5, typeof(int));
var num3 = Expression.Constant(3, typeof(int));
//將兩個屬性包裝成MemberExpression，
var a = Expression.PropertyOrField(p, "A");
var b = Expression.PropertyOrField(p, "B");
//構造Table1.A<3:
var ltA3 = Expression.LessThan(a, num3);
//構造Table1.A=3:
var eqA3 = Expression.Equal(a, num3);
//構造Table1.A>5:
var gtA5 = Expression.GreaterThan(a, num5);
//構造Table1.A=5:
var eqB3 = Expression.Equal(b, num3);
//構造Table1.B>5:
var gtB5 = Expression.GreaterThan(b, num5);
//構造Table1.A<3 OR Table1.A=3
var expLtA3orEqA3 = Expression.OrElse(ltA3, eqA3);
//構造Table1.A>5 && Table1.B=3
var expGtA5andEqB3 = Expression.AndAlso(gtA5, eqB3);
//構造(Table1.A<3 OR Table1.A=3) Or (Table1.A>5 And Table1.B=3))
var expGtA5andEqA3_Or_expLtA3orEqA3=Expression.OrElse(expLtA3orEqA3,expGtA5andEqB3);
//(Table1.A<3 OR Table1.A=3) Or (Table1.A>5 And Table1.B=3)) OR Table1.B>5
var result=Expression.OrElse(expGtA5andEqA3_Or_expLtA3orEqA3,gtB5);
//結果要出來了
Expression<Func<Table,bool>> lambda=Expression.Lambda<Func<Table,bool>>(result,p);
return lambda;
}手動組裝好了,來測驗驗證一下:
//測驗方法
void TestLambda(Expression<Func<Table,bool>> lambda)
{
var list = new List<Table>
{
new Table{A=6,B=2},
new Table{A=5,B=6},
new Table{A=2,B=3}
}
;
var my = list.Where(t => lambda.Compile()(t)).ToArray();
var linq = list.Where(t => ((t.A < 3 || t.A == 3) || (t.A > 5 && t.B == 3)) || t.B > 5).ToArray();
Debug.Assert(my.Length == linq.Length);
for (var i = 0; i < my.Length; i++)
{
Debug.Assert(my[i] == linq[i]);
}
Console.WriteLine("Test_Ok");
}
?
?//運行測驗
void Main()
{
var lambda=Manual();
TestLambda(lambda );
}經過上機運行，結果正確，OK！
但是，問題來了，這手動組裝并不簡單，稍不留神就容易寫錯，如果真這么用，就是浪費表情了，那么有沒有自動的，不需要人工干預的方法？必須有，否則本系列文章還有什么可寫的呢？
具體看下面代碼，就不太過啰嗦的解釋了，簡單說明一下思路，拿到一個多層嵌套的條件組之后，先對直接的獨立條件進行LambdaExpression逐個組裝，串聯起來，再逐個組裝子條件組也串聯起來，最后把獨立條件和子組串聯起來，如果子組里還有子組，進行逐層遞回：
Expression<Func<T,bool>> CreaterQueryExpression<T>(Block block)
{
var param=Expression.Parameter(typeof(T),typeof(T).Name);
return Expression.Lambda<Func<T,bool>>(CreateBlockExpr(block),param);
Expression CreateFieldExpr(List<Field> fields)
{
var lastExp=default(Expression);
foreach (var f in fields)
{
var member=Expression.PropertyOrField(param, f.FieldName);
var value=https://www.cnblogs.com/ls0001/p/Expression.Constant(f.QueryValue);
var exp=f.Comparer switch
{
Comparer.GreatThan=>Expression.GreaterThan(member,value),
Comparer.LessThan=>Expression.LessThan(member,value),
_=> Expression.Equal(member,value),
};
if (lastExp != default(Expression))
{
exp= f.Logical switch
{
Logical.Or => Expression.OrElse(lastExp,exp),
_=>Expression.AndAlso(lastExp,exp),
};
}
lastExp=exp;
}
return lastExp;
}
Expression CreateBlockExpr(Block block)
{
var lastExp=default(Expression);
var exp=CreateFieldExpr(block.Fields);
foreach (var sub in block.Blocks)
{
var subExp = CreateBlockExpr(sub);
if (lastExp != default && subExp!=default)
{
subExp = sub.Logical switch
{
Logical.Or => Expression.OrElse(lastExp, subExp),
_ => Expression.AndAlso(lastExp, subExp),
};
}
lastExp=subExp;
}
if (lastExp != default && exp!=default)
{
exp= block.Logical switch
{
Logical.Or => Expression.OrElse(exp, lastExp),
_ => Expression.AndAlso(exp, lastExp),
};
}
return exp;
}
}
?好，委托已經拿到，是否能正確實作查詢意圖呢？來測驗一下：
// 運行測驗
void Main()
{
var lambda=CreaterQueryExpression<Table>(CreaterDescriptor());
TestLambda(lambda);
}經上機運行，結果OK！
- 至此,初步的原型實作已經完成.
- 接下來要做什么呢,是正式編碼開戰呢，還是思考一下，有什么應用場景，有什么優缺點，如果有缺點能不能克服？如果正式開戰可能會遇到些什么問題或困難，要如何解決？
- 敬請等下回分解，隨手點個贊唄，
轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/553609.html
標籤：架構設計
上一篇：基于Expression Lambda運算式樹的通用復雜動態查詢構建器——《構思篇二》已開源
下一篇：返回列表