अनुप्रयोग अभिव्यक्तियाँ

शुभ दोपहर

हाल ही में किसी और के कोड के माध्यम से देखने पर, मुझे IQueryable और एक्सपोज़र पेड़ों के बारे में एक दिलचस्प समस्या के बारे में पता चला। मुझे उम्मीद है कि समाधान किसी के लिए उपयोगी होगा।

कार्य एक और अभिव्यक्ति के अंदर कुछ अभिव्यक्ति का पुन: उपयोग करने के लिए है, उदाहरण के लिए, हमारे पास कुछ एफ हैं :

Expression<Func<int, int, int>> f = (a, b) => a + b; 

और हम इस f का उपयोग दूसरी अभिव्यक्ति के अंदर करना चाहते हैं, उदाहरण के लिए इस तरह:

 Expression<Func<int, int, int, int>> g = (a, b, c) => f(a+b,b)*c; 

इसके अलावा, यह आवश्यक है कि परिणामी अभिव्यक्ति "शुद्ध" हो, अर्थात्। IQueryable के अंदर उपयोग के लिए उपयुक्त (संकलित कार्यों के बिना, आदि)



यदि आप इन दो पंक्तियों को संकलित करने का प्रयास करते हैं, तो यह पता चलता है कि g की परिभाषा गलत है: 'f' एक 'वैरिएबल' है, लेकिन इसका उपयोग 'मेथड' की तरह किया जाता है , जो सामान्य तौर पर, यह स्पष्ट है कि f अभिव्यक्ति वृक्ष की जड़ है, और न ही यदि कोई फ़ंक्शन या फ़ंक्टर नहीं है। आप इस तरह लिखने की कोशिश कर सकते हैं:

 Expression<Func<int, int, int, int>> g = (a, b, c) => f.Compile()(a+b,b)*c; 

लेकिन तब हमारी अभिव्यक्ति अंततः इस तरह दिखाई देगी:

(a, b, c) => (Invoke(value(ExpressionReducer.Program+<>c__DisplayClass0).f.Compile(), (a + b), b) * c)

स्वाभाविक रूप से, हमारे IQueryable इसे समझ नहीं पाएंगे।

सबसे सरल और स्पष्ट विचार केवल अपने शरीर के लिए f को स्थानापन्न करना है - मोटे तौर पर, g में पद f का "एप्लिकेशन" बनाएं (ईमानदारी से, मैं लैम्ब्डा विलुप्त होने पर बिल्कुल भी मजबूत नहीं हूं, लेकिन मेरी राय में यह बिल्कुल एक आवेदन होगा)।

इस तरह के एक "आवेदन" के लिए, हमें जी ट्री के लिए अभिव्यक्ति ट्री को फिर से लिखना होगा, विशेष रूप से, फ़ंक्शन के शरीर के साथ इनवोक (कंपाइल ()) कॉल को बदलें, और बॉडी में अपने मापदंडों को इनवॉइस तर्कों के मानों से बदलें, अर्थात्: से:

 (a, b, c) => f.Compile()(a+b,b)*c 

पाने के लिए

 (a, b, c) => ((a+b)+b)*c 

आरंभ करने के लिए, आइए हम भारी चालान (संकलन) से छुटकारा पाएं और इसे इस तरह की विस्तार विधि से बदलें:

 public static T Apply<T,T1,T2>(this Expression<Func<T1,T2,T>> expression, T1 t1, T2 t2) { return expression.Compile()(t1, t2); } //... Expression<Func<int, int, int, int>> g = (a, b, c) => f.Apply(a + b, b) * c; 

वास्तव में, लागू फ़ंक्शन का शरीर महत्वपूर्ण नहीं है - यह रूपांतरण के दौरान कभी नहीं बुलाया जाएगा, लेकिन किसी के सरलीकरण के बिना जी का उपयोग करने पर एक वैध निकाय होना उपयोगी है।

अब परिणामस्वरूप पेड़ पर करीब से नज़र डालें:


वास्तव में, यहाँ कदम उठाए जा रहे हैं:

1. कॉल को लागू करने की विधि का पता लगाएं।
2. पहले तर्क से लागू समारोह के लिए लंबो फ़ंक्शन प्राप्त करें।
3. लागू फ़ंक्शन के शेष मापदंडों के साथ लैम्ब्डा बॉडी में तर्कों को बदलें।
4. बदलें। छोटे पेड़ को शरीर f के साथ बदलें।

