ऑब्जेक्ट ओरिएंटेड जिन इंस्टॉलर विकास

पहले भाग का लिंक

लेन-देन।

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

public abstract class TransactionalCommand : Command { public abstract TransactionStep Do(ExecutionContext context, Transaction transaction); public abstract void Rollback(TransactionStep step); } 

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

1. नया लेन-देन चरण बनाएं
2. भौतिक रूप से सहेजें (डिस्क पर, डेटाबेस में, आदि) सिस्टम की स्थिति, या बल्कि इसके उन पहलुओं को जो कमांड निष्पादित होने के बाद बदल जाएंगे,
3. कमांड क्लास के Do (ExecutionContext) विधि को कॉल करें (अर्थात, मूल nontransactional ऑपरेशन करें),
4. शुरुआत में बनाया गया TransactionStep वापस करें।

हमने रोलबैक () पद्धति को भी जोड़ा, जो लेन-देन के चरण को वापस लेती है।
इस प्रकार, हमने राज्य को बनाए रखने और टीम को स्वयं टीम में वापस लाने के लिए जिम्मेदारी सौंपी, जो उपयोगकर्ताओं को इंस्टॉलर द्वारा निष्पादित लेनदेन आदेशों की सरणी को आसानी से बढ़ाने की अनुमति देता है।
इंस्टॉलर अवसंरचना को उपयोगकर्ताओं को सिस्टम की स्थिति को बनाए रखने के लिए एक संरचित भंडारण के साथ प्रदान करना चाहिए जब तक कि लेनदेन पूरा न हो जाए और इसके लिए एक एक्सेस इंटरफ़ेस न हो। तृतीय-पक्ष घटकों (जैसे डेटाबेस, उदाहरण के लिए) की स्थापना पर जितना संभव हो उतना कम निर्भर करने के लिए, मैं सिस्टम की स्थिति को इंस्टॉलर के कार्य फ़ोल्डर के एक विशिष्ट सबफ़ोल्डर में संग्रहीत फ़ाइलों के एक मनमाने सेट के रूप में प्रस्तुत करने जा रहा हूं। फ़ाइल संरचना को इस तरह देखो:
%GIN_DIRECTORY%\packages\[PackageId]\transactions\[TransactionName]\steps\[StepNumber]\
या पेड़ के रूप में:

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

 public class TransactionStep { public const string STEPS_SUBFOLDER_NAME = @"steps"; public int StepNumber { get; set; } public string TransactionName { get; set; } public TransactionalCommand Command { get; set; } public string GetPath(ExecutionContext context) { string transactionsPath = context.ExecutedPackage.TransactionsPath; string transactionPath = Path.Combine(transactionsPath, TransactionName); string stepsPath = Path.Combine(transactionPath, STEPS_SUBFOLDER_NAME); string stepPath = Path.Combine(stepsPath, StepNumber.ToString()); if (!Directory.Exists(stepPath)) { Directory.CreateDirectory(stepPath); } return stepPath; } } 

जैसा कि आप कक्षा के विवरण से देख सकते हैं, कक्षा के दो मुख्य उद्देश्य हैं:

• एक फ़ोल्डर बनाता है और चरण पूरा होने तक सिस्टम की स्थिति को बचाने के लिए फ़ोल्डर में पथ देता है
• इसी आदेश की एक आवृत्ति को संग्रहीत करता है ताकि लेनदेन कदम को वापस लाया जा सके

