आइए, प्रक्षेपित तारों के साथ QueryProvider सौदा करने में मदद करें

QueryProvider की विशिष्टता

QueryProvider इससे नहीं निपट सकते:

var result = _context.Humans .Select(x => $"Name: {x.Name} Age: {x.Age}") .Where(x => x != "") .ToList(); 

यह प्रक्षेपित स्ट्रिंग का उपयोग करके किसी भी वाक्य के साथ सौदा नहीं कर सकता है, लेकिन यह आसानी से इससे निपटेगा:

 var result = _context.Humans .Select(x => "Name " + x.Name + " Age " + x.Age) .Where(x => x != "") .ToList(); 

क्लाइंटलेवल्यूशन (क्लाइंट-साइड कैलकुलेशन के लिए अपवाद) को चालू करने के बाद सबसे दर्दनाक बात यह है कि चूंकि सभी ऑटोमैपर प्रोफाइल को प्रक्षेप के लिए सख्ती से विश्लेषण किया जाना चाहिए। आइए जानें कि क्या है और समस्या के हमारे समाधान का प्रस्ताव।

चीजों को ठीक करना

एक्सप्रेशन ट्री में प्रक्षेप इस तरह परिवर्तित होता है (यह ExpressionStringBuilder.ExpressionToString विधि का परिणाम है, यह कुछ नोड्स को छोड़ देता है लेकिन यह ठीक है):

 // boxing is required for x.Age Format("Name:{0} Age:{1}", x.Name, Convert(x.Age, Object))) 

या इस तरह, अगर 3 से अधिक तर्क हैं:

 Format("Name:{0} Age:{1}", new [] {x.Name, Convert(x.Age, Object))) 

हम यह निष्कर्ष निकाल सकते हैं कि प्रदाता को इन मामलों को संसाधित करने के लिए नहीं सिखाया गया था, लेकिन यह इन मामलों को अच्छी तरह से ज्ञात ToString () के साथ लाने के लिए सिखाया जा सकता है, इस तरह से संसाधित किया जाता है:

 ((("Name: " + x.Name) + " Age: ") + Convert(x.Age, Object))) 

मैं एक विज़िटर लिखना चाहता हूं जो एक्सप्रेशन ट्री (विशेष रूप से, MethodCallExpression नोड्स) का पालन करेगा और प्रारूपण विधि को स्थानापन्न के साथ बदल देगा। यदि आप अभिव्यक्ति पेड़ों से परिचित हैं, तो आप जानते हैं कि C # पेड़ को दरकिनार करने के लिए अपने स्वयं के आगंतुक प्रदान करता है - एक्सप्रेशनविजर । रुचि रखने वालों के लिए अधिक जानकारी ।

हम सभी की जरूरत है VisitMethodCall विधि से हटकर और लौटे मूल्य को थोड़ा संशोधित करने के लिए है। विधि पैरामीटर MethodCallExpression प्रकार का होता है, जिसमें विधि के बारे में जानकारी और उसे दिए गए तर्कों को शामिल किया जाता है।

आइए कार्य को कई भागों में विभाजित करें:

1. यह निर्धारित करें कि यह प्रारूप विधि है जो कि VisitMethodCall में आया है;
2. विधि को स्ट्रिंग के संयोजन के साथ बदलें;
3. हमारे पास मौजूद प्रारूप पद्धति के सभी अधिभार संभाल सकते हैं;
4. हमारे आगंतुक को कॉल करने के लिए विस्तार विधि लिखें।

पहला भाग सरल है: प्रारूप विधि में एक्सप्रेशन ट्री में निर्मित 4 अधिभार हैं:

  public static string Format(string format, object arg0) public static string Format(string format, object arg0,object arg1) public static string Format(string format, object arg0,object arg1,object arg2) public static string Format(string format, params object[] args) 

चलो उन्हें निकालने, उनके MethodInfo प्रतिबिंब का उपयोग कर:

 private IEnumerable<MethodInfo> FormatMethods => typeof(string).GetMethods().Where(x => x.Name.Contains("Format")) //first three private IEnumerable<MethodInfo> FormatMethodsWithObjects => FormatMethods .Where(x => x.GetParameters() .All(xx=> xx.ParameterType == typeof(string) || xx.ParameterType == typeof(object))); //last one private IEnumerable<MemberInfo> FormatMethodWithArrayParameter => FormatMethods .Where(x => x.GetParameters() .Any(xx => xx.ParameterType == typeof(object[]))); 

बहुत बढ़िया। अब हम यह निर्धारित कर सकते हैं कि MethodCallExpression में प्रारूप विधि "आया था"।

VisitMethodCall में पेड़ को दरकिनार करते हुए, निम्नलिखित विधियाँ आ सकती हैं:

1. ऑब्जेक्ट तर्क के साथ प्रारूप
2. वस्तु [] तर्क के साथ प्रारूप
3. पूरी तरह से कुछ और।

कस्टम पैटर्न का एक सा मिलान

चूँकि हमारे पास केवल 3 स्थितियाँ हैं, हम उनका उपयोग करके संभाल सकते हैं, लेकिन जब से हम मानते हैं कि हमें भविष्य में इस पद्धति का विस्तार करने की आवश्यकता है, तो सभी मामलों को इस डेटा संरचना में लोड कर देंगे:

 public class PatternMachingStructure { public Func<MethodInfo, bool> FilterPredicate { get; set; } public Func<MethodCallExpression, IEnumerable<Expression>> SelectorArgumentsFunc { get; set; } public Func<MethodCallExpression, IEnumerable<Expression>, Expression> ReturnFunc { get; set; } } var patternMatchingList = new List<PatternMachingStructure>() 

