🐴 🍿 🛌🏼 C # में अभिव्यक्ति के पेड़ एक व्युत्पन्न (अभिव्यक्ति ट्री विज़िटर बनाम पैटर्न मिलान) खोजने का एक उदाहरण का उपयोग कर 👩🏼‍🍳 🙌🏿 🥡

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

लेख हमेशा की तरह बनाया गया है - यह वैचारिक ढांचे और परिभाषाओं के साथ शुरू होता है और उदाहरणों और उपयोग के तरीकों के साथ समाप्त होता है। नीचे दी गई सामग्री की तालिका।

अभिव्यक्ति की मूल बातें वृक्षों
की अभिव्यक्ति की अभिव्यक्ति पेड़ की अभिव्यक्तियाँ
प्रकार के
पैटर्न का मिलान
भोले आगंतुक
क्लासिक विज़िटर

खैर, लक्ष्य एक विशिष्ट समाधान लगाने या यह कहने के लिए नहीं है कि एक दूसरे से बेहतर है। मैं आपके मामले में सभी बारीकियों को ध्यान में रखते हुए खुद निष्कर्ष निकालने का प्रस्ताव करता हूं। मैं अपने उदाहरण पर अपनी राय व्यक्त करूंगा।

अभिव्यक्ति पेड़

मूल बातें

पहले आपको अभिव्यक्ति के पेड़ से निपटने की आवश्यकता है। उनका मतलब एक्सप्रेशन या उसके किसी वारिस से है (बाद में उन पर चर्चा की जाएगी)। सामान्य परिदृश्य में, अभिव्यक्ति / एल्गोरिदम निष्पादन योग्य कोड / निर्देशों के रूप में प्रस्तुत किए जाते हैं, जिनके साथ उपयोगकर्ता को बहुत कुछ नहीं करना पड़ता है (मुख्य रूप से निष्पादित)। अभिव्यक्ति प्रकार आपको एक अभिव्यक्ति / एल्गोरिथ्म (आमतौर पर लैम्ब्डा, लेकिन आवश्यक नहीं) का प्रतिनिधित्व करने की अनुमति देता है क्योंकि एक पेड़ की संरचना में आयोजित डेटा जिसमें उपयोगकर्ता की पहुंच है। एल्गोरिथ्म और कक्षा के नाम के बारे में जानकारी के आयोजन का पेड़ जैसा तरीका हमें "अभिव्यक्ति पेड़" देता है।

स्पष्टता के लिए, हम एक सरल उदाहरण का विश्लेषण करेंगे। मान लें कि हमारे पास लैम्ब्डा

(x) => Console.WriteLine (x + 5)

यह निम्नलिखित पेड़ के रूप में दर्शाया जा सकता है

ट्री की जड़ मेथडकॉल में सबसे ऊपर है , विधि के पैरामीटर भी अभिव्यक्ति हैं, इसलिए इसमें किसी भी संख्या में बच्चे हो सकते हैं।

हमारे मामले में, केवल एक वंशज है - " अरिथमेटिकोपरेशन " का शिखर । इसमें यह जानकारी है कि यह किस तरह का ऑपरेशन है और बाएं और दाएं ऑपरेंड भी अभिव्यक्ति हैं। इस तरह के एक शीर्ष पर हमेशा 2 वंशज होंगे।

ऑपरेंड को एक स्थिर ( निरंतर ) और एक पैरामीटर ( पैरामीटर ) द्वारा दर्शाया जाता है । ऐसी अभिव्यक्तियों का कोई वंशज नहीं है।

ये बहुत सरल उदाहरण हैं, लेकिन सार को पूरी तरह से दर्शाते हैं।

अभिव्यक्ति के पेड़ों की मुख्य विशेषता यह है कि उन्हें पार्स किया जा सकता है और एल्गोरिथ्म क्या करना चाहिए, इसके बारे में सभी आवश्यक जानकारी पढ़ें। कुछ दृष्टिकोण से, यह विशेषताओं के विपरीत है। विशेषताएँ व्यवहार के घोषणात्मक विवरण का एक साधन हैं (बहुत सशर्त, लेकिन अंतिम लक्ष्य लगभग समान है)। जबकि अभिव्यक्ति पेड़ डेटा का वर्णन करने के लिए एक फ़ंक्शन / एल्गोरिदम का उपयोग कर रहे हैं।

