.NET में चरों को मान असाइन करने का अधिक प्रभावी तरीका कौन सा है?

Question

यह ऐसा कुछ है जिसे मैंने हमेशा के बारे में सोचा है, लेकिन कभी भी प्रोफ़ाइल पर परेशान नहीं है।

क्या यह मान का उपयोग जारी रखने के बजाय एक अस्थायी चर के लिए मान असाइन करने के लिए अधिक कुशल है। एक उदाहरण से स्पष्ट हो सकता है:

string s = reader.GetItem[0].ToString(); 
someClass.SomeField = s; 
someOtherClass.someField = s; 

या

someClass.SomeField = reader.GetItem[0].ToString(); 
someOtherClass.someField = reader.GetItem[0].ToString(); 

मेरे प्रारंभिक सोचा शीर्ष उदाहरण के रूप में यह मद संग्रह पहुंच सकता है या ToString कॉल करने के लिए नहीं है और अधिक कुशल हो जाएगा।

अन्य लोगों के विचारों, या निश्चित उत्तर को किसी भी तरह से सुनने में रुचि होगी।

Answer 1

कंपाइलर यह नहीं जान सकता कि दायीं तरफ की अभिव्यक्ति के दुष्प्रभाव हैं, इसलिए यदि आप इसे दो बार कोड करते हैं तो इसे फिर से मूल्यांकन करना होगा। इसलिए पहली बार इस अर्थ में अधिक कुशल है कि यह GetItem & ToString कॉल को फिर से नहीं करेगा।

तो यदि आप प्रोग्रामर जानते हैं कि ये कॉल शुद्ध/बेवकूफ हैं, तो आपको कोड को पहली बार लिखना चाहिए।

Answer 2

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

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

Answer 3

Brian के रूप में, पहला तरीका अधिक कुशल होगा, भले ही यह वास्तविक दुनिया में बहुत अंतर डालता है, भले ही डुप्लिकेट किए गए कार्यों कितने महंगे हों, और पूरे कोड के इस टुकड़े को कितनी बार बुलाया जाता है।

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

Answer 4

मेरे पास स्थानीय चर में एक मूल्य संग्रहीत करने की आदत है यदि मैं इसे एक से अधिक बार उपयोग करने जा रहा हूं। आम तौर पर, हालांकि, ऐसा इसलिए है क्योंकि मैं दक्षता के बारे में चिंतित होने के बजाय कोड की कॉम्पैक्टनेस पसंद करता हूं - हालांकि, अगर मैं लूप में बार-बार इसका उपयोग कर रहा हूं तो मैं निश्चित रूप से ऐसा करूँगा।

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

Answer 5

यहां अंगूठे का मेरा नियम है। संदेह में, profile your code। एक अनुकूलन कंपाइलर बहुत सारे कोड को हटा सकता है जिससे आपका कोड तेजी से चल रहा है।

दो तथ्यों पर भी विचार किया जाना चाहिए:

• नेट बहुत जल्दी स्मृति आवंटित करता है।
• अतिरिक्त कचरा अतिरिक्त पृष्ठ दोषों, संदर्भ के खराब इलाके, अत्यधिक कचरा संग्रह के कारण आपके आवेदन को धीमा कर सकता है।

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

Answer 6

पठनीयता मामलों। नामित चर के उपयोग का क्या उपयोग है?

इसके अलावा, [0] का उपयोग करने के बजाय, एक फ़ील्ड नाम अधिक समझ में आ जाएगा।

Answer 7

वहाँ

एक और विकल्प है - समग्र काम:

someOtherClass.someField = someClass.SomeField = reader.GetItem[0].ToString(); 

इस प्रयोग के साथ

संकलक reader.GetItem[0].ToString() एक बार का मूल्यांकन करेंगे, और इसका इस्तेमाल दोनों सदस्यों (करने के लिए आवंटित करने के लिए यह है someClass की get का उपयोग नहीं)। यह स्टैक पर मान को डुप्लिकेट करके करता है (जिसे स्पष्ट स्थानीय की आवश्यकता नहीं होती है)।

बहुत ही कुशल, लेकिन ईमानदार होने के लिए मैं एक चर के साथ मूल के बारे में बहुत उत्साहित नहीं होगा।

Answer 8

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

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

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