आंतरिक डीएसएल और अभिव्यक्ति पेड़ - क्रमबद्ध, कॉपी, क्लोन, समान कार्यों के गतिशील निर्माण (भाग I)

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

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

परिचय

की तुलना करें:

var p = new Point(){X=-1,Y=1}; // which has better performance ? var json1 = JsonConvert.SerializeObject(p); var json2 = $"{{\"X\":{pX}, \"Y\":{pY}}}"; 

दूसरी विधि स्पष्ट रूप से तेज़ है (नोड्स ज्ञात हैं और "कोड में crammed" हैं), जबकि विधि निश्चित रूप से अधिक जटिल है। लेकिन जब आपको यह कोड एक फ़ंक्शन (गतिशील रूप से उत्पन्न और संकलित) के रूप में मिलता है, तो जटिलता छिपी होती है (यहां तक ​​कि जो अस्पष्ट हो जाती है वह छिपी होती है)
कहां प्रतिबिंब है और कोड पीढ़ी रनटाइम कहां है)।

 var p = new Point(){X=-1,Y=1}; // which has better performance ? var json1 = JsonConvert.SerializeObject(p); var formatter = JsonManager.ComposeFormatter<Point>(); var json2 = formatter(p); 

यहाँ JsonManager.ComposeFormatter असली टूल है । वह नियम जिसके द्वारा क्रमांकन के दौरान संरचना बाईपास उत्पन्न होता है, स्पष्ट नहीं है, लेकिन यह ऐसा लगता है "डिफ़ॉल्ट मापदंडों के साथ, कस्टम मूल्य प्रकार के लिए पहले स्तर के सभी क्षेत्रों के आसपास जाते हैं"। यदि आप इसे स्पष्ट रूप से सेट करते हैं:

 //    var formatter2 = JsonManager.ComposeFormatter<Point>( chain=>chain .Include(e=>eX) .Include(e=>eY) // DSL Includes ) 

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

  Func<StringBuilder, Point, bool> serializer = ... // later string formatter(Point p) { var stringBuilder = new StringBuilder(); serializer(stringBuilder, p); return stringBuilder.ToString(); } 

 Expression<Func<StringBuilder, Point, bool>> serializerExpression = SerializeAssociativeArray(sb, p, (sb1, t1) => SerializeValueProperty(sb1, t1, "X", o => oX, SerializeValueToString), (sb4, t4) => SerializeValueProperty(sb1, t1, "Y", o => oY, SerializeValueToString) ); Func<StringBuilder, Point, bool> serializer = serializerExpression.Compile(); 

 var @delegate = SerializeAssociativeArray(sb, p, (sb1, t1) => SerializeValueProperty(sb1, t1, "X", o => oX, SerializeValueToString), (sb4, t4) => SerializeValueProperty(sb1, t1, "Y", o => oY, SerializeValueToString), (sb4, t4) => SerializeValueProperty(sb1, t1, "NextPoint", o => o.NextPoint, (sb4, t4) =>SerializeAssociativeArray(sb1, p1, (sb1, t1) => SerializeValueProperty(sb2, t2, "X", o => oX, SerializeValueToString), (sb4, t4) => SerializeValueProperty(sb2, t2, "Y", o => oY, SerializeValueToString) ) ) ); 

 public static bool SerializeAssociativeArray<T>(StringBuilder stringBuilder, T t, params Func<StringBuilder, T, bool>[] propertySerializers) { var @value = false; stringBuilder.Append('{'); foreach (var propertySerializer in propertySerializers) { var notEmpty = propertySerializer(stringBuilder, t); if (notEmpty) { if (!@value) @value = true; stringBuilder.Append(','); } }; stringBuilder.Length--; if (@value) stringBuilder.Append('}'); return @value; } public static bool SerializeValueProperty<T, TProp>(StringBuilder stringBuilder, T t, string propertyName, Func<T, TProp> getter, Func<StringBuilder, TProp, bool> serializer) where TProp : struct { stringBuilder.Append('"').Append(propertyName).Append('"').Append(':'); var value = getter(t); var notEmpty = serializer(stringBuilder, value); if (!notEmpty) stringBuilder.Length -= (propertyName.Length + 3); return notEmpty; } public static bool SerializeValueToString<T>(StringBuilder stringBuilder, T t) where T : struct { stringBuilder.Append(t); return true; } 

 ("sb","t") .. SerializeAssociativeArray.. 

