आप encapsulating कब रोकते हैं?

Question

मेरे पास एक सीमा वर्ग पर कुछ इवेंट हैंडलर है जो किसी दिए गए जेनेरिक लेनदेन के लिए एक दृढ़ता तंत्र का प्रबंधन करता है:

void MyBoundaryClass::MyEventHandler(...) 
{ 
    //retrieve stuff from the UI 
    //... 
    //declare and initialize trasaction to persist 
    SimpleTransaction myTransaction(.../*pass down stuff*/); 
    //do some other checks 
    //... 
    //declare transaction persistor 
    TransactionPersistor myPersistor(myTransaction, .../*pass down connection to DB and other stuff*/); 
    //persist transaction 
    try 
    { 
    myPersistor.Persist(); 
    } 
    catch(...) 
    { 
    //handle errors 
    } 
} 

क्या सरल ट्रांज़ेक्शन और ट्रांसएक्शनपीर्सिस्टर ऑब्जेक्ट्स को लपेटने के लिए किसी प्रकार का ट्रांज़ेक्शन मैनेजर बेहतर होगा?

क्या अंगूठे का कोई उपयोगी नियम समझने के लिए है कि मुझे एक और स्तर के encapsulation की आवश्यकता है?

इस समय अंगूठे का नियम मैं पालन करता हूं "यदि विधि बहुत बड़ी हो जाती है - इसके बारे में कुछ करें"। कभी-कभी सीमा घटना हैंडलरों से निपटने के दौरान प्रक्रियात्मक और ऑब्जेक्ट उन्मुख के बीच सही संतुलन ढूंढना मुश्किल होता है।

कोई राय?

चीयर्स

Answer 1

यह देखते हुए कि:

• concept of encapsulation एक कंटेनर को परिभाषित करने के बारे में है, और
• वस्तु उन्मुख डिजाइन (तरीकों में से मंगलाचरण)

गुजर संदेश की अवधारणा पर आधारित है

मैं तर्क दूंगा कि एपीआई एक नए उच्च स्तरीय encapsulation (आईई।) के pertinence के बारे में एक अच्छा संकेत है। एक नई वस्तु की परिभाषा)

यदि इस नई वस्तु द्वारा प्रदान की जाने वाली सेवाओं (यानी एपीआई) सुसंगत हैं, और एक विशेष वस्तु में पुन: समूहित होने पर शेष कार्यक्रम के लिए बेहतर संपर्क किया जाता है, तो हर तरह से उपयोग करें एक नई वस्तु

अन्यथा, यह एक ओवरकिल संभव है।

चूंकि आप एक नई वस्तु, परीक्षण की धारणा बनाने कि नई वस्तु के भीतर करना आसान (और कुछ अन्य नकली वस्तुओं) हो सकता है द्वारा एक सार्वजनिक एपीआई का पर्दाफाश करने के बजाय कई बनाने विरासत वस्तुओं को उसी परिचालन का परीक्षण करने के लिए।

यदि आप लेनदेन का परीक्षण करना चाहते हैं, तो आपको वास्तव में UI से डेटा पुनर्प्राप्त करने के लिए MyBoundaryClass के MyEventHandler का परीक्षण करना होगा।

लेकिन अगर आप एक TransactionManager परिभाषित करते हैं, कि आप विभिन्न वास्तुकला का स्तर (जीयूआई बनाम डेटा) MyBoundaryClass में मौजूद कम युग्मन का अवसर देता है, और एक समर्पित वर्ग में डेटा प्रबंधन निर्यात करने के लिए।
फिर, आप स्वतंत्र परीक्षण परिदृश्य में डेटा दृढ़ता का परीक्षण कर सकते हैं, विशेष रूप से सीमा मानों पर ध्यान केंद्रित कर सकते हैं, और डेटाबेस विफलता, और मामूली स्थितियां, आदि।

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

चूंकि यह तर्क दिया जा सकता है कि Coupling and Cohesion are two cornerstones of OO Programming, लेनदेन प्रबंधक जैसी नई कक्षा के संयोजन का मूल्यांकन किए जाने वाले कार्यों के सेट की अवधि में मूल्यांकन किया जा सकता है।

संवेदना का अर्थ है कि एक निश्चित वर्ग बारीकी से संबंधित कार्यों का एक सेट करता है। दूसरी तरफ, एकजुटता की कमी का मतलब है कि एक वर्ग कई असंबंधित कार्यों का प्रदर्शन कर रहा है। [...] एप्लिकेशन सॉफ़्टवेयर अंततः अप्रबंधनीय हो जाएगा क्योंकि अधिक से अधिक व्यवहार बिखरे हुए हैं और गलत जगहों पर समाप्त हो गए हैं।

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

उदाहरण के लिए, एक TransactionManager में से एक दिलचस्प पहलू यह पूरी तरह से लेन-देन की धारणा, संपुटित होगा जो होगा:

• लगभग बाकी प्रणाली च द्वारा अज्ञात हो जाते हैं, और अन्य वर्गों के बीच युग्मन को कम कर देंगे और 'लेनदेन'
• लेनदेन चरणों के आसपास अपने एपीआई को केंद्रित करके लेनदेन प्रबंधक की समेकन को मजबूत करता है (जैसे initTransaction(), persistTransaction(), ...), किसी भी लेनदेन उदाहरण के लिए किसी भी गेटर या सेटर से परहेज करना।

Answer 2

VonC के सुझाव पर विस्तार से चर्चा करते निम्नलिखित दिशा-निर्देशों पर विचार करें:

• आप ही कार्य कहीं और आह्वान करने के लिए, एक ही तरह से उम्मीद है, यह उन्हें एक नई वस्तु में संपुटित करने के लिए उचित है।

• यदि कोई फ़ंक्शन (या एक ऑब्जेक्ट) सुविधाओं का एक सेट प्रदान करता है जो व्यक्तिगत रूप से उपयोगी होते हैं, तो इसे छोटे घटकों में पुन: सक्रिय करना उचित होता है।

API के बारे में VonC के दृष्टिकोण एक उत्कृष्ट लिटमस टेस्ट है: प्रभावी इंटरफेस बनाते हैं, और वस्तुओं अक्सर स्पष्ट हो।

Answer 3

encapsulating का स्तर होना चाहिए जो सीधे आपके ऑब्जेक्ट के समेकन से जुड़ा हुआ हो। आपकी ऑब्जेक्ट को एक ही कार्य करना होगा या इसे कई वर्गों में विभाजित किया जाना चाहिए और इसके सभी व्यवहार और गुणों को समाहित करना चाहिए।

अंगूठे का एक नियम तब होता है जब यह आपके ऑब्जेक्ट का परीक्षण करने का समय होता है। यदि आप यूनिट परीक्षण कर रहे हैं और आपको एहसास है कि आप इसे अलग करने की कोशिश कर सकते हैं तो आप कई अलग-अलग चीजों (उसी क्षेत्र की कार्रवाई में नहीं) का परीक्षण कर रहे हैं।

आपके मामले के लिए, मैं आपके "लेनदेन प्रबंधक" के विचार के साथ समाहित होगा। इस तरह "लेनदेन प्रबंधक" संभाल करेगा कि कैसे लेनदेन काम करता है और "MyBoundaryClass" नहीं।