FilterPredicate का उपयोग करके हम यह निर्धारित करते हैं कि हम उन 3 मामलों में से किसके साथ काम कर रहे हैं। SelectorArgumentFunc को फॉर्मेट पद्धति के सभी तर्कों को एकीकृत आकार में लाने के लिए आवश्यक है, ReturnFunc विधि, जो पूर्ण अभिव्यक्ति लौटाएगा।

अब आइए प्रक्षेप को स्थानापन्नता से बदलें, और उसके लिए हमें इस विधि की आवश्यकता होगी:

 private Expression InterpolationToStringConcat(MethodCallExpression node, IEnumerable<Expression> formatArguments) { //picking the first argument //(example : Format("Name: {0} Age: {1}", x.Name,x.Age) -> //"Name: {0} Age: {1}" var formatString = node.Arguments.First(); // going through the pattern from Format method and choosing every // line between the arguments and pass them to the ExpressionConstant method // example:->[Expression.Constant("Name: "),Expression.Constant(" Age: ")] var argumentStrings = Regex.Split(formatString.ToString(),RegexPattern) .Select(Expression.Constant); // merging them with the formatArguments values // example ->[ConstantExpression("Name: "),PropertyExpression(x.Name), // ConstantExpression("Age: "), // ConvertExpression(PropertyExpression(x.Age), Object)] var merge = argumentStrings.Merge(formatArguments, new ExpressionComparer()); // merging like QueryableProvider merges simple lines concatenation // example : -> MethodBinaryExpression //(("Name: " + x.Name) + "Age: " + Convert(PropertyExpression(x.Age),Object)) var result = merge.Aggregate((acc, cur) => Expression.Add(acc, cur, StringConcatMethod)); return result; } 

InterpolationToStringConcat आगंतुक से बुलाया जाएगा, ReturnFunc के पीछे छिपा होगा :

 protected override Expression VisitMethodCall(MethodCallExpression node) { var pattern = patternMatchingList.First(x => x.FilterPredicate(node.Method)); var arguments = pattern.SelectorArgumentsFunc(node); var expression = pattern.ReturnFunc(node, arguments); return expression; } 

अब हमें सभी प्रारूप विधि अधिभार को संभालने के लिए तर्क लिखने की आवश्यकता है। यह बल्कि तुच्छ है और पैटर्न के अंदर स्थित है।

 patternMatchingList = new List<PatternMachingStructure> { // first three Format overloads new PatternMachingStructure { FilterPredicate = x => FormatMethodsWithObjects.Contains(x), SelectorArgumentsFunc = x => x.Arguments.Skip(1), ReturnFunc = InterpolationToStringConcat }, // last Format overload receiving the array new PatternMachingStructure { FilterPredicate = x => FormatMethodWithArrayParameter.Contains(x), SelectorArgumentsFunc = x => ((NewArrayExpression) x.Arguments.Last()) .Expressions, ReturnFunc = InterpolationToStringConcat }, // node.Method != Format new PatternMachingStructure() { FilterPredicate = x => FormatMethods.All(xx => xx != x), SelectorArgumentsFunc = x => x.Arguments, ReturnFunc = (node, _) => base.VisitMethodCall(node) } }; 

तदनुसार, हम पहले सकारात्मक FilterPredicate तक VisitMethodCall पद्धति में उस सूची का अनुसरण करेंगे, फिर तर्कों ( SelectorArgumentFunc ) में कनवर्ट करें और ReturnFunc निष्पादित करें ।

आइए एक विस्तार विधि लिखें जिसे हम प्रक्षेप को बदलने के लिए कॉल कर सकते हैं।

हम एक अभिव्यक्ति प्राप्त कर सकते हैं, इसे विज़िटर को सौंप सकते हैं, और फिर हमारे द्वारा मूल अभिव्यक्ति ट्री की जगह CreateQuery विधि को कॉल कर सकते हैं:

 public static IQueryable<T> ReWrite<T>(this IQueryable<T> qu) { var result = new InterpolationStringReplacer<T>().Visit(qu.Expression); var s = (IQueryable<T>) qu.Provider.CreateQuery(result); return s; } 

अपना ध्यान qu.Provider.CreateQuery (परिणाम) को देने के लिए दें , जिसमें IQueryable <T> में IQueryable विधि है । यह व्यापक रूप से C # के लिए उपयोग किया जाता है ( IEnumerable <T> इंटरफ़ेस देखें!), और यह एक वर्ग के साथ सभी सामान्य इंटरफेस को संभालने की आवश्यकता से आया है जो IQueryable / IEnumerable प्राप्त करना चाहता है, और इसे अन्य इंटरफ़ेस विधियों का उपयोग करके संभालना चाहता है।

टी को एक बेसकलैस (कोवरियन के माध्यम से) तक लाने से हम बच सकते थे, लेकिन यह इंटरफ़ेस के तरीकों पर कुछ सीमाएँ निर्धारित करता है।

परिणाम

लेख के शीर्ष पर linq व्यंजक में पुनः लागू करें:

 var result = _context.Humans .Select(x => $"Name: {x.Name} Age: {x.Age}") .Where(x => x != "") .ReWrite() .ToList(); // correct // [Name: "Piter" Age: 19] 

GitHub