एक विधि पैरामीटर के रूप में सदस्य चर पास करना

Question

एक परियोजना में, मुझे इस तरह एक कोड मिला है:

class SomeClass
{
    private SomeType _someField;

    public SomeType SomeField
    {
        get { return _someField; }
        set { _someField = value; }
    }

    protected virtual void SomeMethod(/*...., */SomeType someVar)
    {
    }

    private void SomeAnotherMethod()
    {
        //.............
        SomeMethod(_someField);
        //.............
    }

};

मैं अपने साथियों को कैसे मनाऊँ कि यह बुरा कोड है?

मेरा मानना ​​है कि यह एक अनावश्यक जटिलता है। यदि आप पहले से ही इस तक पहुँच रखते हैं तो एक सदस्य चर को विधि पैरामीटर के रूप में क्यों पास करें? यह भी एनकैप्सुलेशन का उल्लंघन है।

क्या आप इस कोड के साथ कोई अन्य समस्या देखते हैं?

Comments

क्या आपको लगता है कि यह बुरा है?

— यनीस

@ यानिस रिज़ोस, आपको लगता है कि यह अच्छा है? कम से कम यह अनावश्यक जटिलता है। वैरिएबल को विधि पैरामीटर के रूप में क्यों पास किया जाता है, यदि आपके पास पहले से ही पहुंच है? यह एनकैप्सुलेशन का उल्लंघन है, साथ ही साथ।

— टीका

मान्य बिंदु, कृपया उन्हें शामिल करने के लिए प्रश्न संपादित करें। हम आपकी टीम के साथियों को समझाने में आपकी मदद नहीं कर सकते, लेकिन हम आपको कोड का मूल्यांकन करने में मदद कर सकते हैं, यही आपके प्रश्न के बारे में होना चाहिए।

— यनीस

मेरे पास एक ऐसा तरीका है जो एक विधि की तुलना में अलग-अलग चर को जोड़ सकता है जो निरंतर 2 + 2 करता है। विधि पर पैरामीटर पुन: प्रयोज्य के लिए है।

— दांते

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

— रेमी

Answer 1

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

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

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

अधिक बारूद और विचारों के लिए, मैं अंकल बॉब के क्लीन कोड की एक प्रति लेने की सलाह दूंगा ।

Comments

संदर्भित पुस्तक के प्रभाव को देखने के बाद डाउनवोट किया गया।

— फ्रैंक हिलमैन

हालाँकि मेरा छोटा सा हिस्सा बहुत दुखद है कि उत्तर लिखने के 5 साल बाद, आपने मुझसे केवल 2 इंटरनेट पॉइंट छीन लिए, मेरा एक और छोटा हिस्सा है जो उत्सुक है यदि आप कुछ संदर्भ प्रदान कर सकते हैं जो (संभवतः बुरा) का संकेत होगा मेरे द्वारा संदर्भित पुस्तक को प्रभावित करें। यह उचित और लगभग उन बिंदुओं के लायक प्रतीत होगा

— डीएक्सएम

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

— फ्रैंक हिलमैन

मस्तिष्क प्रसंस्करण चुनौतियों के बारे में संज्ञानात्मक भार

— jxramos

Answer 2

मैं सदस्य क्षेत्र को एक (निजी) पद्धति में एक पैरामीटर के रूप में पारित करने के औचित्य के बारे में सोच सकता हूं: यह स्पष्ट करता है कि आपकी विधि क्या निर्भर करती है।

जैसा कि आप कहते हैं, सभी सदस्य फ़ील्ड आपकी पद्धति के निहित पैरामीटर हैं, क्योंकि संपूर्ण ऑब्जेक्ट है। हालांकि, परिणाम की गणना करने के लिए वास्तव में पूर्ण वस्तु की आवश्यकता है? यदि SomeMethodएक आंतरिक विधि है जो केवल निर्भर करती है _someField, तो क्या यह निर्भरता को स्पष्ट करने के लिए क्लीनर नहीं है? वास्तव में, इस निर्भरता को स्पष्ट करने से यह संकेत भी मिल सकता है कि आप वास्तव में इस कोड को अपनी कक्षा से बाहर कर सकते हैं! (ध्यान दें कि हम यहां गेटर्स या सेटर के बारे में बात नहीं कर रहे हैं, लेकिन कोड जो वास्तव में कुछ गणना करता है)

