खुद मैपर या एक्सप्रेशनट्रीस के बारे में थोड़ा

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

त्याग

मैं आपको एक बार फिर याद दिलाता हूं: हम एक आदिम मैपर लिखेंगे। यदि आप अचानक इसे संशोधित करने और इसे ठेस में उपयोग करने का निर्णय लेते हैं - ऐसा न करें। एक तैयार समाधान लें जो इस विषय क्षेत्र में समस्याओं के ढेर को जानता है और पहले से ही उन्हें हल करने का तरीका जानता है। अपनी बाइक मैपर को लिखने और उपयोग करने के कई और कम महत्वपूर्ण कारण हैं:

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

"मैपर" शब्द को क्या कहा जाता है?

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

उपभोक्ता के लिए, मैपर एक सेवा है जो निम्नलिखित इंटरफ़ेस प्रदान करती है:

public interface IMapper<out TOut> { TOut Map(object source); } 

मैं जोर देता हूं: यह सबसे आदिम इंटरफ़ेस है, जो मेरे दृष्टिकोण से, स्पष्टीकरण के लिए सुविधाजनक है। वास्तव में, हम सबसे अधिक विशिष्ट मैपर (IMapper <TIn, Tout>) या एक अधिक सामान्य मुखौटा (IMapper) के साथ काम करेंगे, जो स्वयं निर्दिष्ट प्रकार के इनपुट-आउटपुट ऑब्जेक्ट के लिए एक विशिष्ट मैपर का चयन करेगा।

Naive कार्यान्वयन

नोट: यहां तक ​​कि मैपर के अनुभवहीन कार्यान्वयन के लिए प्रतिबिंब और अभिव्यक्ति के बुनियादी ज्ञान की आवश्यकता होती है। यदि आपने इन तकनीकों के बारे में लिंक का पालन नहीं किया है या कुछ भी नहीं सुना है - इसे करें, इसे पढ़ें। मैं वादा करता हूं कि दुनिया कभी भी एक जैसी नहीं होगी।

हालाँकि, हम आपका अपना मैपर लिख रहे हैं। आरंभ करने के लिए, आइए डेटा प्रकार के सभी गुण ( प्रॉपर्टीइंफो ) प्राप्त करें जो आउटपुट होंगे (इसके बाद मैं इसे TOO ) कहूंगा । यह काफी सरल है: हम प्रकार जानते हैं, चूंकि हम TOUT प्रकार के साथ एक सामान्य वर्ग के कार्यान्वयन को लिख रहे हैं। अगला, प्रकार वर्ग के एक उदाहरण का उपयोग करके, हमें इसके सभी गुण मिलते हैं।

 Type outType = typeof(TOut); PropertyInfo[] outProperties = outType.GetProperties(); 

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

हम और आगे बढ़ें। यह अच्छा होगा कि टाइप टूट का एक उदाहरण बनाया जा सके, यानी, बहुत ही वस्तु जिसमें हम आने वाली वस्तु को "मैप" करते हैं। C # में, इसे करने के कई तरीके हैं। उदाहरण के लिए, हम यह कर सकते हैं: System.Activator.CreateInstance ()। या यहां तक ​​कि सिर्फ नया टुट (), लेकिन इसके लिए आपको टुट के लिए एक प्रतिबंध बनाने की आवश्यकता है, जिसे आप सामान्यीकृत इंटरफ़ेस में नहीं करना चाहेंगे। हालाँकि, हम दोनों अभिव्यक्ति पेड़ के बारे में कुछ जानते हैं, जिसका अर्थ है कि हम इसे इस तरह से कर सकते हैं:

 ConstructorInfo outConstructor = outType.GetConstructor(Array.Empty<Type>()); Func<TOut> activator = outConstructor == null ? throw new Exception($"Default constructor for {outType.Name} not found") : Expression.Lambda<Func<TOut>>(Expression.New(outConstructor)).Compile(); 

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

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

 TOut outInstance = _activator(); PropertyInfo[] sourceProperties = source.GetType().GetProperties(); for (var i = 0; i < sourceProperties.Length; i++) { PropertyInfo sourceProperty = sourceProperties[i]; string propertyName = sourceProperty.Name; if (_outProperties.TryGetValue(propertyName, out PropertyInfo outProperty)) { object sourceValue = sourceProperty.GetValue(source); outProperty.SetValue(outInstance, sourceValue); } } return outInstance; 