उनका उपयोग, उदाहरण के लिए, इकाई ढांचे के प्रदाताओं में किया जाता है । आवेदन स्पष्ट है - अभिव्यक्ति के पेड़ को पार्स करने के लिए, यह समझने के लिए कि वहां क्या निष्पादित किया जाना चाहिए और इस विवरण से एसक्यूएल बनाना चाहिए । कम प्रसिद्ध उदाहरण मोकिंग के लिए moq पुस्तकालय हैं । अभिव्यक्ति वृक्षों का उपयोग DLR में भी किया जाता है ।(डायनेमिक भाषा रनटाइम)। कंपाइलर डेवलपर्स एमएसआईएल उत्पन्न करने के बजाय गतिशील प्रकृति और डॉटनेट के बीच संगतता सुनिश्चित करने के लिए उनका उपयोग करते हैं ।

यह भी उल्लेखनीय है कि अभिव्यक्ति के पेड़ अपरिवर्तनीय हैं।

वाक्य - विन्यास

चर्चा के लायक अगली बात वाक्य रचना है। 2 मुख्य तरीके हैं:

अभिव्यक्ति वर्ग के स्थिर तरीकों के माध्यम से अभिव्यक्ति के पेड़ बनाना
अभिव्यक्ति में संकलित लैम्ब्डा अभिव्यक्तियों का उपयोग करना

अभिव्यक्ति कक्षा के स्थैतिक तरीके

अभिव्यक्ति वर्ग के स्थिर तरीकों के माध्यम से अभिव्यक्ति के पेड़ बनाना आमतौर पर कम उपयोग किया जाता है (विशेषकर उपयोगकर्ता के दृष्टिकोण से)। यह बोझिल है, लेकिन काफी सरल है, हमारे पास हमारे
निपटान में बहुत सारी बुनियादी ईंटें हैं, जिनसे आप काफी जटिल
चीजों का निर्माण कर सकते हैं। निर्माण तब से स्थैतिक तरीकों से होता है अभिव्यक्ति निर्माणकर्ताओं के पास एक आंतरिक संशोधक होता है । और इसका मतलब यह नहीं है कि आपको प्रतिबिंब को उजागर करने की आवश्यकता है।

एक उदाहरण के रूप में, मैं ऊपर के उदाहरण से एक अभिव्यक्ति बनाऊंगा :

(x) => Console.WriteLine (x + 5)

ParameterExpression parameter = Expression.Parameter(typeof(double));
ConstantExpression constant = Expression.Constant(5d, typeof(double));
BinaryExpression add = Expression.Add(parameter, constant);
MethodInfo writeLine = typeof(Console).GetMethod(nameof(Console.WriteLine), new[] { typeof(double) });
MethodCallExpression methodCall = Expression.Call(null, writeLine, add);
Expression<Action<double>> expressionlambda = Expression.Lambda<Action<double>>(methodCall, parameter);
Action<double> delegateLambda = expressionlambda.Compile();
delegateLambda(123321);

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

लैंबडा अभिव्यक्ति

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

Expression<Action<double>> write =  => Console.WriteLine( + 5);

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

सामान्य मामले में रूपांतरण सही नहीं है। एक प्रतिनिधि केवल इसे नहीं उठा सकता है और एक अभिव्यक्ति के रूप में खुद को पेश कर सकता है (लेकिन यह अभी भी संभव है)।

सभी मेमनों को अभिव्यक्ति पेड़ों में नहीं बदला जा सकता है। इसमें शामिल है:

युक्त कार्य संचालक
गतिशील योगदान
अतुल्यकालिक
शरीर (ब्रेसिज़) के साथ

double variable;
dynamic dynamic;
Expression<Action> assignment = () => variable = 5; //Compiler error: An expression tree may not contain an assignment operator
Expression<Func<double>> dynamically = () => dynamic; //Compiler error: An expression tree may not contain a dynamic operation
Expression<Func<Task>> asynchon = async () => await Task.CompletedTask; //Compiler error: Async lambda cannot be converted to expresiion trees
Expression<Action> body = () => { }; //Compiler error: A lambda expression with a statement body cannot be converted to an expression tree

भाव के प्रकार

मैं सुझाव देता हूं कि हमारे पास जो अवसर हैं, उनका प्रतिनिधित्व करने के लिए उपलब्ध प्रकारों पर एक त्वरित नज़र डालें वे सभी सिस्टम में हैं