मैं सार्वजनिक तरीकों के लिए एक ही तर्क नहीं करूंगा, क्योंकि फोन करने वाला न तो जानता है और न ही इस बात की परवाह करता है कि परिणाम का कौन सा भाग प्रासंगिक है ...

Comments

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

— एन्ड्रेस एफ

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

— स्टीवन एवर्स

@SnOrfus मैंने वास्तव में कक्षा से पूरी तरह से विधि को वापस लेने का सुझाव दिया था

— एंड्रेस एफ।

+1। "... क्या यह निर्भरता स्पष्ट करने के लिए क्लीनर नहीं है?" Abso-गुस्सा-loutely। यहाँ कौन कहेगा "वैश्विक चर एक सामान्य नियम के रूप में अच्छे हैं"? वह तो COBOL-68 है। मुझे अभी सुन लो और बाद में मेरा विश्वास करो। हमारे गैर-तुच्छ कोड में, कभी-कभी, स्पष्ट रूप से यह बताने के लिए कि कक्षा-वैश्विक चर का उपयोग कहां किया जाता है। हमने एक निजी क्षेत्र के ए) मनमाने ढंग से बैक-एन-आगे उपयोग द्वारा कई उदाहरणों में पेंच को खराब कर दिया है और यह सार्वजनिक संपत्ति है बी) "आश्रितों को छिपाते हुए" एक क्षेत्र के परिवर्तन को बाधित करता है। अब इसे 3-5 गहरी विरासत श्रृंखला द्वारा गुणा करें।

— राडारबॉब

@ इस पर मैं अंकल बॉब से असहमत हूं। जब भी संभव हो, तरीकों को कार्य-समान होना चाहिए और केवल स्पष्ट निर्भरता पर निर्भर होना चाहिए। (जब ओओपी में सार्वजनिक तरीकों को कॉल किया जाता है, तो इनमें से एक निर्भरता this(या self) है, लेकिन इसे कॉल द्वारा ही स्पष्ट किया जाता है obj.method(x))। अन्य अंतर्निहित निर्भरताएं वस्तु की स्थिति हैं; यह आमतौर पर कोड को समझने में कठिन बनाता है। जब भी संभव हो - और कारण के भीतर - निर्भरता स्पष्ट और कार्यात्मक शैली बनाते हैं। निजी तरीकों के मामले में, यदि संभव हो तो, स्पष्ट रूप से प्रत्येक पैरामीटर को पारित करें जिनकी उन्हें आवश्यकता है। और हाँ, यह उन्हें बाहर निकालने में मदद करता है।

— एंड्रेस एफ।

Answer 3

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

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

किसी कार्य के किसी सार्वजनिक कार्य के लिए सदस्य चर पास करते समय, जब कार्य को बाह्य रूप से बुलाता है, तब भी मेरी राय में एक प्रमुख कोड गंध का गठन होगा।

Comments

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

— मटनज़

@mattnz क्या कोई तरीका है जिससे आप ह्वाट की ग्रंथ सूची या आदर्श प्रोग्रामिंग के बारे में उनकी किसी भी पुस्तक के लिए लिंक प्रदान कर सकते हैं? मैं इंटरनेट खंगाल रहा हूं और उस पर कुछ नहीं पा रहा हूं। Google इसे "क्या" करने के लिए स्वतः पूर्ण करने का प्रयास करता रहता है।

— बुटिक बटुक

Answer 4

यदि फ़ंक्शन को कई बार कहा जाता है, तो उस सदस्य चर को कभी-कभी और कुछ और पास करने में, तो यह ठीक है। उदाहरण के लिए, मैं इस बुरे पर बिल्कुल भी विचार नहीं करूंगा:

