Share dynamic splicing expression expressions component and principle

Objective

LINQ everyone knows that it's good to use it, but there's a problem when you're searching with LINQ, you write that.

1. var query = from the user in db. Set<user> ()
2. where user. Username = = "xxxx"
3. Select User;

OK, it looks good, but If you want to do a dynamic search, • Oh! In fact, the method is still very much, just around the Big Bend

What is dynamic search? By the way, if you make a table page, there is a user name, registration time, rank three columns, you want to implement dynamic combination search, only when the user specified to search by the user name to add the user name this column to search conditions, the traditional SQL is so dry

1. string sql= "select * from user ";
2. if (username!= "")
3. {
4. sql+= " Where username=" +username
5. }

Disclaimer: Just do an example, can not run unimportant! ( the code above must normally be problematic)

Can you do that with LINQ? Uh, To the bottom of this

2. var query = from the user in db. Set<user> ()
4. Select User;
6. var userName = string. Empty;
8. if (! string. Isnullorwhitespace (UserName))
10. {
12. query = query. Where (x = X.username = = Username);
14. }

Yes, it can be, but in the actual project is generally not directly returned to the IQueryable interface, there is no way to do so.

So, the dynamic splicing LINQ came into being, and the Essence of LINQ is the expression tree, and you can see the signature of the where extension method of IQueryable, which begins with expression.

Introduction and use of components

The original purpose of encapsulation is also for self-use. I'm lazy, so I'm going to make the components as simple as possible, here's a complete example of use

2. Testdatacontext db = new testdatacontext ();
4. var builder = new expressionbuilder<user> ();//Instantiate component, User what is said below
6. var filters = New list<sqlfilter> ();
8. Filters. ADD (Sqlfilter.create ("Id", operation.equal, 1)); Add a search condition where the user's id attribute value equals 1
10. Filters. ADD (Sqlfilter.create ("lastlogindate", Operation.greaterthan, DateTime.Now));// Add user's Lastlogindate property value is greater than the current search criteria
12. Filters. Add (Sqlfilter.create ("Username", Operation.like, "aaaa"));//Adding the user's Username attribute value to the search criteria like "AAAAA"
14. Filters. Add (Sqlfilter.create ("ID", operation.in, new int[] {1, 2, 3}));//Add user's Id attribute value at 1, 2, 3 search conditions, when operation is in, the last argument must be a collection
16. Filters. ADD (Sqlfilter.create ("Password", Operation.notequal, "1"));
18. Filters. ADD (Sqlfilter.create ("Status", operation.in, new int[] {1}));
20. var where = Builder. Build (filters, new dictionary<string, string> ());//According to the above conditions, splicing out the expression tree
22. var results = db. Set<user> (). where (where). ToList ();//The Earth people know

The above code is spliced out the expression tree is like this

1. var ids=new int[]{1,2,3};
2. var status=new int[]{1};
3. Db. Set<user> (). Where (x = x.id = = 1 && x.lastlogindate > DateTime.Now && ids. Contains (x.id) && x.username.contains ("aaaa") && X.password! = "1" && status . Contains (X.status));

The comments have been made clear, but lines 2nd and 10th need to be explained in particular, and the build method for line 10th is prototyped as follows

1. Public Expression<func<tparameter, bool>> Build (ilist<sqlfilter> filters, dictionary< String, string> Filternamemap)

The return value is a expression<func<tparameter,bool>> type, which has a generic parameter, which is the user when the 2nd row is instantiated, and when used, You must ensure that the attributes of each search condition that you add are in the user class.

Why design it like this? This feeling is not clear at once, when the principle is said

In addition, we can see that there is a filternamemap parameter, which is mainly used for the conversion of property names, and is generally used for foreign keys. Let me briefly describe my design intentions at that time.

For example, there is a list that shows role information in the permissions system, with the role name, description, and functionality of the three columns, where the third column is from the menu and the others are from the role table.

In general, the property name of the third column may be set to privileges, and then the type is string, but if the user wants to search by role-owned functionality, you can't filter by string? It is usually filtered by the function ID, also privilegeid.

