क्या यह वास्तव में एक सुधार है (आंतरिक गुंजाइश लूप में आंतरिक गुंजाइश है)?

Question

Resharper सिफारिश की है कि इन वार्स:

List<string> senderDeviceIDList; 
string senderDeviceID; 
. . . 
      foreach (var item in PlatypiIds) 
      { 
       senderDeviceIDList = await GetSenderDeviceIDForSenderID(item); 
       senderDeviceID = senderDeviceIDList[0]; 

... भीतरी दायरे में घोषित किया जा सकता है, तो जैसे:

foreach (var item in PlatypiIds) 
    { 
     List<string> senderDeviceIDList = await GetSenderDeviceIDForSenderID(item); 
     string senderDeviceID = senderDeviceIDList[0]; 

... लेकिन यह वास्तव में "अधिक बेहतर" है? क्या ऐसा नहीं है कि वर्रों को एन बार घोषित किया जा सके (एक बार प्रत्येक फोरच लूप के लिए)?

Answer 1

कोई प्रदर्शन या स्मृति आवंटन यहाँ के मामले में किसी भी लाभ चर अंदर या oustside if दायरे सेIL घोषित किये गए हैं, वैसे ही, है।

केवल लाभ चर गुंजाइश के स्थानीयकरण है। यह गुंजाइश उपयोग की जा रही है, जो की तरह अच्छाई लाता में ले जाएँ:

• आसान पुनर्रचना (सबसे महत्वपूर्ण हो सकता है)

• पठनीयता। आप गुंजाइश अंदर चर देखते हैं, तो आप जानते हैं कि इसके लिए प्रयोग किया जाता है कि गुंजाइश अंदर केवल और अगर आप कुछ चर कि जाहिरा तौर पर अंदर नहीं है देखते हैं, आप जानते हैं कि इसे बदलने कोड के अन्य भागों को प्रभावित कर सकते हैं। तो यह कुछ संभावित खतरे परिचय बदल रहा है।

संक्षेप में, यह आपके द्वारा लिखे गए कोड की पठनीयता और प्रयोज्यता के बारे में है और कोई प्रदर्शन या स्मृति खपत लाभ नहीं पेश करता है।

Answer 2

क्या ऐसा नहीं है कि वर्रों को एन बार घोषित किया जा सके (प्रत्येक फोरैच लूप के लिए एक)?

तार्किक रूप से, देखने के एक वैचारिक बिंदु से हाँ, और उस बिंदु है! तर्कसंगत रूप से वे एक बार प्रति लूप मौजूद हैं और लूप के दायरे से बाहर कोई समझ नहीं है।

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

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

Answer 3

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

आप foreach लूप (बालों) के अंत में अपने अंतिम अवस्था में उन वस्तुओं का उपयोग करने के लिए आवश्यक है, तो आप 1 दृष्टिकोण के साथ जाने के लिए कर सकते हैं।

Answer 4

कभी कभी लाभ मौजूद है।

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