if ( CalculateCharges(newStartDate) > CalculateCharges(m_StartDate) )
{
     //handle increase in charges
}

जहां newStartDateकुछ स्थानीय चर है और m_StartDateएक सदस्य चर है।

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

Comments

इससे कोई फर्क नहीं पड़ता कि विधि को सदस्य चर के अलावा अन्य मापदंडों के साथ कहा जाता है। जो मायने रखता है वह यह है कि इसे इस तरह से कहा जा सकता है । आप हमेशा यह नहीं जानते हैं कि जब आप इसे बना रहे होते हैं तो एक विधि को आखिरकार कैसे कहा जाएगा।

— कालेब

हो सकता है कि आपको "if" स्थिति को "needHandleIncreaseChages (newStartDate)" द्वारा बेहतर रूप से प्रतिस्थापित करना चाहिए और फिर आपका तर्क अब और नहीं रखता है।

— टारियन

Answer 5

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

Comments

आप जो याद कर रहे हैं वह यह है कि इस निजी सदस्य चर में सार्वजनिक एक्सेसर्स हैं।

— tika

तो आप कह रहे हैं कि संरक्षित आभासी विधि को एक निजी चर के सार्वजनिक अभिगमकर्ता पर निर्भरता लेनी चाहिए? और आपको वर्तमान कोड में कोई समस्या है?

— माइकल ब्राउन

सार्वजनिक एक्सेसरों का उपयोग किया जाता है। अवधि।

— टीका

Answer 6

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

invalidateRect(m_frame);

पूरे क्षेत्र के पुनर्विकास का कारण। उदाहरण के लिए, ऐसा तब हो सकता है जब इसे पहली बार पदानुक्रम में जोड़ा गया हो।

ऐसा करने में कुछ भी गलत नहीं है - दृश्य का फ्रेम एक मान्य आयत है, और दृश्य स्वयं जानता है कि यह स्वयं को फिर से बनाना चाहता है। दृश्य वर्ग एक अलग विधि प्रदान कर सकता है जो कोई पैरामीटर नहीं लेता है और इसके बजाय दृश्य फ़्रेम का उपयोग करता है:

invalidateFrame();

लेकिन सिर्फ इसके लिए एक विशेष विधि क्यों जोड़ें जब आप अधिक सामान्य उपयोग कर सकते हैं invalidateRect()? या, यदि आपने प्रदान करने का चयन किया है, तो आप invalidateFrame()शायद इसे अधिक सामान्य के संदर्भ में कार्यान्वित करेंगे invalidateRect():

View::invalidateFrame(void)
{
    invalidateRect(m_frame)
}

यदि आप पहले से ही इस तक पहुंच रखते हैं, तो चर को विधि पैरामीटर के रूप में क्यों पास करें?

यदि आप विधि को उस आवृत्ति चर पर विशेष रूप से संचालित नहीं करते हैं, तो आपको अपने स्वयं के तरीके के लिए उदाहरण चर को पास करना चाहिए । ऊपर दिए गए उदाहरण में, दृश्य का फ्रेम केवल एक और आयत है जहां तक विधि का संबंध है।invalidateRect()

Answer 7

यह समझ में आता है अगर विधि एक उपयोगिता विधि है। उदाहरण के लिए कहो कि आपको कई मुफ्त टेक्स्ट स्ट्रिंग्स से एक अद्वितीय संक्षिप्त नाम प्राप्त करने की आवश्यकता है।

आप प्रत्येक स्ट्रिंग के लिए एक अलग कार्यान्वयन को कोड नहीं करना चाहेंगे, बजाय स्ट्रिंग को एक सामान्य विधि से गुजरने से समझ में आता है।

हालाँकि अगर विधि हमेशा एक ही सदस्य पर काम करती है तो इसे पैरामीटर के रूप में पारित करने के लिए थोड़ा गूंगा लगता है।

