🤲 🏟️ 🍆 कोड के लिए आलस्य का अर्ध-स्वचालित रूपांतरण 🦍 🚩 🛀🏼

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

प्रस्तावना

जब मैं C ++ में प्रोग्रामिंग कर रहा था, तो मैंने इन उद्देश्यों के लिए मापदंडों के साथ #define निर्देश का उपयोग किया। एक महान तंत्र जो आपको आवेषण के साथ एक सरल रेखा में कोड का एक टुकड़ा घोषित करने की अनुमति देता है, जिसे आप कई बार पुन: उपयोग कर सकते हैं। यह टेम्प्लेट या जेनेरिक कक्षाओं की पेशकश के समान नहीं है।
दुर्भाग्य से, C # डेवलपर्स ने C ++ के समान #define निर्देश के लिए समर्थन शामिल नहीं किया। इसके लिए संभवतः कारण हैं, मुख्य रूप से, कोड की पठनीयता और पारदर्शिता में। लेकिन मैं तब भी चाहता था कि समान निर्माणों की घोषणा करते समय कोड डुप्लीकेशन की आवश्यकता से बचा जा सके।
मुझे कहना होगा कि Microsoft कोड पीढ़ी का उपयोग करते हुए काफी सक्रिय है। कम से कम Linq2Sql वर्गों को लें - वर्ग संरचना के सभी घोषणाएं xml फ़ाइल में हैं जिसके आधार पर कोड उत्पन्न होता है। इसके अलावा, .NET फ्रेमवर्क में एक पूरा System.CodeDom नाम स्थान कोड पीढ़ी को समर्पित है। कई तरीके और कक्षाएं आपको सीएलआर शब्दों में कोड उत्पन्न करने और इसे .NET - C #, VB.Net द्वारा समर्थित किसी भी भाषा के रूप में सहेजने की अनुमति देती हैं। यह कुछ इस तरह दिखता है:

/// <summary> ///   - /// </summary> /// <param name="newC"></param> /// <param name="e"></param> private void CreateProperty(CodeTypeDeclaration newC, XmlElement e) { string propName = e.GetAttribute("name"); var propType = ResolveType(e.GetAttribute("datatype")); var rel_field_prop_name = createPropertyConstName(newC, e, propName); var new_prop = new CodeMemberProperty { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = "p_" + propName, HasGet = true, HasSet = true, Type = propType }; var comment = e.GetAttribute("displayname"); if (!string.IsNullOrEmpty(comment)) new_prop.Comments.Add(new CodeCommentStatement("<summary>\n " + comment + "\n </summary>", true)); new_prop.GetStatements.Add(new CodeMethodReturnStatement( new CodeCastExpression(propType, new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(new CodeBaseReferenceExpression(), "GetDataProperty"), new CodeFieldReferenceExpression(null, rel_field_prop_name))))); new_prop.SetStatements.Add( new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(new CodeBaseReferenceExpression(), "SetDataProperty"), new CodeFieldReferenceExpression(null, rel_field_prop_name), new CodePropertySetValueReferenceExpression())); newC.Members.Add(new_prop); }

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

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

