दिलचस्प पोस्ट
स्रोत और ImageView की पृष्ठभूमि के बीच अंतर क्या है एंड्रॉइड 5.0 के नीचे संस्करणों के लिए सामग्री डिज़ाइन की कॉम्बिबिलीटी? मैं ग्रहण में एक देशी पुस्तकालय (.so फ़ाइल) कैसे आयात करूँ? LINQ को इकाईयों की पहचान नहीं है क्लिक पर ट्विटर बूटस्ट्रैप एप पतन छुपाएं एलेप्से में आवेदन ढेर के आकार को कैसे बढ़ाएं? स्ट्रिंग में शब्दों का क्रम उलटा UIViewContentModeScaleAspectFill क्लिपिंग नहीं भरें "टीईआरएम" का प्रयोग कर सिग्नल हैंडलिंग एक बार में कई एनोटेशन दिखाने के लिए MKMapView को स्थानांतरित करना XMLHttpRequest का उपयोग करके डाक डेटा भेजें नेस्टेड लूपों को तोड़कर 2 डी टक्कर का पता लगाने के लिए क्वाटट्री एक्सकोड 4 प्रोजेक्ट और वास्तविक फ़ोल्डर का नाम बदलना मूल वस्तु को बदलने के लिए मैं एक एक्सटेंशन विधि कैसे प्राप्त करूं?

पूर्ववत इंजन के लिए डिजाइन पैटर्न

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

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

मैं कल्पना कर सकता हूं कि आप साधारण आज्ञाओं को कैसे बदलेंगे, जो ऑब्जेक्ट गुणों को बदलते हैं, लेकिन कैसे जटिल आज्ञाओं के बारे में? मॉडल में नई नोड ऑब्जेक्ट्स डालने और कुछ लाइन ऑब्जेक्ट्स को जोड़ने जैसे नए नोड्स के संदर्भ में

वह कैसे लागू होगा?

वेब के समाधान से एकत्रित समाधान "पूर्ववत इंजन के लिए डिजाइन पैटर्न"

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

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

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

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

पूर्ववत / फिर से लागू करना सरल है: अपनी कार्रवाई करें और एक नया चेकपॉइंट स्थापित करें; पिछला चेकपॉइंट को सभी ऑब्जेक्ट संस्करण रोलबैक करें

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

अगर आप जीओएफ बात कर रहे हैं, तो यादव पैटर्न विशेष रूप से पूर्ववत करता है।

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

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

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

अब, बेशक, बहुत से लोग खुद को सोच रहे हैं "अच्छा ड्यूह, यह कमांड पैटर्न का हिस्सा नहीं है?" हां, लेकिन मैंने बहुत सारे कमांड सिस्टम को देखा है, जिनके पास दो सेट कमांड हैं, एक तत्काल कार्रवाई के लिए और एक अन्य सेट / पूर्ववत करें / फिर से करें मैं यह नहीं कह रहा हूं कि ऐसे कमांड नहीं होंगे जो कि तत्काल आपरेशनों के लिए विशिष्ट हैं और पूर्ववत / फिर से करें, लेकिन दोहराव को कम करने से कोड को और अधिक संतोषणीय बना दिया जाएगा

आप उनके पूर्ववत के लिए Paint.NET कोड का उल्लेख कर सकते हैं – उन्हें वास्तव में अच्छा पूर्ववत सिस्टम मिला है यह संभवत: आपको जो की आवश्यकता होगी उससे थोड़ा सा सरल है, लेकिन यह आपको कुछ विचार और दिशानिर्देश दे सकता है

-Adam

यह ऐसा मामला हो सकता है जहां सीएसएलए लागू हो। यह विंडोज फॉर्म के अनुप्रयोगों में ऑब्जेक्ट को जटिल पूर्ववत समर्थन प्रदान करने के लिए डिज़ाइन किया गया था।

मैंने जटिल पूर्ववत सिस्टम को लागू किया है ताकि मिमेंटो पैटर्न का सफलतापूर्वक उपयोग किया जा सके- बहुत आसान है, और स्वाभाविक रूप से एक रेडो फ्रेमवर्क भी प्रदान करने का लाभ उठाया है एक और अधिक सूक्ष्म लाभ यह है कि कुल कार्रवाई एक भी पूर्ववत में भी शामिल की जा सकती है

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

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

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

