Hand-written LINQ framework (II: LINQ design ideas)

1. Main design model of LINQ framework

At this point we can see the principle of LINQ dimly, it is not the hanging garden, it has a foundation. Supported by a series of new features above, Microsoft has made the above features interact coherently and form a natural integrated query framework through a large-scale build extension approach. These features are the language for LINQ enhancements, it can also be said that designers are constantly exploring new language features in line with the modern development system, but also more and more support for functional programming features, such as the DLR introduction of Python, Ruby functional scripting language strong support. Other functional scripting languages will increasingly be supported later. Now we are going to focus on the object model. What is an object model? In fact, most of the time, we pay attention to the language level of learning and do not focus on the design principle of the object, resulting in the increasing cost of learning. It is more important for us to learn and develop design ability (so-called design ability reflects technical level). Object model is simply the object design model, how to construct the deep object structure to meet the needs. At present, the main ORM framework on the.net platform, ADO.NET EntityFramework, embodies the role of object model in the design of the conceptual layer of the architecture system. There are many object models worth exploring in the ADO.NET EntityFrameWork and Linq to SQL framework. LINQ is full of extension methods. Behind these extension methods is a big design secret, which is the chained programming model. We will learn the chained programming model in detail to understand why LINQ can use the same method coherently and appear so elegant.

1.1. Chain design mode (design system logic in pipeline-like link mode)

The chain design pattern is a beautiful pattern that has been neglected for a long time. The last time I saw its beauty was when I was studying LINQ and saw the emergence of a continuous extension method, it made me feel really good. In fact, in many cases, we can also use this design mode for reference, which can naturally deal with a lot of tricky problems. The bold design is to use chain mode to artificially recombine the fragmented business algorithm after business fragmentation. If the design is good, it will be a top feast. Since this article is about LINQ, I won’t cover it here, but there will be another article on bold chained business process reengineering. In many cases, when we design a system function or application framework, we can use the chain design mode to elegant our development mode, so that the coding is very smooth and convenient. In order to vividly express the use of chain design mode, HERE I use a relatively simple small example to show its design concept and use.

Example: Suppose I have an object type representing students and a set of students. The student collection type is mainly used to accommodate the student entity. The collection type provides a series of methods to perform continuous operations on the collection. The most common one is the filtering operation. For example, all female students are screened out, and then the list of students over 20 years old is screened out from all the selected female students, and then the list of students from Nanjing, Jiangsu province is continued to be screened. I think LINQ is the most common approach, because LINQ is built for queries, and queries are mostly for collection data.

Object diagram:



In the Student class, we define several basic Student attributes. The important methods in StudentCollection are SelectByFemale method and SelectByMankind method, which are methods to select students as female and male respectively. SelectByAge and SelectByAddress are used to filter ages and addresses, respectively. Because the specific method code is relatively simple, I will not post here, the purpose is to let you can intuitively see the benefits of the chain design pattern and flexible place.

Sample code:

 1 // Construct the Student array
 2 Student[] StudentArrary = new Student[3] 
 3 { 
 4     new Student(){Name="Wang Qingpei", Age=24, Sex="Male", Address="Nanjing, Jiangsu"}, 
 5     new Student(){Name="Chen Yuhe", Age=23, Sex="Female", Address="Yancheng, Jiangsu province"}, 
 6     new Student(){Name="Jinyuan", Age=22, Sex="Female", Address="Huai 'an, Jiangsu"} 
 7 }; 
 8 // Initialize the StudentCollection with the Student array
 9 StudentCollection StudentCollection = new StudentCollection(StudentArrary); 
10 StudentCollection WhereCollection = 
11     StudentCollection.SelectByFemale().// Select all female students
12     SelectByAge(20).// Select a list of students aged 20
13     SelectByAddress("Nanjing, Jiangsu");// Select * from student list whose address is "Nanjing"
Copy the code

Doesn’t it look elegant? I feel elegant and comfortable. One of the things that’s kind of weird about StudentCollection is that each method has to have a return type that makes the next call work, so it has to be the same data type every time. That’s the StudentCollection collection type.

Most of the time, there is a blind spot in our design thinking. That is, every time we return, it has nothing to do with this time. Chain programming seems to find this blind spot and seriously emphasize to us that we should exercise this design blind spot regularly. We use mind maps to analyze the blind spots of chain design, and also look for design benefits that we often overlook.

Mind mapping:



Each method in the figure above has a return return type, but make sure that the type returned can be the operation object of the next method. When designing object methods, you definitely need to break up large procedures into smaller procedures that can be organized. Most of the time when we design the object model is also difficult to think about this, in fact, we are not skilled enough, we need to do more practice and read more books on design, the rest of the time.