पहला आइटम करने के लिए पर्याप्त आसान है - हम System.Linq.Expressions नाम स्थान से अभिव्यक्तिविजिटर वर्ग का उपयोग करते हैं। यह एक बहुत ही सुविधाजनक वर्ग है जो आपको न केवल अभिव्यक्ति पेड़ के सभी नोड्स पर जाने की अनुमति देता है, बल्कि इसके कुछ हिस्सों को भी फिर से लिखता है (अधिक जानकारी के लिए http://msdn.microsoft.com/en-us/library/bb546136/28v=vs.90%29.aspx देखें ) हम मानते हैं कि लागू विधि ExpressionReductor वर्ग में है:

 private class InvokerVisitor : ExpressionVisitor { protected override Expression VisitMethodCall(MethodCallExpression node) { if (node.Method.DeclaringType == typeof (ExpressionReductor) && node.Method.Name == "Apply") { //     } return base.VisitMethodCall(node); } } 

दूसरा बिंदु कुछ अधिक जटिल है। जैसा कि आप पेड़ से देख सकते हैं, f ऑटो-जेनरेटेड क्लास ExpressionReducer.Program + <> c__DisplayClass0 का एक क्षेत्र बन गया है - यह है कि C # विधियों के शरीर में घोषित किए गए सभी फंक्शंस या अभिव्यक्तियों के साथ काम करता है या विधि मापदंडों के रूप में आता है। अन्य विकल्पों में से, यह एक नामित वर्ग का एक क्षेत्र या संपत्ति या फ़ंक्शन कॉल का परिणाम है।
सादगी के लिए, हम केवल पहले मामले पर विचार करेंगे (बाकी को समान रूप से लागू किया जा सकता है): एफ एक निश्चित वर्ग का क्षेत्र है।

 class FieldLambdaFinder : ExpressionVisitor { protected override Expression VisitMember(MemberExpression node) { var constantExpression = (ConstantExpression) node.Expression; var info = (FieldInfo) node.Member; var fieldValue = (Expression)info.GetValue(constantExpression.Value); return fieldValue; } public Expression Find(Expression expression) { return Visit(expression); } } 

तीसरा आइटम काफी सरल है - आइए एक शब्दकोश लिखें (पैरामीटर f -> पैरामीटर लागू करें) और f के शरीर में सभी ParameterExpression को प्रतिस्थापित करें:

 internal class Replacer : ExpressionVisitor { private Dictionary<ParameterExpression, Expression> _replacements; public Replacer(IEnumerable<ParameterExpression> what, IEnumerable<Expression> with) { _replacements = what.Zip(with, (param, expr) => new { param, expr }).ToDictionary(x => x.param, x => x.expr); } public Expression Replace(Expression body) { return Visit(body); } protected override Expression VisitParameter(ParameterExpression node) { Expression replacement; return _replacements.TryGetValue(node, out replacement) ? replacement : base.VisitParameter(node); } } 

अंतिम आइटम विधानसभा में सब कुछ दिखाएगा:

 private class InvokerVisitor : ExpressionVisitor { protected override Expression VisitMethodCall(MethodCallExpression node) { if (node.Method.DeclaringType == typeof (ExpressionReductor) && node.Method.Name == "Apply") { var lambda = GetLambda(node.Arguments[0]); return Replace(lambda, node.Arguments.Skip(1)); } return base.VisitMethodCall(node); } private Expression Replace(LambdaExpression lambda, IEnumerable<Expression> arguments) { var replacer = new Replacer(lambda.Parameters, arguments); return replacer.Replace(lambda.Body); } private LambdaExpression GetLambda(Expression expression) { var finder = new FieldLambdaFinder(); return (LambdaExpression) finder.Find(expression); } } 

खुद को सरल बनाने की विधि:

 public static Expression<T> Simplify<T>(this Expression<T> expression) { var invoker = new InvokerVisitor(); return (Expression<T>) invoker.Visit(expression); } 

एक बार में सब कुछ यहाँ पाया जा सकता है ।

नतीजतन, हमें वह मिला जो हम चाहते थे:

 Expression<Func<int, int, int>> f = (a, b) => a + b; Expression<Func<int, int, int, int>> g = (a, b, c) => f.Apply(a + b, b)*c; g = g.Simplify(); 

शेष समस्याएं:

1. अन्य मामलों में एफ कैसे प्राप्त करें।
2. यदि लागू पैरामीटर अन्य कार्यों के लिए कॉल होते हैं जिनके दुष्प्रभाव होते हैं, तो प्रतिस्थापन गलत है। हमारे मामले में, यह नहीं हो सकता है, क्योंकि हम IQueryable के साथ काम कर रहे हैं, लेकिन आपको इसे ध्यान में रखना चाहिए।
3. सरलीकृत फ़ंक्शन गणना को ध्वस्त नहीं करता है: f.Apply (5, 5) सरल करता है (5 + 5), और नहीं (10)।
4. सरलीकृत फ़ंक्शन पुनरावर्ती नहीं है, अर्थात्, ऐसे उदाहरणों पर - f.Apply (a, f.Apply (b, c)) - इसे कई बार कॉल करना होगा।