हालाँकि, यदि आप हर बार संकलन करने से पहले संकलन कहते हैं, तो एक धारावाहिक धारावाहिक एक गतिशील रूप से उत्पन्न फ़ंक्शन से आगे निकल जाएगा ( ComposeFormatter अंदर संकलन एक महंगा ऑपरेशन है), लेकिन आप लिंक को बचा सकते हैं और इसका पुन: उपयोग कर सकते हैं:

 static Func<Point, string> formatter = JsonManager.ComposeFormatter<Point>(); public string Get(Point p){ // which has better performance ? var json1 = JsonConvert.SerializeObject(p); var json2 = formatter(p); return json2; } 

यदि आपको पुन: उपयोग के लिए गुमनाम प्रकार के धारावाहिक बनाने और बचाने की आवश्यकता है, तो आपको अतिरिक्त बुनियादी ढांचे की आवश्यकता है:

 static CachedFormatter cachedFormatter = new CachedFormatter(); public string Get(List<Point> list){ // there json formatter will be build only for first call // and assigned to cachedFormatter.Formatter // in all next calls cachedFormatter.Formatter will be used. // since building of formatter is determenistic it is lock free var json3 = list.Select(e=> {X:eX, Sum:e.X+EY}) .ToJson(cachedFormatter, e=>e.Sum); return json3; } 

उसके बाद, हम आत्मविश्वास से अपने लिए पहला माइक्रोएप्टिमाइजेशन को ध्यान में रखते हैं और जमा करते हैं, जमा करते हैं, जमा करते हैं ... कौन मजाक है, कौन नहीं है, लेकिन इस सवाल पर आगे बढ़ने से पहले कि नया धारावाहिक नया है, मैं स्पष्ट लाभ को ठीक करता हूं - यह तेजी से होगा।

बदले में क्या?

डीएसएल में सीरलाइज़ में दुभाषिया शामिल है (और उसी तरह से यह पुनरावृत्तियों में संभव है, प्रतिलिपि, क्लोन - और यह भी होगा) निम्नलिखित लागतों की आवश्यकता है:

1 - संकलित कोड के लिंक को संग्रहीत करने के लिए बुनियादी ढांचे की लागत।

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

2 - आपको अमूर्त के लीक के साथ-साथ एक समान समस्या को ध्यान में रखने की आवश्यकता है: मौजूदा समाधानों की तुलना में शब्दार्थ में परिवर्तन।

उदाहरण के लिए, पॉइंट और IEnumerable को क्रमबद्ध करने के लिए दो अलग-अलग धारावाहिकों की आवश्यकता होती है।

 var formatter1 = JsonManager.ComposeFormatter<Point>(); var formatter2 = JsonManager.ComposeEnumerableFormatter<Point>(); // but not // var formatter2 = JsonManager.ComposeEnumerableFormatter<List<Point>>(); 

या: "क्लोजर काम करता है?"। यह काम करता है, केवल नोड को नाम सेट करने की आवश्यकता है (अद्वितीय):

 string DATEFORMAT= "YYYY"; var formatter3 = JsonManager.ComposeFormatter<Record>( chain => chain .Include(i => i.RecordId) .Include(i => i.CreatedAt.ToString(DATEFORMAT) , "CreatedAt"); ); 

यह व्यवहार ComposeFormatter से ComposeFormatter दुभाषिया के आंतरिक उपकरण द्वारा निर्धारित किया जाता है।

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

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

इस सब को ध्यान में रखते हुए, मैं एक विशेष डीएसएल की प्रभावशीलता में वापस आता हूं।

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

सरलीकरण को कॉन्फ़िगर किया जाना चाहिए:

1. बाईपास ट्री (नोड्स का वर्णन करने के लिए जिसके माध्यम से क्रमांकन होगा, जिस तरह से यह परिपत्र लिंक की समस्या को हल करता है), पत्तियों के मामले में - एक फॉर्मेटर (प्रकार से) असाइन करें।
2. पत्तियों सहित नियम (यदि वे निर्दिष्ट नहीं हैं) - संपत्ति बनाम फ़ील्ड? केवल पढ़ने के लिए?
3. एक शाखा (नेविगेशन के साथ एक नोड) और एक शीट दोनों को निर्दिष्ट करने में सक्षम होने के लिए केवल e=>e.Name ( e=>e.Name ) नहीं है, लेकिन आम तौर पर कोई भी फ़ंक्शन (`e => e.Name.ToUpper) ()," MymemberName ") - एक विशिष्ट के लिए फ़ॉर्मेटर सेट करें नोड।

लचीलापन बढ़ाने के अन्य विकल्प:

1. एक शीट को क्रमबद्ध करें जिसमें एक जसन होता है "जैसा कि" स्ट्रिंग (विशेष स्ट्रिंग फॉर्मेटर) है;
2. समूहों के लिए स्वरूपक सेट करें, अर्थात पूरी शाखाएँ, इस शाखा में इस तरह से - एक दूसरे तरीके से (उदाहरण के लिए, समय के साथ यहाँ तारीखें, और इस समय के बिना एक में)।

हर जगह ऐसे निर्माण शामिल हैं: बायपास ट्री, शाखा, पत्ती, और यह सब DSL शामिल का उपयोग करके लिखा जा सकता है।

डीएसएल शामिल है

चूंकि हर कोई ईएफ कोर से परिचित है, इसलिए निम्न अभिव्यक्तियों के अर्थ को तुरंत पकड़ लिया जाना चाहिए (यह xpath का सबसेट है)।

  // DSL Includes Include<User> include1 = chain=> chain .IncludeAll(e => e.Groups) .IncludeAll(e => e.Roles) .ThenIncludeAll(e => e.Privileges) // EF Core syntax // https://docs.microsoft.com/en-us/ef/core/querying/related-data var users = context.Users .Include(blog => blog.Groups) .Include(blog => blog.Roles) .ThenInclude(blog => blog.Privileges); 

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

 Include<User> include2 = chain=> chain .Include(e => e.UserName) // leaf member .IncludeAll(e => e.Groups) .ThenInclude(e => e.GroupName) // leaf member .IncludeAll(e => e.Roles) .ThenInclude(e => e.RoleName) // leaf member .IncludeAll(e => e.Roles) .ThenIncludeAll(e => e.Privileges) .ThenInclude(e => e.PrivilegeName) // leaf member 

या एक विशेष दुभाषिया के माध्यम से, नियम से गतिशील रूप से जोड़ें:

 // Func<ChainNode, MemberInfo> rule = ... var include2 = IncludeExtensions.AppendLeafs(include1, rule); 

यहाँ नियम एक नियम है जिसे ChainNode.Type द्वारा चुना जा सकता है। नोड द्वारा लौटाई गई अभिव्यक्ति के प्रकार (चेननोड - डीएसएल के आंतरिक प्रतिनिधित्व में शामिल हैं, जिसमें बाद में चर्चा की जाएगी) क्रमांकन में भागीदारी के लिए गुण (मेंबरफो), जैसे। केवल संपत्ति, या केवल पढ़ने / लिखने के लिए संपत्ति, या केवल जिनके लिए एक फ़ॉर्मेटर है, आप प्रकारों की एक सूची से चयन कर सकते हैं, और यहां तक ​​कि अभिव्यक्ति को भी स्वयं एक नियम निर्धारित कर सकते हैं (यदि यह पत्ती के नोड्स को सूचीबद्ध करता है - अर्थात, पेड़ में शामिल होने का रूप) ।

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

बॉक्स से बाहर

ईएफ कोर के साथ एकीकरण।
रनिंग कार्य "चक्रीय लिंक को काट देना" है, केवल वही शुरू करना है, जो कि शामिल-अभिव्यक्ति में निर्दिष्ट है:

 static CachedFormatter cachedFormatter1 = new CachedFormatter(); string GetJson() { using (var dbContext = GetEfCoreContext()) { string json = EfCoreExtensions.ToJsonEf<User>(cachedFormatter1, dbContext, chain=>chain .IncludeAll(e => e.Roles) .ThenIncludeAll(e => e.Privileges)); } } 

ToJsonEf नेविगेशन अनुक्रम को स्वीकार करता है, जब क्रमबद्ध करता है, तो वह इसका उपयोग करता है ("EF कोर के लिए डिफ़ॉल्ट" नियम से पत्तियों का चयन करता है, अर्थात सार्वजनिक पठन / लेखन संपत्ति), मॉडल में रुचि रखता है - जहां स्ट्रिंग / json फ़ील्ड स्वरूपण सम्मिलित करने के लिए उपयोग करता है। डिफ़ॉल्ट रूप से (बाइट [] प्रति स्ट्रिंग, आईएसओ में डेटाइम, आदि)। इसलिए, उसे अपने अधीन से ही IQugeable प्रदर्शन करना होगा।

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

 static CachedFormatter cachedFormatter1 = new CachedFormatter(); string GetJson() { using (var dbContext = GetEfCoreContext()) { var json = dbContext.ParentRecords // back to EF core includes // but .Include(include1) also possible .IncludeAll(e => e.Roles) .ThenIncludeAll(e => e.Privileges) .Select(e => new { FieldA: e.FieldA, FieldJson:"[1,2,3]", Role: e.Roles().First() }) .ToJson(cachedFormatter1, chain => chain.Include(e => e.Role), LeafRuleManager.DefaultEfCore, config: rules => rules .AddRule<string[]>(GetStringArrayFormatter) .SubTree( chain => chain.Include(e => e.FieldJson), stringAsJsonLiteral: true) // json as is .SubTree( chain => chain.Include(e => e.Role), subRules => subRules .AddRule<DateTime>( dateTimeFormat: "YYYMMDD", floatingPointFormat: "N2" ) ), ), useToString: false, // no default ToString for unknown leaf type (throw exception) dateTimeFormat: "YYMMDD", floatingPointFormat: "N2" } } 

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

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

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

अधिक डीएसएल शामिल हैं

 Include<Point> include = chain => chain.Include(e=>eX).Include(e=>eY); 

यह EF कोर से भिन्न होता है जिसमें स्थिर कार्य शामिल होते हैं जिन्हें चर को नहीं सौंपा जा सकता है और पैरामीटर के रूप में पारित किया जाता है। डीएसएल में खुद को शामिल किया गया था जो रिपॉजिटरी टेम्प्लेट के मेरे कार्यान्वयन में "शामिल" करने की आवश्यकता से बाहर पैदा हुआ था, बिना टाइप जानकारी के प्रकट होने के बिना, जब वे तार में मानकीकृत होते थे।

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

EF Core के आंतरिक प्रतिनिधित्व में e=>User.Name Expression.Member द्वारा प्राप्त तार की एक सूची शामिल है ( e=>User.Name द्वारा निर्दिष्ट अभिव्यक्ति)। e=>User.Name केवल [ e=>User.Name ] हो सकता है ( https://msdn.microsoft.com/en-us/usibrary/system.linq.expressions)। मेम्ब्रेक्सप्रेशन (v = बनाम 110) .aspx और आंतरिक विचारों में केवल Name रेखा बच जाती है)।

DSL में शामिल है, आंतरिक प्रतिनिधित्व ChainNode और ChainMemberNode कक्षाएं हैं जो संपूर्ण अभिव्यक्ति (जैसे e=>User.Name ) को e=>User.Name , जो कि, जैसा कि यह है, अभिव्यक्ति पेड़ में बनाया गया है। यह इस बात से ठीक है कि DSL में फ़ील्ड और उपयोगकर्ता मान दोनों प्रकार और फ़ंक्शन कॉल शामिल हैं:

कार्यों का निष्पादन:

 Include<User> include = chain => chain .Include(i => i.UserName) .Include(i => i.Email.ToUpper(),"EAddress"); 

इसके साथ क्या करना है यह दुभाषिया पर निर्भर करता है। CreateFormatter- {"UserName": "John", "ERddress": "JOHN@MAIL.COM"} वापस आएगा

निष्पादन अशक्त संरचनाओं पर ट्रैवर्सल स्थापित करने के लिए भी उपयोगी हो सकता है।

 Include<StrangePointF> include = chain => chain .Include(e => e.NextPoint) // NextPoint is nullable struct .ThenIncluding(e => e.Value.X) .ThenInclude(e => e.Value.Y); // but not this way (abstraction leak) // Include<StrangePointF> include // = chain => chain // now this can throw an exception // .Include(e => e.NextPoint.Value) // .ThenIncluding(e => eX) // .ThenInclude(e => eY); 

डीएसएल में मल्टी-लेवल के लिए एक छोटी प्रविष्टि भी शामिल है।

 Include<User> include = chain => chain .Include(i => i.UserName) .IncludeAll(i => i.Groups) // ING-form - doesn't change current node .ThenIncluding(e => e.GroupName) // leaf .ThenIncluding(e => e.GroupDescription) // leaf .ThenInclude(e => e.AdGroup); // leaf 

से तुलना करें

 Include<User> include = chain => chain .Include(i => i.UserName) .IncludeAll(i => i.Groups) .ThenInclude(e => e.GroupName) .IncludeAll(i => i.Groups) .ThenInclude(e => e.GroupDescription) .IncludeAll(i => i.Groups) .ThenInclude(e => e.AdGroup); 

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

बीजगणित में अभिव्यक्तियाँ शामिल करें ।

शामिल भाव हो सकते हैं:

 var b1 = InlcudeExtensions.IsEqualTo(include1, include2); var b2 = InlcudeExtensions.IsSubTreeOf(include1, include2); var b3 = InlcudeExtensions.IsSuperTreeOf(include1, include2); 

 var include2 = InlcudeExtensions.Clone(include1); 

 var include3 = InlcudeExtensions.Merge(include1, include2); 

 IReadOnlyCollection<string> paths1 = InlcudeExtensions.ListLeafXPaths(include); // as xpaths IReadOnlyCollection<string[]> paths2 = InlcudeExtensions.ListLeafKeyPaths(include); // as string[] 

आदि

अच्छी खबर यह है: अमूर्तता की कोई लीक नहीं है, शुद्ध अमूर्त का स्तर यहां तक ​​पहुंच गया है। मेटाडेटा है और मेटाडेटा के साथ काम करते हैं।

द्वंद्ववाद

DSL में आपको अमूर्तता के एक नए स्तर को प्राप्त करने की अनुमति मिलती है, लेकिन उपलब्धि के समय, अगले स्तर पर जाने के लिए एक आवश्यकता का गठन किया जाता है: स्वयं भाव शामिल करें।

इस मामले में, धाराप्रवाह श्रृंखला के रूप में डीएसएल उत्पन्न करना आवश्यक नहीं है, आपको बस आंतरिक प्रतिनिधित्व संरचना बनाने की आवश्यकता है।

 var root = new ChainNode(typeof(Point)); var child = new ChainPropertyNode( typeof(int), expression: typeof(Point).CreatePropertyLambda("X"), memberName:"X", isEnumerable:false, parent:root ); root.Children.Add("X", child); // or there is number of extension methods eg: var child = root.AddChild("X"); Include<Point> include = ChainNodeExtensions.ComposeInclude<Point>(root); 

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

कॉपी, क्लोन, बराबर

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

 Include<User> include = chain=>chain.Include(e=>e.UserId).IncludeAll(e=>e.Groups).ThenInclude(e=>e.GroupId) bool b1 = ObjectExtensions.Equals(user1, user2, include); bool b2 = ObjectExtensions.EqualsAll(userList1, userList2, include); 

 Include<User> include = chain=>chain.Include(e=>e.UserId).IncludeAll(e=>e.Groups).ThenInclude(e=>e.GroupId) var newUser = ObjectExtensions.Clone(user1, include, leafRule1); var newUserList = ObjectExtensions.CloneAll(userList1, leafRule1); 

 Include<User> include = chain=>chain.IncludeAll(e=>e.Groups); ObjectExtensions.Copy(user1, user2, include, supportedLeafsRule); ObjectExtensions.CopyAll(userList1, userList2, include, supportedLeafsRule); 

copy / clone :

1. readonly , Tuple<,> Anonymous Type. , .
2. (. IEnumerable ) — public .
3. expression include-, — .
4. " " .

DSL , .. . , Tuple<,> , .. c readonly , ValueTuple<,> c writabale ( ).

, ( Expression Trees) Includes — . Include DSL .

Detach, FindDifferences ..

run-time, .cs ?

.cs , , run-time :

1. ( , , source control).
2. , , , — .
3. .
4. " ". dev time , : "" "" , "" , , "" .

Roslyn', . Typescript ( DTO , .. ) — DSL Includes Roslyn' ( ) — typescript ( ). " " " " .cs ( Expression Trees).

: run time — , . ( Expression Trees).

Expression Trees

Internal DSL Expression Tree :

1. LambdaExpression.Compile Lambda . , . , "" expression tree, CallExpression — LambdaExpression, (. LambdaExpression) ConstantExpression. , " /" — , Expression Trees.

   
   

2. ssmbly , ( 10 ) ( assembly , — ). , , , — .

   
   

, ( ), , . : . — — .cs .

— 600 15 . JSON.NET, ServiceStack reflection' GetProperties().

dslComposeFormatter — ComposeFormatter , .

BenchmarkDotNet =v0.10.14, OS=Windows 10.0.17134
Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), 1 CPU, 4 logical and 4 physical cores
.NET Core SDK=2.1.300

fake_expressionManuallyConstruted — expression ( ).

DSL : DSL ; Internal DSL run-time .

Expression Tree .NET Standard .

Expression Trees Internal DSL Fluent API. # .

fluent ( Expression Trees), Internal DSL # fluent, "" Expression Trees.

Expression Trees DSL Includes ( , ), / run-time — (run-time ).

Internal DSL : - serialize , copy , clone , equals "" . , " ", . : includes ( ) , ( , ).

निष्कर्ष

DSL Includes DTO — ( json). , , , " ", . = .

Internal DSL , DSL, Internal DSL ( Expression) ( Expression Tree).

DSL Includes json ComposeFormatter DashboardCodes.Routines nuget GitHub.