Because I'm using ExtJS (skip this section directly), so the question is, ExtJS passed me the parameter name is privileges, the value is a collection, because my Model class property name is this, but my background for filtering the real property is Privilegeid, So I need to map privileges to Privilegeid, and tell ExpressionBuilder that if you encounter the search criteria for the privileges attribute name, change the attribute name to Privilegeid for stitching.

To facilitate understanding, the following is the source of Sqlfilter, very simple

2. Public class Sqlfilter
4. {
6. Public Static Sqlfilter Create (string PropertyName, operation operation, object value)
8. {
10. return New Sqlfilter ()
12. {
14. Name = PropertyName,
16. Operation = operation,
18. Value = value
20. };
22. }
26. // <summary>
28. /// field name
30. // </summary>
32. Public string Name { get; set; }
36. // <summary>
38. /// search operation, greater than or equal to
40. // </summary>
42. Public Xinchen.DbUtils.Operation operation { get; set; }
46. // <summary>
48. /// Search parameter values
50. // </summary>
52. Public Object Value { get; set; }
54. }

Here's the operation.

2. Public enum Operation
4. {
6. GreaterThan,
8. LessThan,
10. Greaterthanorequal,
12. Lessthanorequal,
14. NotEqual,
16. Equal,
18. Like,
20. Inch
22. }

Component principle

I'm not sure I can say it clearly ...

is actually the principle of splicing the expression tree

2. //If we want to splice x=>x.id==1, if the type of x is User
4. var parameterexp = Expression.parameter (typeof(User), "x");
6. //The result is this: X=>,x is the variable name
8. var propertyexp = Expression.property (Parameterexp, "Id");
10. //The result is this: x=>x.id, this sentence is to construct an expression that accesses the property
12. //The first parameter of the above sentence is the object expression you want to take the property to. We want to spell the expression is x=>x.id==1,==1 this piece first regardless, actually is x=>x.id, then actually we are to take the attribute value to x, and X is Parameterexp, so the first parameter is Parameterexp, the second argument say, is the property name
14. var constexp = expression.constant (1);
16. //result is • No result, build a constant expression with a value of 1 (The World of LINQ, Everything is an expression tree)
18. //Right now is the key step.
20. var BODY = expression.equal (propertyexp, constexp);
22. //The result is: X=>x.id==1, this · You need to explain it, it's simple, isn't it? Create an equal expression and pass in the left and right expressions
24. //Of course it doesn't work here, and it needs to continue.
26. var lambda = expression.lambda<func<user, bool>> (body, parameterexp);
28. //This sentence and the second sentence are the most difficult to understand when I learned two places. This is to encapsulate our results into energy, the first parameter is our result, the second parameter is the parameter required to achieve this result, which of course is parameterexp, then the generic parameter func<user,bool> Is that we want to encapsulate this expression into what kind of thing, at this time, the type of lambda is expression<fun<user,bool>>

This is a fairly simple expression tree, and the notes are very well written, and the following is a complex

2. //If we want to splice x=>x.username.contains ("AAA"), if the type of x is User
4. var parameterexp = Expression.parameter (typeof(User), "x");
6. var propertyexp = Expression.property (Parameterexp, "Username");
8. //The above two sentences are no longer introduced
10. var containsmethod = typeof(string). GetMethod ("Contains", new type[] { typeof(string)});
12. //Because we are going to splice an expression that calls the Contains method of the string type username, so the reflection gets the contains method of the string type
14. var constexp = expression.constant ("aaa");
16. //no longer explained
18. var containsexp = Expression.call (Propertyexp, Containsmethod, constexp);
20. The result is: X=>x.username.contains ("AAA"), the first parameter, which is the method to invoke which instance, here is Propertyexp, the second is which method to call, and the third is the argument, which understands the previous example, This should not be difficult to understand .
22. var lambda = expression.lambda<func<user, bool>> (Containsexp, parameterexp);
24. //no longer explained

As you can see, the first sentence takes the user type, so I used generics in the design expressionbuilder for passing this parameter

The principle is here, to see more examples of directly read the source bar

Postscript

Continue advertising ... To understand the relevant technology, please enter QQ group 74522853, the answer XLinq

Share dynamic splicing expression expressions component and principle