Answer 8

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

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

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

Answer 9

इस बारे में सोचते समय कुछ बातें जो मेरे सामने आती हैं:

1. सामान्य तौर पर, कम मापदंडों वाले विधि हस्ताक्षर समझने में आसान होते हैं; एक बड़ा कारण तरीकों का आविष्कार किया गया था, जिससे वे जिस डेटा पर काम करते हैं, उनसे शादी करके लंबी पैरामीटर सूची को समाप्त कर सकते हैं।
2. विधि हस्ताक्षर को सदस्य चर पर निर्भर बनाने से भविष्य में उन चर को बदलना कठिन हो जाएगा, क्योंकि आपको न केवल विधि के अंदर बदलने की आवश्यकता है, बल्कि हर जगह विधि को भी कहा जाता है। और चूंकि आपके उदाहरण में SomeMethod संरक्षित है, इसलिए उपवर्गों को भी बदलना होगा।
3. तरीके (सार्वजनिक या निजी) जो वर्ग के आंतरिक पर निर्भर नहीं करते हैं, उन्हें उस वर्ग पर होने की आवश्यकता नहीं है। उन्हें उपयोगिता के तरीकों में उतारा जा सकता है और खुश रहना चाहिए। उनके पास कोई व्यवसाय नहीं है जो उस वर्ग का हिस्सा है। यदि विधि (ओं) को स्थानांतरित करने के बाद कोई अन्य विधि उस चर पर निर्भर नहीं करती है, तो उस चर को भी जाना चाहिए! सबसे अधिक संभावना है कि चर उस विधि या विधियों के साथ होना चाहिए जो उस पर काम करती है और सार्वजनिक हो रही है और मूल वर्ग द्वारा रचित है।
4. अपनी कक्षा जैसे विभिन्न कार्यों के लिए डेटा पास करना एक प्रक्रियात्मक कार्यक्रम है, जिसमें वैश्विक चर केवल OO डिजाइन के सामने उड़ते हैं। यह सदस्य चर और सदस्य कार्यों (ऊपर देखें) का आशय नहीं है, और ऐसा लगता है जैसे आपकी कक्षा बहुत सामंजस्यपूर्ण नहीं है। मुझे लगता है कि यह एक कोड गंध है जो आपके डेटा और विधियों को समूहीकृत करने का बेहतर तरीका सुझा रहा है।

Answer 10

आप याद कर रहे हैं यदि पैरामीटर ("तर्क") संदर्भ या केवल पढ़ने के लिए है।

class SomeClass
{
    protected SomeType _someField;
    public SomeType SomeField
    {
        get { return _someField; }

        set {
          if (doSomeValidation(value))
          {
            _someField = value;
          }
        }
    }

    protected virtual void ModifyMethod(/*...., */ ref SomeType someVar)
    { 
      // ...
    }    

    protected virtual void ReadMethod(/*...., */ SomeType someVar)
    { 
      // ...
    }

    private void SomeAnotherMethod()
    {
        //.............

        // not recommended, but, may be required in some cases
        ModifyMethod(ref this._someField);

        //.............

        // recommended, but, verbose
        SomeType SomeVar = this.someField;
        ModifyMethod(ref SomeVar);
        this.someField = SomeVar;

        //.............

        ReadMethod(this.someField);
        //.............
    }

};

कई डेवलपर्स, आमतौर पर निर्माण के तरीकों में एक चर के आंतरिक क्षेत्रों को सीधे असाइन करते हैं। कुछ अपवाद हैं।

याद रखें कि "सेटलर्स" में अतिरिक्त तरीके हो सकते हैं, न कि केवल असाइनमेंट, और कभी-कभी, यहां तक ​​कि वर्चुअल तरीके भी हो सकते हैं, या वर्चुअल तरीके कह सकते हैं।

नोट: मेरा सुझाव है कि "संरक्षित" के रूप में गुणों के आंतरिक क्षेत्रों को रखें।