। सरल प्रकार के भावों को मैंने एक संक्षिप्त विवरण के साथ एक टैबलेट में एक साथ रखा।

गतिशील

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

var parameter1 = Expression.Parameter(typeof(object), "name1");
var parameter2 = Expression.Parameter(typeof(object), "name2"); 
var dynamicParam1 = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null);
var dynamicParam2 = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null);
CallSiteBinder csb = Microsoft.CSharp.RuntimeBinder.Binder.BinaryOperation(CSharpBinderFlags.None, ExpressionType.Add, typeof(Program), new[] { dynamicParam1, dynamicParam2 });
var dyno = Expression.Dynamic(csb, typeof(object), parameter1, parameter2);
Expression<Func<dynamic, dynamic, dynamic>> expr = Expression.Lambda<Func<dynamic, dynamic, dynamic>>(dyno, new[] { parameter1, parameter2 });
Func<dynamic, dynamic, dynamic> action = expr.Compile();
var res = action("1", "2");
Console.WriteLine(res); //12
res = action(1, 2);
Console.WriteLine(res); //3

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

अपवाद ब्लॉक को पकड़ते हैं

दूसरी बात जिस पर मैं ध्यान देता हूं वह है ट्रायल / कैच / आखिर / फॉल्ट फंक्शनलिटी, या यों कहें
कि हमारे पास फॉल्ट ब्लॉक तक पहुंच है। यह C # में उपलब्ध नहीं है, लेकिन यह MSIL में है। यह एक प्रकार का
अंतिम एनालॉग है, जिसे किसी अपवाद के मामले में निष्पादित किया जाएगा। नीचे दिए गए उदाहरण में, एक अपवाद फेंक दिया जाएगा, जिसके बाद "हाय" प्रदर्शित किया जाएगा और कार्यक्रम इनपुट की प्रतीक्षा करेगा। उसके बाद ही यह पूरी तरह से गिर जाएगा। मैं उपयोग के लिए इस अभ्यास की सिफारिश नहीं करता हूं।

var throwSmth = Expression.Throw(Expression.Constant(new Exception(), typeof(Exception)));
var log = Expression.Call(null, typeof(Console).GetMethod(nameof(Console.WriteLine), new[] { typeof(string) }), Expression.Constant("Hi", typeof(string)));
var read = Expression.Call(null, typeof(Console).GetMethod(nameof(Console.ReadLine)));
var fault = Expression.TryFault(throwSmth, Expression.Block(new[] { log, read }));
Expression<Action> expr = Expression.Lambda<Action>(fault);
Action compiledExpression = expr.Compile();
compiledExpression();

उपलब्ध अभिव्यक्ति वृक्ष के प्रकार का संक्षिप्त विवरण

तालिका

एक प्रकार	संक्षिप्त वर्णन
मुख्य
अभिव्यक्ति	, . ,
Expression<TDelegate>

BinaryExpression	(+, — )
UnaryExpression	(+, -), throw
ConstantExpression	—
ParameterExpression
MethodCallExpression	, MethodInfo
IndexExpression
BlockExpression	, .

ConditionalExpression	— if-else
LabelTarget	goto
LabelExpression	, . LabelTarget. , GotoExpression, — . void, .
GotoExpression	. . ( .. «break»)
LoopExpression	, «break»
SwitchCase	SwitchExpression
SwitchExpression	switch/case
TryExpression	try/catch/finally/fault
CatchBlock	, ,

ElementInit	IEnumerable. ListInitExpression
ListInitExpression	+
DefaultExpression
NewArrayExpression	+
NewExpression
/
MemberAssignment
MemberBinding	, , ,
MemberExpression	/
MemberInitExpression
MemberListBinding	/
MemberMemberBinding	/ , /

LambdaExpression
InvocationExpression	-
DebugInfoExpression	.
SymbolDocumentInfo	, .
DynamicExpression	( )
RuntimeVariablesExpression	/
TypeBinaryExpression	, (is)

ExpressionVisitor — . .
DynamicExpressionVisitor — DynamicExpression ( VisitDynamic)

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

पैटर्न मिलान