1.2. Chain query method (process each working point in query expression step by step)

In the chain design pattern above, we learned that if we build a loop object model, we can use the object collection repeatedly to perform repeated query operations. In fact, LINQ uses this approach as its query principle. Here I will get right to the core design principles of LINQ. LINQ’s chain model is mainly used in the collection of query objects, which are filled with the corresponding query methods of LINQ expressions that can be used by building extension methods on a large area. So how do we understand LINQ queries? LINQ: from *** in *** where *** select *** This is a new query syntax built on top of CTS, handled by an editor, and not in C# or a managed language like VB.NET. In fact, we all know that C#, VB.NET and other syntax are based on. NET platform IL intermediate languages, they are part of the source code, not the final output of the program. IL is the program code that we output each time we compile. The syntax of LINQ is ultimately the syntax of IL, and when we write LINQ query expressions the editor has already intelligently translated them into object methods. Too many principles are introduced in the next section. On the chain query method is also an object design problem, we see the chain design pattern can be very natural to build in line with our own actual needs of the chain query method, this series of query methods to add a big problem is that can not be dynamically added to the object to expand the internal. For example, the published object is not directly modified, so here we use the extension method technology mentioned above, through the extension method we can easily add behavior for the published object. Let’s look at a little example just to reinforce the impression.

Example: Suppose I have a set of published ORM simple components built on. NET2.0, now I need to expand it into a chain query mode, and do not want to use the previous cumbersome query mode. So I need to build a separate one. NET3.0 or. The NET3.5 extension is an extension of the previous assembly. It can be used or not used, so that we can use extension methods or other new syntactic features.

 1 /// <summary> 
 2         ///Get the Base_Deptment object collection based on the existing properties in the Base_Deptment object.
 3         /// </summary> 
 4         /// <param name="model">Base_Deptment instance</param> 
 5         /// <returns>Set of Base_Deptment object instances</returns> 
 6         [ContextLogHandler(OperationSort = 1, OperationExtension = typeof(Dal.LogWrite))] 
 7         public List<Base_Deptment> GetAllListByPropertyValue(Base_Deptment model8)         { 
 9             return ORMHelper.FindEntityList<Base_Deptment>(model); 
10         }
Copy the code

Ormhelper. FindEntityList is a generic method that queries a list of objects based on existing attributes of an entity. If I needed to add additional conditions I would have to add a value for the Base_Deptment type parameter model to use, now I want to extend it to use chained queries via chained design mode, as in:

 1 /// <summary> 
 2         ///Get the Base_Deptment object collection based on the existing properties in the Base_Deptment object.
 3         /// </summary> 
 4         /// <param name="model">Base_Deptment instance</param> 
 5         /// <returns>Set of Base_Deptment object instances</returns> 
 6         [ContextLogHandler(OperationSort = 1, OperationExtension = typeof(Dal.LogWrite))] 
 7         public List<Base_Deptment> GetAllListByPropertyValue(Base_Deptment model8)         { 
 9             Base_Deptment QueryModel = new Base_Deptment(); 
10             var selectList = QueryModel.Select((Base_Deptment Model) => Model.FiledObject.BDeptCode) 
11             .Where((Model) => Model.FiledObject.BDeptCode == "800103848") 
12             .OrderByAscending((Model) => model.FiledObject.BDeptCreateTime); 
13             return selectList; 
14         }
Copy the code

The code here is only understood in context, and it may make a little bit of sense, but it doesn’t make any difference.

This is how you can design an otherwise bloated feature into such an elegant use. I will cover the Linq to CustomEntity implementation in a later article, so I won’t go into the details here. The example itself is meant to show us that chained queries can be used to implement more user-friendly and elegant components or frameworks.

2. The core design principle of LINQ framework

 1 // Construct the Student array
 2 Student[] StudentArrary = new Student[3] 
 3 { 
 4     new Student(){Name="Wang Qingpei", Age=24, Sex="Male", Address="Nanjing, Jiangsu"}, 
 5     new Student(){Name="Chen Yuhe", Age=23, Sex="Female", Address="Yancheng, Jiangsu province"}, 
 6     new Student(){Name="Jinyuan", Age=22, Sex="Female", Address="Huai 'an, Jiangsu"} 
 7 }; 
 8 
 9 var list = StudentArrary.Where((studentModel) => studentModel.Name == "Wang Qingpei").Select((studentModel) => studentModel); 
10 var list = from i in StudentArrary where i.Name == "Wang Qingpei" select i;
Copy the code