कई पूर्ववत सिस्टम केवल इन-मेमोरी हैं, लेकिन यदि आप चाहें तो आप पूर्ववत स्टैक को जारी रख सकते हैं, मुझे लगता है

बस मेरी फुर्तीली विकास पुस्तक में आदेश पैटर्न के बारे में पढ़ रहा था – हो सकता है कि इसकी क्षमता हो?

आप प्रत्येक कमांड कमांड इंटरफ़ेस को लागू कर सकते हैं (जिसमें एक एक्जिक्यूट () विधि है)। यदि आप पूर्ववत करना चाहते हैं, तो आप पूर्ववत विधि जोड़ सकते हैं।

अधिक जानकारी यहां

मैं इस तथ्य पर Mendelt Siebenga के साथ हूँ कि आपको कमांड पैटर्न का उपयोग करना चाहिए। आप जिस पैटर्न का इस्तेमाल करते थे वह यादव पैटर्न था, जो समय के साथ बहुत ही बेकार हो सकता है।

चूंकि आप मेमोरी-गहन अनुप्रयोग पर काम कर रहे हैं, इसलिए आपको यह निर्दिष्ट करने में सक्षम होना चाहिए कि पूर्ववत इंजन को कितना मेमोरी लेने की इजाजत है, कितने स्तर पूर्ववत सहेजे गए हैं या कुछ स्टोरेज जो वे जारी रहेंगे। आप ऐसा नहीं करना चाहिए, आपको जल्द ही मशीन की स्मृति से होने वाली त्रुटियों का सामना करना होगा।

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

अधिकांश उदाहरण मैंने पढ़ा है या तो कमांड या स्मृति चिन्ह पैटर्न का उपयोग कर। लेकिन आप इसे एक सरल डेक-संरचना के साथ भी डिजाइन पैटर्न के बिना कर सकते हैं।

संदर्भ के लिए, यहाँ कमांड पैटर्न का एक साधारण कार्यान्वयन है जो C # में पूर्ववत / रीडो के लिए है:

http://www.catnapgames.com/blog/2009/03/19/simple-undo-redo-system-for-csharp.html

पूर्ववत को संभालने के लिए एक चतुर तरीका है, जो आपके सॉफ़्टवेयर को बहु उपयोगकर्ता सहयोग के लिए उपयुक्त बना देगा, डेटा संरचना का परिचालन परिवर्तन कार्यान्वित कर रहा है ।

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

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

ऑब्जेक्ट्स के लिए पॉइंटर्स (सी ++) के कारण बहुत से बग हैं, जिन्हें कभी भी तय नहीं किया गया था, जैसा कि आप कुछ अवांछित पूर्ववत करें पुनः अनुक्रम (उन स्थानों को सुरक्षित नहीं पूर्ववत करने के लिए "आइडेंटिफ़ायर" को अद्यतन नहीं करते हैं) करते हैं। इस क्षेत्र में अक्सर कीड़े … ummm … दिलचस्प

गति / संसाधन के उपयोग के लिए कुछ परिचालन विशेष मामलों हो सकते हैं – जैसे चीजों को बदलना, चीजें घूमते हुए।

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

मुझे ऐसा करने के लिए एक पांग-कूद पहेली खेल के लिए एक solver लिखते समय किया था। मैंने प्रत्येक कदम को कमान ऑब्जेक्ट बनाया था जो कि पर्याप्त जानकारी रखी थी जिसे यह या तो किया या पूर्ववत किया जा सकता था मेरे मामले में यह प्रारंभिक स्थिति और प्रत्येक चाल की दिशा को संचय के रूप में सरल था। फिर मैंने इन सभी वस्तुओं को एक स्टैक में संग्रहीत किया, ताकि प्रोग्राम आसानी से कई कदमों को पूर्ववत कर सके क्योंकि बैक ट्रैकिंग की आवश्यकता होती है।

