क्वेरी करने योग्य प्रदाता को प्रक्षेपित स्ट्रिंग्स को छाँटने में मदद करना

क्वेरी प्रदाता की सूक्ष्मताएं

क्वेरी करने वाला प्रदाता इसे संभाल नहीं सकता:

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(); 

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

हम सही करते हैं

एक्सप्रेशन ट्री में प्रक्षेप का अनुवाद इस तरह किया जाता है (यह एक्सप्रेशनस्ट्रीमिंगबर्ल का परिणाम है। एक्सप्रेशनटॉस्ट्रिंग विधि, यह कुछ नोड्स को छोड़ देता है, लेकिन हमारे लिए यह
घातक नहीं):

 //  x.Age  boxing 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")) //  private IEnumerable<MethodInfo> FormatMethodsWithObjects => FormatMethods .Where(x => x.GetParameters() .All(xx=> xx.ParameterType == typeof(string) || xx.ParameterType == typeof(object))); // 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) { //   //(example : Format("Name: {0} Age: {1}", x.Name,x.Age) -> //"Name: {0} Age: {1}" var formatString = node.Arguments.First(); //      Format    //       ExpressionConstant // example:->[Expression.Constant("Name: "),Expression.Constant(" Age: ")] var argumentStrings = Regex.Split(formatString.ToString(),RegexPattern) .Select(Expression.Constant); //     formatArguments // example ->[ConstantExpression("Name: "),PropertyExpression(x.Name), // ConstantExpression("Age: "), // ConvertExpression(PropertyExpression(x.Age), Object)] var merge = argumentStrings.Merge(formatArguments, new ExpressionComparer()); //  ,  QueryableProvider     // 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 के पीछे छिपा हुआ है
(जब नोड। मीथोड == string.Format)

 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> { //    Format new PatternMachingStructure { FilterPredicate = x => FormatMethodsWithObjects.Contains(x), SelectorArgumentsFunc = x => x.Arguments.Skip(1), ReturnFunc = InterpolationToStringConcat }, //   Format,   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) } }; 

तदनुसार, VisitMethodCall पद्धति में, हम इस शीट के माध्यम से पहले पॉजिटिव FilterPredicate तक जाएंगे, फिर तर्कों (SelectorArgumentFunc) में कनवर्ट करें और ReturnFunc को निष्पादित करें।

आइए, एक्सटेंशन लिखिए, यह कहते हुए कि हम प्रक्षेप को बदल सकते हैं।

हम अभिव्यक्ति प्राप्त कर सकते हैं, इसे अपने आगंतुक को पास कर सकते हैं, और फिर IQuryableProvider 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; } 

कास्ट पर ध्यान दें। IIVable <T> में टाइप IQueryable के Cider..Preatider.CreateQuery (परिणाम), यह आम तौर पर c # के लिए मानक अभ्यास है (IEnumerable <T> देखें), यह एक वर्ग में सभी सामान्य इंटरफेस को संसाधित करने की आवश्यकता के कारण उत्पन्न हुआ। जो IQueryable / IEnumerable को स्वीकार करना चाहता है, और इसे सामान्य इंटरफ़ेस विधियों का उपयोग करके संसाधित करता है।
बेस क्लास में टी को कास्टिंग करने से इसे टाला जा सकता था, यह सहसंयोजक का उपयोग करना संभव है, लेकिन यह इंटरफ़ेस के तरीकों पर कुछ प्रतिबंध भी लगाता है (अगले लेख में इस पर अधिक)।

संपूर्ण

लेख की शुरुआत में अभिव्यक्ति पर ReWrite लागू करें

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

GitHub