तो, कार्य डेरिवेटिव की गणना करना है। आप निम्नलिखित का अनुमान लगा सकते हैं: विभिन्न प्रकार के कार्यों के लिए व्युत्पन्न खोजने के लिए कुछ नियम हैं - गुणा, भाग, आदि। ऑपरेशन के आधार पर, आपको एक विशिष्ट सूत्र का चयन करना होगा। इस तरह के एक सूत्रीय सूत्रीकरण में, कार्य को आदर्श रूप से स्विच / केस पर रखा जाता है । और भाषा के नवीनतम संस्करण में, हमें स्विच / केस 2.0 या पैटर्न मिलान के साथ प्रस्तुत किया गया था ।

यहाँ कुछ पर चर्चा करना कठिन है। एक हब पर, इतनी मात्रा में कोड बोझिल और खराब पढ़ा जाता है, इसलिए मेरा सुझाव है कि जीथब को देखें । एक व्युत्पन्न के उदाहरण के लिए, यह इस तरह निकला:

उदाहरण

    public class PatterntMatchingDerivative
    {
        private readonly MethodInfo _pow = typeof(Math).GetMethod(nameof(Math.Pow));
        private readonly MethodInfo _log = typeof(Math).GetMethod(nameof(Math.Log), new[] { typeof(double) });
        private readonly ConstantExpression _zero = Expression.Constant(0d, typeof(double));
        private readonly ConstantExpression _one = Expression.Constant(1d, typeof(double));
		
        public Expression<Func<double, double>> ParseDerivative(Expression<Func<double, double>> function)
        {
            return Expression.Lambda<Func<double, double>>(ParseDerivative(function.Body), function.Parameters);
        }

        private Expression ParseDerivative(Expression function) => function switch
        {
            BinaryExpression binaryExpr => function.NodeType switch
            {
                ExpressionType.Add => Expression.Add(ParseDerivative(binaryExpr.Left), ParseDerivative(binaryExpr.Right)),
                ExpressionType.Subtract => Expression.Subtract(ParseDerivative(binaryExpr.Left), ParseDerivative(binaryExpr.Right)),

                ExpressionType.Multiply => (binaryExpr.Left, binaryExpr.Right) switch
		{	
	  	    (ConstantExpression _, ConstantExpression _) => _zero,
		    (ConstantExpression constant, ParameterExpression _) => constant,
		    (ParameterExpression _, ConstantExpression constant) => constant,
		    _ => Expression.Add(Expression.Multiply(ParseDerivative(binaryExpr.Left), binaryExpr.Right), Expression.Multiply(binaryExpr.Left, ParseDerivative(binaryExpr.Right)))
		},

                ExpressionType.Divide => (binaryExpr.Left, binaryExpr.Right) switch
		{
		    (ConstantExpression _, ConstantExpression _) => _zero,
		    (ConstantExpression constant, ParameterExpression parameter) => Expression.Divide(constant, Expression.Multiply(parameter, parameter)),
		    (ParameterExpression _, ConstantExpression constant) => Expression.Divide(_one, constant),
		    _ => Expression.Divide(Expression.Subtract(Expression.Multiply(ParseDerivative(binaryExpr.Left), binaryExpr.Right), Expression.Multiply(binaryExpr.Left, ParseDerivative(binaryExpr.Right))), Expression.Multiply(binaryExpr.Right, binaryExpr.Right))
	        },
            },
            MethodCallExpression methodCall when methodCall.Method == _pow => (methodCall.Arguments[0], methodCall.Arguments[1]) switch
            {
                (ConstantExpression constant, ParameterExpression _) => Expression.Multiply(methodCall, Expression.Call(null, _log, constant)),
                (ParameterExpression param, ConstantExpression constant) => Expression.Multiply(constant, Expression.Call(null, _pow, param, Expression.Constant((double)constant.Value - 1, typeof(double)))),
                (ConstantExpression constant, Expression expression) => Expression.Multiply(Expression.Multiply(ParseDerivative(expression), methodCall), Expression.Call(null, _log, constant)),
             },
             _ => function.NodeType switch
            {
                ExpressionType.Constant => _zero,
                ExpressionType.Parameter => _one,
                _ => throw new OutOfMemoryException("Bitmap best practice")
             }
        };
    }

यह थोड़ा असामान्य लगता है, लेकिन दिलचस्प है। यह लिखने में खुशी हुई - सभी स्थितियां एक पंक्ति में व्यवस्थित रूप से फिट होती हैं।

उदाहरण खुद के लिए बोलता है, आप इसे शब्दों से बेहतर नहीं बता सकते।

