डायनेमिक लाइनक क्वेश्चन या एक्सप्रेशन ट्री

परिचय

Linq to Entity आपको स्थैतिक प्रकार की जाँच के साथ बहुत ही स्पष्ट रूप से जटिल प्रश्न लिखने की अनुमति देता है। लेकिन कभी-कभी आपको प्रश्नों को थोड़ा और गतिशील बनाने की आवश्यकता होती है। उदाहरण के लिए, स्तंभ नाम स्ट्रिंग द्वारा दिए जाने पर छँटाई जोड़ें।
यानी कुछ इस तरह लिखें:

var query = from customer in context.Customers select customer; //!  . query = query.OrderBy("name"); var data = query.ToList(); 

इस मामले में, अभिव्यक्ति पेड़ों का गतिशील निर्माण बचाव में आएगा। सच है, अकेले अभिव्यक्ति पर्याप्त नहीं होगी, आपको टेम्पलेट विधियों को गतिशील रूप से खोजने और निर्माण करने की आवश्यकता होगी। लेकिन यह इतना मुश्किल नहीं है। नीचे विवरण।

जब फ़ील्ड नाम स्ट्रिंग द्वारा दिया जाता है, तो इकाई प्रश्नों के लिए linq को सॉर्ट करें

सामान्य तौर पर, Linq क्वेरी द्वारा लौटाए गए डेटा को व्यवस्थित करने के लिए उपयोग की जाने वाली 4 विधियाँ हैं:

 OrderBy OrderByDescending ThenBy ThenByDescending 

हम एक सामान्यीकृत विधि लिखेंगे जिसमें 3 तर्क होंगे।

 public static IOrderedQueryable<T> ApplyOrder<T>( this IQueryable<T> source, string property, string methodName ) 

कहाँ स्रोत स्रोत IQueriable है जिससे आप ऑर्डर जोड़ना चाहते हैं; संपत्ति - उस संपत्ति का नाम जिसके द्वारा छँटाई की जाती है; MethodName - ऊपर की सूची से आदेश देने की विधि का नाम। बेशक, युद्ध कोड में, ApplyOrder को निजी बनाया गया है, और उपयोगकर्ता विधियों के साथ काम कर रहा है:

 OrderBy (this IQueryable<T> source, string property) OrderByDescending (this IQueryable<T> source, string property) ThenBy (this IQueryable<T> source, string property) ThenByDescending (this IQueryable<T> source, string property) 

जिसे तुच्छ रूप से व्यवस्थित किया जाता है और अंततः ApplyOrder कहते हैं।

 public static IOrderedQueryable<T> ApplyOrder<T>( this IQueryable<T> source, string property, string methodName ) { //   .       x => x.property,      var arg = Expression.Parameter(typeof(T), "x"); //   . x => x.      Expression expr = arg; //      .    property. x => x.property expr = Expression.Property(expr, property); //    ,     var lambda = Expression.Lambda(expr, arg); //   Queryable    methodName.         var method = typeof(Queryable).GetGenericMethod( methodName, //    new[] { typeof(T), expr.Type }, //   new[] { source.GetType(), lambda.GetType() } ); // ,     this  . //..  source.OrderBy(x => x.property); return (IOrderedQueryable<T>)method.Invoke(null, new object[] { source, lambda }); } 

टिप्पणियां समझाती हैं कि क्या हो रहा है। सबसे पहले, एक अभिव्यक्ति ट्री बनाया जाता है जिसमें सॉर्ट किया गया फ़ील्ड एक्सेस किया जाता है। फिर अभिव्यक्ति वृक्ष से एक मेमना बनाया जाता है। अगला, एक छँटाई विधि जो लंबोदर को स्वीकार करने में सक्षम है, का निर्माण किया जाता है। और, अंत में, इस विधि को गतिशील रूप से लॉन्च किया गया है।
यहां सबसे कठिन क्षण एक टेम्पलेट विधि का गतिशील निर्माण है, जिसे एक अलग विस्तार विधि GetGenericMethod में बनाया गया है।

 public static MethodInfo GetGenericMethod( this Type type, string name, Type[] genericTypeArgs, Type[] paramTypes ) { var methods = //     from abstractGenericMethod in type.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static) //   where abstractGenericMethod.Name == name //  generic- where abstractGenericMethod.IsGenericMethod // ,    let pa = abstractGenericMethod.GetParameters() //      where pa.Length == paramTypes.Length //  ,    select abstractGenericMethod.MakeGenericMethod(genericTypeArgs) into concreteGenericMethod //     ,           where concreteGenericMethod.GetParameters().Select(p => p.ParameterType).SequenceEqual(paramTypes, new TestAssignable()) select concreteGenericMethod; //     . return methods.FirstOrDefault(); } 

यहां, नाम विधि के लिए, टाइप क्लास बनाई गई है, और 2 प्रकार की सूचियां हैं। GenericTypeArgs सूची बताती है कि किस प्रकार के लिए एक सार्वभौमिक विधि बनाई जानी चाहिए, और paramTypes उन मापदंडों को दिखाता है कि इस पद्धति को किस प्रकार स्वीकार करना चाहिए। यह सब ओवरलोडिंग के बारे में है, कभी-कभी एक तरीका अलग-अलग हस्ताक्षर के साथ हो सकता है, और हमें सही चुनने की आवश्यकता है। खोज पूरी तरह से सी # अधिभार संकल्प के नियमों के अनुसार नहीं है, यह केवल इस बात पर ध्यान दिया जाता है ताकि आप पारित मूल्यों को विधि के तर्कों को असाइन कर सकें। और फिर, लंबे समय तक नहीं, सोच, शर्तों को संतुष्ट करने वाला पहला अधिभार लिया जाता है। एक विशेष वर्ग TestAssignable द्वारा एक प्रकार के मूल्य को दूसरे को सौंपने की संभावना पर प्रकारों की तुलना।

 private class TestAssignable : IEqualityComparer<Type> { public bool Equals(Type x, Type y) { //    y       x,     return x.IsAssignableFrom(y); } public int GetHashCode(Type obj) { return obj.GetHashCode(); } }      : var context = new Models.TestContext(); var query = from customer in context.Customers select customer; query = query .ApplyOrder("name", "OrderBy") .ApplyOrder("surname", "ThenBy") .ApplyOrder("id", "ThenByDescending"); var data = query.ToList(); 

न्यूनतम संशोधनों के साथ दिखाया गया दृष्टिकोण वस्तुओं के लिए लाइनक के साथ काम करने के लिए IEnumerable <> के लिए अनुकूलित किया जा सकता है।