इस प्रकार, हमने पूरी तरह से BasicMapper वर्ग का गठन किया है। आप यहां उनके परीक्षणों से खुद को परिचित कर सकते हैं । कृपया ध्यान दें कि स्रोत या तो किसी विशेष प्रकार का एक वस्तु या एक अनाम वस्तु हो सकता है।

प्रदर्शन और मुक्केबाजी

प्रतिबिंब महान है, लेकिन धीमा है। इसके अलावा, इसके लगातार उपयोग से मेमोरी ट्रैफ़िक बढ़ता है, जिसका अर्थ है कि यह GC को लोड करता है, जिसका अर्थ है कि यह एप्लिकेशन को और भी धीमा कर देता है। उदाहरण के लिए, हमने सिर्फ PropertyInfo.SetValue और PropertyInfo.GetValue विधियों का उपयोग किया। GetValue विधि एक ऑब्जेक्ट लौटाती है जिसमें एक निश्चित मान लिपटे (बॉक्सिंग) होता है। इसका मतलब है कि हमें खरोंच से आवंटन प्राप्त हुआ।

मैपर आमतौर पर स्थित होते हैं जहां आपको एक वस्तु को दूसरे में बदलने की आवश्यकता होती है ... नहीं, एक नहीं, बल्कि कई वस्तुएं। उदाहरण के लिए, जब हम डेटाबेस से कुछ लेते हैं। इस स्थान पर, मैं सामान्य प्रदर्शन देखना चाहता हूं और प्राथमिक ऑपरेशन पर स्मृति नहीं खोना चाहता।

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

संकलित मैपर

वास्तव में, सब कुछ अपेक्षाकृत सरल है: हमने पहले ही एक्सप्रेशन के साथ नया किया था। नया (कन्स्ट्रक्टरइन्फो)। आपने शायद ध्यान दिया है कि स्थिर नई विधि को ऑपरेटर के समान ही कहा जाता है। तथ्य यह है कि लगभग सभी सी # वाक्यविन्यास अभिव्यक्ति वर्ग के स्थिर तरीकों के रूप में परिलक्षित होता है। यदि कुछ गायब है, तो इसका मतलब है कि आप तथाकथित की तलाश कर रहे हैं "सिंथेटिक चीनी।"

यहां कुछ ऑपरेशन दिए गए हैं जिनका उपयोग हम अपने मैपर में करेंगे:

• परिवर्तनीय घोषणा - अभिव्यक्ति। उपलब्ध (प्रकार, स्ट्रिंग)। प्रकार तर्क बताता है कि किस प्रकार का चर बनाया जाएगा, और स्ट्रिंग चर का नाम है।
• असाइनमेंट - Expression.Assign (एक्सप्रेशन, एक्सप्रेशन)। पहला तर्क वह है जो हम असाइन करते हैं, और दूसरा तर्क वह है जो हम असाइन करते हैं।
• किसी ऑब्जेक्ट की प्रॉपर्टी तक पहुंच एक्सप्रेशन.प्रॉपर्टी (एक्सप्रेशन, प्रॉपर्टीइन्फो) है। अभिव्यक्ति संपत्ति का मालिक है, और PropertyInfo प्रतिबिंब के माध्यम से प्राप्त संपत्ति का वस्तु प्रतिनिधित्व है।

इस ज्ञान के साथ, हम चर, वस्तुओं के उपयोग गुण और वस्तुओं के गुणों को मान प्रदान कर सकते हैं। सबसे अधिक संभावना है, हम यह भी समझते हैं कि एक्सप्रेशनट्री को फंक <ऑब्जेक्ट, टुट> के प्रतिनिधि के रूप में संकलित करने की आवश्यकता है। योजना यह है: हमें एक चर मिलता है जिसमें इनपुट डेटा होता है, टाइप टूट का एक उदाहरण बनाएं और ऐसे भाव बनाएं जो एक संपत्ति को दूसरे को सौंपते हैं।