भोले आगंतुक

इस तरह के कार्य में, एक अभिव्यक्ति ट्री आगंतुक तुरंत ध्यान में आता है, जो
कि रसोई में फुर्तीली चर्चा करने के लिए शौकीनों के बीच बहुत शोर और थोड़ी सी घबराहट करता है। “डर अज्ञानता नहीं, बल्कि गलत ज्ञान है। यह सच है कि जो सच नहीं है पर विचार करने की तुलना में कुछ भी नहीं जानना बेहतर है। टॉल्स्टॉय के इस अद्भुत वाक्यांश को याद करते हुए, अज्ञानता को स्वीकार करते हुए और Google के समर्थन को सूचीबद्ध करते हुए, आप निम्नलिखित मार्गदर्शिका पा सकते हैं ।

मेरे पास यह लिंक 1949 में "अभिव्यक्ति वृक्ष आगंतुक" क्वेरी के लिए पहला (साइबेरिया के बाद) है।
पहली नज़र में, यह वही है जो हमें चाहिए। लेख का शीर्षक फिट बैठता है कि हम क्या करना चाहते हैं, और उदाहरणों में कक्षाएं प्रत्यय आगंतुक के साथ नामित की जाती हैं ।

डेरिवेटिव के साथ हमारे उदाहरण के लिए सादृश्य द्वारा, लेख की समीक्षा करने और बनाने के बाद, हमें मिलता है:
जीथब के लिए लिंक।

उदाहरण

public class CustomDerivativeExpressionTreeVisitor
    {
        public Expression<Func<double, double>> Visit(Expression<Func<double, double>> function)
        {
            return Expression.Lambda<Func<double, double>>(Visitor.CreateFromExpression(function.Body).Visit(), function.Parameters);
        }
    }

    public abstract class Visitor
    {
        protected static readonly MethodInfo Pow = typeof(Math).GetMethod(nameof(Math.Pow));
        protected static readonly MethodInfo Log = typeof(Math).GetMethod(nameof(Math.Log), new[] { typeof(double) });
        protected readonly ConstantExpression Zero = Expression.Constant(0d, typeof(double));
        protected readonly ConstantExpression One = Expression.Constant(1d, typeof(double));
        public abstract Expression Visit();
        public static Visitor CreateFromExpression(Expression node)
            => node switch
            {
                BinaryExpression be => new BinaryVisitor(be),
                MethodCallExpression mce when mce.Method == Pow => new PowMethodCallVisitor(mce),
                _ => new SimpleVisitor(node),
            };
        
    }

    public class BinaryVisitor : Visitor
    {
        private readonly BinaryExpression _node;
        
        public BinaryVisitor(BinaryExpression node)
        {
            _node = node;
        }

        public override Expression Visit()
            => _node.NodeType switch
            {
                ExpressionType.Add => Expression.Add(ParseDerivative(binaryExpr.Left), ParseDerivative(binaryExpr.Right)),
                ExpressionType.Subtract => Expression.Subtract(ParseDerivative(binaryExpr.Left), ParseDerivative(binaryExpr.Right)),

                ExpressionType.Multiply => (binaryExpr.Left, binaryExpr.Right) switch
		{	
	  	    (ConstantExpression _, ConstantExpression _) => _zero,
		    (ConstantExpression constant, ParameterExpression _) => constant,
		    (ParameterExpression _, ConstantExpression constant) => constant,
		    _ => Expression.Add(Expression.Multiply(ParseDerivative(binaryExpr.Left), binaryExpr.Right), Expression.Multiply(binaryExpr.Left, ParseDerivative(binaryExpr.Right)))
		},

                ExpressionType.Divide => (binaryExpr.Left, binaryExpr.Right) switch
		{
		    (ConstantExpression _, ConstantExpression _) => _zero,
		    (ConstantExpression constant, ParameterExpression parameter) => Expression.Divide(constant, Expression.Multiply(parameter, parameter)),
		    (ParameterExpression _, ConstantExpression constant) => Expression.Divide(_one, constant),
		    _ => Expression.Divide(Expression.Subtract(Expression.Multiply(ParseDerivative(binaryExpr.Left), binaryExpr.Right), Expression.Multiply(binaryExpr.Left, ParseDerivative(binaryExpr.Right))), Expression.Multiply(binaryExpr.Right, binaryExpr.Right))
	        },
            };
    }

    public class PowMethodCallVisitor : Visitor
    {
        private readonly MethodCallExpression _node;

        public PowMethodCallVisitor(MethodCallExpression node)
        {
            _node = node;
        }

        public override Expression Visit()
            => (_node.Arguments[0], _node.Arguments[1]) switch
            {
                (ConstantExpression constant, ParameterExpression _) => Expression.Multiply(_node, Expression.Call(null, Log, constant)),
                (ParameterExpression param, ConstantExpression constant) => Expression.Multiply(constant, Expression.Call(null, Pow, param, Expression.Constant((double)constant.Value - 1, typeof(double)))),
                (ConstantExpression constant, Expression expression) => Expression.Multiply(Expression.Multiply(CreateFromExpression(expression).Visit(), _node), Expression.Call(null, Log, constant)),
            };
    }

    public class SimpleVisitor : Visitor
    {
        private readonly Expression _node;

        public SimpleVisitor(Expression node)
        {
            _node = node;
        }

        public override Expression Visit()
            => _node.NodeType switch
            {
                ExpressionType.Constant => Zero,
                ExpressionType.Parameter => One,
            };
    }