मैंने एक बार एक आवेदन पर काम किया था जिसमें आवेदन के मॉडल (यानी सीडीकास्ट … हम एमएफसी का उपयोग कर रहे थे) द्वारा किए गए सभी बदलाव मॉडल के भीतर रखे गए आंतरिक डेटाबेस में फ़ील्ड को अद्यतन करके कमांड के अंत में बने रहेंगे। इसलिए प्रत्येक कार्रवाई के लिए हमें अलग पूर्ववत / फिर से कोड लिखना नहीं था पूर्ववत स्टैक में हर समय एक रिकॉर्ड (प्रत्येक कमांड के अंत में) बदल दिया गया था, केवल प्राथमिक कुंजी, फ़ील्ड नाम और पुरानी मान याद किया।

डिज़ाइन पैटर्न (जीओएफ, 1 99 4) का पहला खंड एक डिजाइन पैटर्न के रूप में पूर्ववत / फिर से लागू करने के लिए उपयोग का मामला है।

मेरी राय में, यूएनडीओ / आरईडीओ को 2 तरीकों में मोटे तौर पर लागू किया जा सकता है। 1. कमांड लेवल (कमान स्तर को पूर्ववत करें / पुन: नाम दिया गया है) 2. दस्तावेज़ स्तर (जिसे वैश्विक पूर्ववत / रेडो कहते हैं)

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

सीमा: एक बार जब आदेश का दायरा समाप्त हो जाता है, तो पूर्ववत / फिर से करना असंभव है, जिससे दस्तावेज़ स्तर (वैश्विक) को वापस / फिर से करना असंभव होता है

मुझे लगता है कि आपका मुकदमा वैश्विक पूर्ववत / पुनः में फिट होगा क्योंकि यह एक मॉडल के लिए उपयुक्त है जिसमें बहुत सारे स्मृति स्थान शामिल हैं I इसके अलावा, यह चुनिंदा पूर्ववत / फिर से भी करना उपयुक्त है। दो आदिम प्रकार हैं

  1. सभी स्मृति पूर्ववत करें / फिर से करें
  2. वस्तु स्तर पूर्ववत करें को फिर से करें

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

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

1 और 2 दोनों के तरीके हो सकते हैं जैसे कि 1. पहलेउन्डो () 2.उत्पाद () 3.Redo () 4.Redo () के बाद। इन विधियों को मूल पूर्ववत / रीडो कमांड (संदर्भ कमांड नहीं) में प्रकाशित किया जाना है ताकि सभी ऑब्जेक्ट्स इन विधियों को भी विशिष्ट कार्रवाई करने के लिए लागू कर सकें।

एक अच्छी रणनीति 1 और 2 के संकर बनाना है। सौंदर्य यह है कि इन तरीकों (1 और 2) स्वयं कमांड पैटर्न का उपयोग करते हैं

आप अपने प्रारंभिक विचार performant कर सकते हैं

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

आप PostSharp में पूर्ववत / पुन: प्रतिमान पैटर्न के तैयार-किए गए कार्यान्वयन का प्रयास कर सकते हैं। https://www.postsharp.net/model/undo-redo

यह आपको स्वयं को लागू करने के बिना अपने एप्लिकेशन को पूर्ववत / फिर से कार्यप्रणाली जोड़ने देता है यह आपके मॉडल में परिवर्तनों को ट्रैक करने के लिए रिकॉर्ड करने योग्य पैटर्न का उपयोग करता है और यह INotifyPropertyChanged पैटर्न के साथ काम करता है जो PostSharp में कार्यान्वित भी होता है।

आपको यूआई नियंत्रणों के साथ प्रदान किया गया है और आप यह तय कर सकते हैं कि प्रत्येक ऑपरेशन का नाम और ग्रैन्यूलिटी क्या होगा।

मुझे नहीं पता कि यह आपके लिए किसी भी तरह का उपयोग होने जा रहा है, लेकिन जब मेरी किसी एक परियोजना पर ऐसा कुछ करना था, तो मैंने एंडोइंजिन को http://www.undomadeeasy.com से डाउनलोड करना समाप्त कर दिया – एक अद्भुत इंजन और मैं वास्तव में बोनट के तहत क्या था के बारे में बहुत ज्यादा परवाह नहीं है – यह सिर्फ काम किया है।