2010 में, Microsoft T4 टेक्स्ट टेम्प्लेट के साथ आया। प्रलेखन को देखते हुए, यह लगभग आपकी आवश्यकता है। लेकिन, सबसे पहले, मेरे पास अभी भी 2008 के स्टूडियो में परियोजनाएं हैं, और दूसरी बात, मैं उन्हें काम करने के लिए नहीं मिला :-(।

फिर भी नेमारले जैसी चीज है। आमतौर पर C # के शीर्ष पर अपनी भाषा के साथ आने का अवसर है। कूल, लेकिन फिर से वह नहीं जो आपको चाहिए।
आखिरकार, मैं सिर्फ C # में कोड के टुकड़ों का पुन: उपयोग करने में सक्षम होना चाहता हूं।

मुझे कुछ सरल चाहिए

इसलिए, मैं तत्परता की स्थिति में पहुंच गया - मेरे हाथ पहले से ही कुछ प्रोग्राम करने के लिए खुजली कर रहे हैं। मुख्य विशलिस्ट तैयार की जाती है:

"कोड-जनरेटिंग" कोड सरल और पढ़ने में आसान होना चाहिए।
कोड पीढ़ी के लिए कक्षाओं को लिनक-शैली श्रृंखला इंटरफेस को लागू करना चाहिए।
पीढ़ी के लिए उपयोग किए जाने वाले टेम्पलेट को एक साधारण स्ट्रिंग के रूप में घोषित किया जाना चाहिए।
एक वर्ग में मैन्युअल रूप से उत्पन्न और लिखित कोड को संयोजित करना संभव होना चाहिए

और उनके आधार पर, तकनीकी समाधान विकसित किए जाते हैं:

एक पुस्तकालय सरल कोड पीढ़ी के लिए कक्षाओं और विधियों से युक्त होता है
समाधान में एक निष्पादन योग्य एप्लिकेशन की एक परियोजना शामिल है, जो पहले इकट्ठे होने में से एक है, तुरंत लॉन्च (पोस्टब्यूइल्डस्टेप में) और उल्लिखित लाइब्रेरी का उपयोग करके अन्य परियोजनाओं के लिए आवश्यक भागों को उत्पन्न करता है।
उत्पन्न और लिखित कोड को संयोजित करने में सक्षम होने के लिए हम आंशिक कक्षाओं का उपयोग करते हैं। (संभवतः, इस सुविधा को C # में जोड़ा गया था, ताकि यह #define feature की कमी के कारण इतना आक्रामक न हो।)
हम कोड पीढ़ी के लिए प्रारंभिक डेटा तैयार करते हैं, उदाहरण के लिए, स्थानान्तरण के रूप में। क्यों? हां, यह सुविधाजनक है।

निचला रेखा - समान गुणों के एक सेट के साथ एक वर्ग बनाने के लिए कोड कुछ इस तरह दिखता है:

 //   const string CommandPropertyTemplate = @"public static <type> <name> {{ get {{ return PVCommand.<name>.GetCommand(); }} }} "; //      var commandsClass = CodeWriter .BeginSource("Commands.cs") .Using("MyApp.Display") .BeginNamespace("MyAppCommands") .AddClass("Commands").Static(); //         //   var allcmds = System.Enum.GetValues(typeof(PVCommand)).Cast<PVCommand>(); foreach (var cmd in allcmds) { commandsClass.AddBlock<RoutedUICommand>(cmd.ToString(), CommandPropertyTemplate); }

टेम्पलेट के डिजाइन के बारे में कुछ टिप्पणियां। डबल घुंघराले ब्रेसिज़ का उपयोग केवल इस स्ट्रिंग को स्ट्रिंग में प्रस्तुत करने के लिए किया जाता है। कीवर्ड और संपत्ति के नाम और प्रकार के साथ बदल दिए जाते हैं, जो AddBlock () पद्धति के मापदंडों के रूप में पारित किए जाते हैं।

तो यह सब क्यों आवश्यक है?

खैर, अब थोड़ा सोचते हैं कि यह सब कैसे लगाया जा सकता है।

स्थानीय तार के साथ काम करें

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

  public enum Strings { [Description("MyCoolApp - trial version")] AppTitle, }

इस गणना के आधार पर, दो कलाकृतियां बनाई गई हैं:

संसाधनों के साथ XAML। (इसे उत्पन्न करने के लिए Linq2XML से कक्षाएं ली जाती हैं)
कोड से संसाधनों तक सुविधाजनक पहुंच के लिए स्टेटिक क्लास।

WPF में स्थानीयकरण के तार के साथ काम करने के लिए आवश्यक सभी कोड बनाना इस तरह दिखता है:

 //    const string ResourceEntry = @" public const <type> <name>Key = ""<name>""; public static <type> <name> {{ get{{ return App.RString(<name>Key); }} }} "; //     var stringTable = CodeWriter .BeginSource("Strings.cs") .BeginNamespace("MyApp") .AddClass("StringTable") .Static(); //      foreach (var rstring in GetResourceStrings()) { var resourseKey = rstring.ToString(); stringTable.AddBlock<string>(resourseKey, ResourceEntry); } //   XAML void StringTableXamlTo(string dir) { var nsDefault = "http://schemas.microsoft.com/winfx/2006/xaml/presentation"; var nsX = "http://schemas.microsoft.com/winfx/2006/xaml"; var nsCore = "clr-namespace:MyApp.Core;assembly=MyApp.Core"; var resourcedict = new XElement(XName.Get("ResourceDictionary", nsDefault), new XAttribute(XName.Get("Uid", nsX), "StringTable"), new XAttribute(XNamespace.Xmlns + "core", nsCore), new XAttribute(XNamespace.Xmlns + "x", nsX)); foreach (var rstring in GetResourceStrings()) { var resourseKey = rstring.ToString(); var resourceValue = EnumHelper.GetDescription(rstring); var resourceDecl = new XElement(XName.Get("StringObject", nsCore), new XAttribute(XName.Get("Uid", nsX), "UID_" + resourseKey), new XAttribute(XName.Get("Key", nsX), resourseKey), new XAttribute("Localization.Attributes", "Value (Readable Modifiable Text)"), new XAttribute("Value", resourceValue) ); resourcedict.Add(resourceDecl); } var xaml = new XDocument(resourcedict); xaml.Save(Path.Combine(dir, "stringtable.xaml")); } }

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

डोमेन मॉडल

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

 const string ModelPropertyTemplate = @" <type> _<name>; public <type> <name> {{ get {{ return _<name>; }} set {{ _<name> = value; if (PropertyChanged != null) PropertyChanged(this, new PropertyChangedEventArgs(""<name>"")); }} } ";

निष्कर्ष

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

आपका ध्यान के लिए धन्यवाद!

पुनश्च यहां आप खुद को उल्लेखित पुस्तकालय के स्रोतों से परिचित करा सकते हैं।