वास्तव में - हम अलग-अलग वर्गों के लिए स्विच मामलों को फैलाते हैं। उनमें से कोई भी कम नहीं थे, जादू दिखाई नहीं दिया। सभी एक ही मामले, बहुत अधिक लाइनें। और वादा किया गया डबल प्रेषण कहां है?

क्लासिक आगंतुक और दोहरी प्रेषण

यहाँ यह विज़िटर टेम्पलेट के बारे में बताने लायक है , यह विज़िटर भी है , जो एक्सप्रेशन ट्री विज़िटर का आधार है । आइए इसका विश्लेषण अभिव्यक्ति पेड़ के उदाहरण पर करें।

एक दूसरे के लिए, मान लें कि हम अभिव्यक्ति के पेड़ डिजाइन करते हैं। हम उपयोगकर्ताओं को अभिव्यक्ति पेड़ के माध्यम से पुनरावृति करने की क्षमता देना चाहते हैं और, नोड्स (अभिव्यक्ति प्रकार) के आधार पर, कुछ क्रियाएं करते हैं।

पहला विकल्प कुछ नहीं करना है। यही है, उपयोगकर्ताओं को स्विच / केस का उपयोग करने के लिए मजबूर करना। यह इतना बुरा विकल्प नहीं है। लेकिन यहां इस तरह की बारीकियां हैं: हम एक विशेष प्रकार के लिए जिम्मेदार तर्क फैलाते हैं। सीधे शब्दों में कहें, बहुरूपता और आभासी चुनौतियों ( उर्फ देर से बाध्यकारी) रनटाइम के प्रकार की परिभाषा को शिफ्ट करना और इन चेकों को हमारे कोड से हटाना संभव बनाता है। हमारे पास तर्क के लिए पर्याप्त है जो वांछित प्रकार का एक उदाहरण बनाता है, फिर सब कुछ हमारे लिए रनटाइम द्वारा किया जाएगा।

दूसरा विकल्प।स्पष्ट समाधान तर्क को आभासी तरीकों में खींचने के लिए है। प्रत्येक उत्तराधिकारी में आभासी पद्धति को ओवरराइड करके, हम स्विच / केस के बारे में भूल सकते हैं। पॉलिमॉर्फिक कॉल का तंत्र हमारे लिए तय करेगा। मेथड टेबल यहाँ काम करेगा, इसमें ऑफ़सेट द्वारा विधियाँ बताई जाएँगी। लेकिन यह एक पूरे लेख के लिए एक विषय है, तो चलो दूर नहीं किया जाता है। आभासी तरीके हमारी समस्या को हल करने के लिए लगते हैं। लेकिन दुर्भाग्य से, वे एक और निर्माण करते हैं। हमारे कार्य के लिए, हम GetDeriviative () विधि जोड़ सकते हैं। लेकिन अब अभिव्यक्ति कक्षाएं खुद अजीब लगती हैं। हम सभी अवसरों के लिए ऐसे तरीके जोड़ सकते हैं, लेकिन वे कक्षा के सामान्य तर्क के अनुकूल नहीं हैं। और हमने अभी भी उपयोगकर्ताओं के समान कुछ करने का अवसर प्रदान नहीं किया (पर्याप्त तरीके से, निश्चित रूप से)। हमें उपयोगकर्ता को प्रत्येक विशेष प्रकार के तर्क को परिभाषित करने की आवश्यकता है,लेकिन बहुरूपता (जो हमारे लिए उपलब्ध है) को बनाए रखें।