हम इस वर्ग से ठोस कदमों के उपवर्ग प्राप्त करेंगे। उदाहरण के लिए:

 public class SingleFileStep: TransactionStep { public string OldFilePath { get; set; } } 

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

 public class Transaction { public string TransactionName { get; set; } public TransactionState TransactionState { get; set; } public List<TransactionStep> Steps { get; set; } public Transaction() { Steps = new List<TransactionStep>(); } public T CreateStep<T>(TransactionalCommand command) where T: TransactionStep, new() { T step = new T(); int stepNumber = Steps.Count; step.StepNumber = stepNumber; step.Command = command; step.TransactionName = TransactionName; Steps.Add(step); return step; } public void Save(ExecutionContext context) { string transactionsPath = context.ExecutedPackage.TransactionsPath; string transactionPath = Path.Combine(transactionsPath, TransactionName + @"\"); Directory.CreateDirectory(transactionPath); string dataFilePath = Path.Combine(transactionPath, @"data.xml"); GinSerializer.Serialize(this, dataFilePath); } public void Rollback() { Steps.BackForEach(s => { s.Command.Rollback(s); }); } } 

जैसा कि आप देख सकते हैं, वर्ग के मुख्य कार्य इस प्रकार हैं:

• लेन-देन के लिए एक नया कदम जोड़ना और लेन-देन के चरणों का क्रम संग्रहीत करना
• इसी XML फ़ाइल में डिस्क पर ट्रांजेक्शन सेव करें
• रिवर्स ऑर्डर में लेन-देन के सभी चरणों को वापस करके लेन-देन को रोलबैक करें

BackForEach विधि एक विस्तार विधि है जिसे एक अलग वर्ग में ले जाया गया है ताकि अन्य वर्गों के कोड को अव्यवस्थित न किया जा सके। खैर, सामान्य तौर पर, मैं विस्तार विधियों और लैम्ब्डा अभिव्यक्तियों का उपयोग करना पसंद करता हूं, कृपया मुझे इस कमजोरी के लिए क्षमा करें।
अब हम वर्गों में से एक को TransactionalCommand के उत्तराधिकारी के रूप में समझते हैं कि उपयोगकर्ताओं को लेनदेन का समर्थन करने वाले आदेशों को कैसे लागू करना चाहिए।

 public class CreateFile: TransactionalCommand { public string SourcePath { get; set; } public string DestPath { get; set; } public override void Do(ExecutionContext context) { File.Copy(SourcePath, DestPath, true); } public override TransactionStep Do(ExecutionContext context, Transaction transaction) { SingleFileStep step = null; if (transaction != null) { step = transaction.CreateStep<SingleFileStep>(this); } if (File.Exists(DestPath)) { string rollbackFileName = Guid.NewGuid().ToString("N") + ".rlb"; string dataPath = step.GetPath(context); string rollbackFilePath = Path.Combine(dataPath, rollbackFileName); step.OldFilePath = rollbackFilePath; File.Copy(DestPath, rollbackFilePath); } Do(context); return step; } public override void Rollback(TransactionStep step) { SingleFileStep currentStep = (SingleFileStep)step; if (File.Exists(currentStep.OldFilePath)) { File.Copy(currentStep.OldFilePath, DestPath, true); } else { File.Delete(DestPath); } } } 

दो तर्कों के साथ डू () पद्धति, इसके पास किए गए लेनदेन के ढांचे के भीतर, CreateStep <> विधि का उपयोग करके एक नया लेनदेन चरण बनाता है, फिर जाँचता है कि क्या फ़ाइल पहले से ही उस पथ के साथ मौजूद है जहाँ इंस्टॉलर को वर्तमान चरण में एक नई फ़ाइल बनानी चाहिए, और यदि फ़ाइल पहले से ही है। यह इसे एक अलग नाम (हालांकि नाम बदला नहीं जा सकता है) के तहत इसे इंस्टॉलर इन्फ्रास्ट्रक्चर (TransactionStep.GetPath) द्वारा प्रदान किए गए फ़ोल्डर में कॉपी करता है, और उसके बाद ही nransransactional कमांड कमांड्स के वर्ग से विरासत में मिली विधि को कॉल करता है, जो परिणाम के रूप में लौटता है। ट्रांस कदम की शुरुआत में tion कदम।
रोलबैक विधि एक तर्क के रूप में एक लेनदेन कदम उठाती है, और इसकी OldFilePath संपत्ति की जाँच करके फ़ाइल के पुराने संस्करण को गंतव्य फ़ोल्डर में कॉपी कर देती है या गंतव्य फ़ोल्डर से फ़ाइल को हटा देती है।
लेन-देन वर्ग के लिए कोड में, आप ExecutionContext.ExecutedPackage संपत्ति को देख सकते हैं, जो संदर्भ के भीतर निष्पादित पैकेज के संदर्भ का प्रतिनिधित्व करता है। इस लिंक को पैकेज क्लास के कंस्ट्रक्टर के अंदर इनिशियलाइज़ किया गया है। ध्यान दें कि पैकेज वर्ग में एक TransPPath गुण है जो पैकेज लेनदेन फ़ोल्डर के लिए पथ को इंगित करता है।

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

 private void LoadTransactions() { _transactions = new List<Transaction>(); if (String.IsNullOrEmpty(TransactionsPath) || !Directory.Exists(TransactionsPath)) { return; } string[] transactionNames = Directory.GetDirectories(TransactionsPath); foreach (string name in transactionNames) { string transactionPath = Path.Combine(TransactionsPath, name); string dataFilePath = Path.Combine(transactionPath, TRANSACTIONS_DATA_FILENAME); Transaction transaction = GinSerializers.TransactionSerializer.Deserialize(dataFilePath); _transactions.Add(transaction); } } 

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

 public void Rollback(string transactionName) { Transaction transaction = GetTransactionByName(transactionName); transaction.Rollback(); } public void Rollback() { foreach (Transaction transaction in _transactions) { transaction.Rollback(); } } public void AddTransaction(Transaction transaction) { _transactions.Add(transaction); } 

अब आइए जानें कि पैकेज के अंदर लेनदेन कैसे करें। मैं इस छद्मकोड के साथ ऐसा करना चाहूंगा:

 PackageBody body = new PackageBody() { Command = new CommandSequence() { Commands = new Command[] { new TransactionContainer() { TransactionName = "myTransaction", Commands = new List<Command>() { new CreateFile() { SourcePath = @"D:\test\newfile.txt", DestPath = @"C:\test\folder1\file1.txt" }, new CreateFile() { SourcePath = @"D:\test\newfile.txt", DestPath = @"C:\test\folder1\file2.txt" }, new ThrowException() { Message = "Test exception" }, new CreateFile() { SourcePath = @"D:\test\newfile.txt", DestPath = @"C:\test\folder1\file3.txt" } } } } } }; PackageBuilder builder = new PackageBuilder(body); string fileName = builder.GetResult(); Package pkg = new Package(fileName); ExecutionContext ctx = pkg.Execute(); 

जैसा कि आप देख सकते हैं, कक्षाओं की संरचना में काफी बदलाव आया है।

1. अब आप एक सिंगल कमांड को पैकेजबॉडी क्लास में पास कर सकते हैं, ज्यादातर मामलों में यह कमांडस्सेंस कमांड का एक उदाहरण होगा।
2. TransactionContainer कमांड से विरासत में मिली क्लास का इस्तेमाल कमांड के अनुक्रम को ट्रांजेक्शन में संयोजित करने के लिए किया जाता है। यह CommandSequence के समान है, लेकिन इसमें एक अतिरिक्त TransactionName पैरामीटर है।

TransactionContainer के अंदर, मैंने कई फ़ाइल निर्माण कमांड्स को नेस्ट किया, और उनके बीच एक अपवाद फेंक दिया। इस पैकेज का व्यवहार निम्नानुसार होगा:

1. पैकेज CreateFile फ़ाइलों को बनाने के लिए पहले दो कमांड निष्पादित करेगा।
2. तीसरे ThrowException कमांड पर, एक अपवाद फेंक दिया जाएगा और पैकेज निष्पादित करना बंद कर देगा, जिसका अर्थ है कि अंतिम CreateFile कमांड बिल्कुल भी निष्पादित नहीं करेगा
3. यह पैकेज myTransaction नामक लेनदेन रोलबैक प्रक्रिया के लिए आगे बढ़ेगा, इसमें शामिल दो CreateFile कमांड को वापस रोल करके।

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

1. काम करने के लिए पैकेज के लिए आवश्यक सभी फ़ोल्डर संरचना डिस्क पर बनाता है (पैकेज की फ़ाइल ट्री संरचना देखें)
2. पैकेजबॉडी क्लास के कमांड की डू () विधि को कॉल करता है।

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

 Transaction transaction = new Transaction() { TransactionName = TransactionName, TransactionState = TransactionState.Undefined }; try { context.Transactions.Add(transaction); foreach (Command command in Commands) { if (command is TransactionalCommand) { ((TransactionalCommand)command).Do(context, transaction); } else { command.Do(context); } } transaction.TransactionState = TransactionState.Active; } catch { transaction.Rollback(); } finally { transaction.Save(context); } 

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

• खाली रोलबैक विधि (TransactionStep)
• Do (ExecutionContext) विधि पहले की तरह ही बनी हुई है, अर्थात यह केवल एक नेस्टेड कमांड या कमांड को कंटेनर कमांड के आंतरिक तर्क के अनुसार निष्पादित करता है, Do (ExecutionContext) विधि को इसके या उनके एक तर्क के अनुसार लागू करता है।
• दो तर्कों के साथ Do (ExecutionContext, Transaction) विधि Do (ExecutionContext) विधि के आंतरिक तर्क को दोहराती है, लेकिन एक ही समय में यह जांच करती है कि किस से नेस्टेड कमांड या कमांड विरासत में मिली हैं, और यदि उसे TransactionalCommand से विरासत में मिला है, तो वह अपने Do (ExecutionContext) लेनदेन को कॉल करता है। अन्यथा, Do (ExecutionContext) विधि। यही है, नेस्टेड कमांड के लेन-देन का सत्यापन TransactionContainer वर्ग से कंटेनर क्लास में स्थानांतरित हो गया है।
• चूंकि कंटेनर कमांड पैरेंट ट्रांजैक्शन में अपना कदम नहीं बनाता है, Do (ExecutionContext, Transaction) विधि रिटर्न देती है।

जैसा कि ऊपर बताया गया है, CommandSecquence और ExecuteIf कक्षाएं अब इस तरह दिखती हैं:

 public class CommandSequence: TransactionalCommand { public List<Command> Commands; public override void Do(ExecutionContext context) { foreach (Command command in Commands) { command.Do(context); } } public override TransactionStep Do(ExecutionContext context, Transaction transaction) { foreach (Command command in Commands) { if (command is TransactionalCommand) { ((TransactionalCommand)command).Do(context, transaction); } else { command.Do(context); } } return null; } public override void Rollback(TransactionStep step) { } } public class ExecuteIf : TransactionalCommand { public string ArgumentName { get; set; } public Command Command { get; set; } public override void Do(ExecutionContext context) { if ((bool)context.GetResult(ArgumentName)) { Command.Do(context); } } public override TransactionStep Do(ExecutionContext context, Transactions.Transaction transaction) { if ((bool)context.GetResult(ArgumentName)) { if (Command is TransactionalCommand) { ((TransactionalCommand)Command).Do(context, transaction); } else { Command.Do(context); } } return null; } public override void Rollback(TransactionStep step) { } } 

अब हम किसी भी स्तर के घोंसले के कमांड वाले लेनदेन बना सकते हैं।

तीसरे भाग का लिंक