दुर्भाग्य से, कोड बहुत कॉम्पैक्ट नहीं है, इसलिए मेरा सुझाव है कि आप तुरंत CompiledMapper के कार्यान्वयन पर एक नज़र डालें। मैं यहां केवल मुख्य बिंदु लाया।

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

 var parameter = Expression.Parameter(typeof(object), "source"); 

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

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

 Expression sourceValue = Expression.Property(sourceInstance, sourceProperty); Expression outValue = Expression.Property(outInstance, outProperty); expressions.Add(Expression.Assign(outValue, sourceValue)); 

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

ठीक है, बहुत अंत में, हमें उन सभी अभिव्यक्तियों को संकलित करना होगा जो हमने बनाए थे। हम यहाँ क्या रुचि रखते हैं? फ़ंक्शन के बॉडी चर में "बॉडी" होती है। "सामान्य कार्य" एक शरीर है, है ना? खैर, जिसे हम ब्रेसिज़ में संलग्न करते हैं। तो, एक्सप्रेशन.ब्लॉक वास्तव में यही है। चूँकि घुंघराले ब्रेक्स भी एक स्कोप हैं, इसलिए हमें वहाँ ऐसे वेरिएबल्स पास करने होंगे जो वहाँ इस्तेमाल होंगे - हमारे मामले में sourceInstance और outInstance।

 var body = Expression.Block(new[] {sourceInstance, outInstance}, expressions); return Expression.Lambda<Func<object, TOut>>(body, parameter).Compile(); 

आउटपुट में, हमें Func <ऑब्जेक्ट, TOut>, अर्थात मिलता है। एक फ़ंक्शन जो डेटा को एक ऑब्जेक्ट से दूसरे में बदल सकता है। ऐसी मुश्किलें, आप क्यों पूछते हैं? मैं आपको याद दिलाता हूं कि, पहले, हम वैल्यू टाइप मानों की नकल करते समय मुक्केबाजी से बचना चाहते थे, और दूसरी बात, हम PropertyInfo.GetValue और PropertyInfo.SetValue तरीकों को छोड़ना चाहते थे, क्योंकि वे कुछ धीमी हैं।

बॉक्सिंग क्यों नहीं? क्योंकि संकलित एक्सप्रेशनट्री एक वास्तविक आईएल है, और रनटाइम के लिए, यह आपके कोड की तरह (लगभग) जैसा दिखता है। क्यों "संकलित मैपर" तेजी से है? फिर: क्योंकि यह सिर्फ सादा आईएल है। वैसे, हम बेंचमार्कडॉटनेट लाइब्रेरी का उपयोग करके आसानी से गति की पुष्टि कर सकते हैं, और बेंचमार्क को यहां देखा जा सकता है ।

Ratio कॉलम में "संकलित मैपर" (CompiledMapper) ने AutoMapper की तुलना में बहुत अच्छा परिणाम दिखाया (यह आधारभूत है, अर्थात 1)। हालाँकि, हम खुशी नहीं मनाते: AutoMapper में हमारी बाइक की तुलना में काफी अधिक क्षमताएं हैं। इस प्लेट के साथ मैं बस यह दिखाना चाहता था कि एक्सप्रेशन ट्रीज़ "क्लासिक रिफ्लेक्शन एप्रोच" की तुलना में बहुत तेज़ है।

सारांश

मुझे आशा है कि मैं यह दिखाने में सक्षम था कि आपका मैपर लिखना काफी सरल है। परावर्तन और अभिव्यक्ति पेड़ बहुत शक्तिशाली उपकरण हैं जो डेवलपर्स कई अलग-अलग कार्यों को हल करने के लिए उपयोग करते हैं। निर्भरता इंजेक्शन, Serialization / Deserialization, CRUD रिपॉजिटरी, SQL प्रश्नों का निर्माण, .NET अनुप्रयोगों के लिए स्क्रिप्ट के रूप में अन्य भाषाओं का उपयोग करना - यह सब प्रतिबिंब, परावर्तन.प्रमाण और अभिव्यक्ति पेड़ों का उपयोग करके किया जाता है।

मैपर के बारे में क्या? मैपर एक महान उदाहरण है जहां आप यह सब सीख सकते हैं।

पुनश्च: यदि आप कुछ और अभिव्यक्ति चाहते थे, तो मेरा सुझाव है कि इस तकनीक का उपयोग करके अपने JSON कनवर्टर को कैसे बनाया जाए ।