केवल उपयोगकर्ता के ऐसा करने के प्रयास सफल नहीं होंगे।

यह वह जगह है जहाँ असली आगंतुक झूठ बोलता है। बुनियादी प्रकार के पदानुक्रम (हमारे मामले में अभिव्यक्ति) में, हम फॉर्म की एक विधि को परिभाषित करते हैं

virtual Expression Accept(ExpressionVisitor visitor);

वारिसों में, इस पद्धति को ओवरराइड किया जाएगा।

ExpressionVisitor अपने आप में एक आधार वर्ग है जिसमें
हर प्रकार के पदानुक्रम के लिए एक ही हस्ताक्षर के साथ एक आभासी पद्धति है। एक उदाहरण के रूप में ExpressionVisitor वर्ग का उपयोग करना, VisitBinary (...), VisitMethodCall (...), VisitConstant (...), VisitParameter (...)।

इन तरीकों को हमारे पदानुक्रम के संबंधित वर्ग में कहा जाता है।

उन। बाइनरी एक्सप्रेशन क्लास में स्वीकार विधि इस तरह दिखाई देगी:

	
protected internal override Expression Accept(ExpressionVisitor visitor)
{
        return visitor.VisitBinary(this);
}

परिणामस्वरूप, एक नए व्यवहार को परिभाषित करने के लिए, उपयोगकर्ता को केवल अभिव्यक्तिविजिटर वर्ग के लिए एक वारिस बनाने की आवश्यकता होती है, जिसमें एक समस्या को हल करने के लिए संबंधित तरीकों को फिर से परिभाषित किया जाएगा। हमारे मामले में, एक DerivativeExpressionVisitor बनाया गया है।

इसके अलावा, हमारे पास अभिव्यक्ति के उत्तराधिकारियों की कुछ वस्तुएं हैं, लेकिन जो अज्ञात हैं, लेकिन आवश्यक नहीं हैं।
हम वर्चुअल एक्सेप्ट पद्धति को एक्सप्रेशनविजर कार्यान्वयन के साथ कहते हैं जिसकी हमें आवश्यकता है, अर्थात्। DerivativeExpressionVisitor के साथ। डायनेमिक डिस्पैचिंग के लिए धन्यवाद, स्वीकार की ओवरराइड कार्यान्वयन कहा जाता है, जैसे कि रन-टाइम, बाइनरीएक्सप्रेशन कहते हैं। इस पद्धति के शरीर में, हम पूरी तरह से समझते हैं कि हम बाइनरी एक्सप्रेशन में हैं, लेकिन हमें यह पता नहीं है कि कौन सा एक्सप्रेशनविसेसर उत्तराधिकारी हमारे पास आया था। लेकिन जबसे VisitBinary भी आभासी है, हमें जानने की आवश्यकता नहीं है। फिर, हम बस बेस क्लास के संदर्भ में कॉल करते हैं, कॉल गतिशील रूप से (रन टाइम पर) भेजा जाता है और रनटाइम प्रकार के एक ओवरराइड किए गए विजिटबिनरी कार्यान्वयन को कहा जाता है। दोहरे प्रेषण के लिए इतना - "आप इसे करते हैं" की शैली में पिंग-पोंग - "नहीं, आप"।

यह हमें क्या देता है वास्तव में, यह बाहर से आभासी तरीकों को "जोड़ना" संभव बनाता है, नहीं
कक्षा बदल रहा है। यह बहुत अच्छा लगता है, लेकिन इसके डाउनसाइड हैं:

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

लेकिन अभिव्यक्ति के पेड़ की प्रकृति अभिव्यक्तियों के साथ काम करने की बारीकियों के कारण इन लागतों की अनुमति देती है, क्योंकि इस तरह के वर्कअराउंड उनकी मुख्य विशेषताओं में से एक है।
यहां आप ओवरलोडिंग के लिए उपलब्ध सभी तरीकों को देख सकते हैं।

तो, आइए देखें कि यह अंत में कैसा दिखता है।
जीथब से लिंक करें।

उदाहरण

public class BuildinExpressionTreeVisitor : ExpressionVisitor
    {
        private readonly MethodInfo _pow = typeof(Math).GetMethod(nameof(Math.Pow));
        private readonly MethodInfo _log = typeof(Math).GetMethod(nameof(Math.Log), new[] { typeof(double) });
        private readonly ConstantExpression _zero = Expression.Constant(0d, typeof(double));
        private readonly ConstantExpression _one = Expression.Constant(1d, typeof(double));

        public Expression<Func<double, double>> GetDerivative(Expression<Func<double, double>> function)
        {
            return Expression.Lambda<Func<double, double>>(Visit(function.Body), function.Parameters);
        }

        protected override Expression VisitBinary(BinaryExpression binaryExpr)
            => binaryExpr.NodeType switch
            {
                ExpressionType.Add => Expression.Add(Visit(binaryExpr.Left), Visit(binaryExpr.Right)),
                ExpressionType.Subtract => Expression.Subtract(Visit(binaryExpr.Left), Visit(binaryExpr.Right)),

                ExpressionType.Multiply when binaryExpr.Left is ConstantExpression && binaryExpr.Right is ConstantExpression => _zero,
                ExpressionType.Multiply when binaryExpr.Left is ConstantExpression && binaryExpr.Right is ParameterExpression => binaryExpr.Left,
                ExpressionType.Multiply when binaryExpr.Left is ParameterExpression && binaryExpr.Right is ConstantExpression => binaryExpr.Right,
                ExpressionType.Multiply => Expression.Add(Expression.Multiply(Visit(binaryExpr.Left), binaryExpr.Right), Expression.Multiply(binaryExpr.Left, Visit(binaryExpr.Right))),

                ExpressionType.Divide when binaryExpr.Left is ConstantExpression && binaryExpr.Right is ConstantExpression => _zero,
                ExpressionType.Divide when binaryExpr.Left is ConstantExpression && binaryExpr.Right is ParameterExpression => Expression.Divide(binaryExpr.Left, Expression.Multiply(binaryExpr.Right, binaryExpr.Right)),
                ExpressionType.Divide when binaryExpr.Left is ParameterExpression && binaryExpr.Right is ConstantExpression => Expression.Divide(_one, binaryExpr.Right),
                ExpressionType.Divide => Expression.Divide(Expression.Subtract(Expression.Multiply(Visit(binaryExpr.Left), binaryExpr.Right), Expression.Multiply(binaryExpr.Left, Visit(binaryExpr.Right))), Expression.Multiply(binaryExpr.Right, binaryExpr.Right)),
            };

        protected override Expression VisitMethodCall(MethodCallExpression methodCall)
            => (methodCall.Arguments[0], methodCall.Arguments[1]) switch
            {
                (ConstantExpression constant, ParameterExpression _) => Expression.Multiply(methodCall, Expression.Call(null, _log, constant)),
                (ParameterExpression param, ConstantExpression constant) => Expression.Multiply(constant, Expression.Call(null, _pow, param, Expression.Constant((double)constant.Value - 1, typeof(double)))),
                (ConstantExpression constant, Expression expression) => Expression.Multiply(Expression.Multiply(Visit(expression), methodCall), Expression.Call(null, _log, constant)),
            };

        protected override Expression VisitConstant(ConstantExpression _) => _zero;

        protected override Expression VisitParameter(ParameterExpression b) => _one;
    }

जाँच - परिणाम

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

इसी तरह, पदानुक्रम से आगंतुक का समर्थन बहुत विवादास्पद है।

लेकिन मुझे उम्मीद है कि यहां दी गई जानकारी सही विकल्प बनाने के लिए पर्याप्त है।

C # में अभिव्यक्ति के पेड़ एक व्युत्पन्न (अभिव्यक्ति ट्री विज़िटर बनाम पैटर्न मिलान) खोजने का एक उदाहरण का उपयोग कर

अभिव्यक्ति पेड़

मूल बातें

वाक्य - विन्यास

अभिव्यक्ति कक्षा के स्थैतिक तरीके

लैंबडा अभिव्यक्ति

भाव के प्रकार

गतिशील

अपवाद ब्लॉक को पकड़ते हैं

तालिका

पैटर्न मिलान

भोले आगंतुक

क्लासिक आगंतुक और दोहरी प्रेषण

जाँच - परिणाम

More articles: