String.Intern स्ट्रिंग्स को और भी दिलचस्प बनाता है

अनुवादक से प्रस्तावना:



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

String.Intern स्ट्रिंग्स को और भी दिलचस्प बनाता है

हर सी # नौसिखिया डेवलपर के पास आने वाली पहली चीजों में से एक तार के साथ काम कर रहा है। मैं "हेड फर्स्ट सी #" की शुरुआत में स्ट्रिंग्स के साथ काम करने की मूल बातें दिखाता हूं, जैसा कि वे लगभग हर दूसरे सी # बुक में करते हैं। इसलिए यह आश्चर्यजनक नहीं होना चाहिए कि सी # जूनियर और मध्यम स्तर के डेवलपर्स को लगता है कि उन्हें एक बहुत अच्छा लाइन-बाय-लाइन बेस मिल गया है। लेकिन रेखाएं जितनी दिलचस्प लगती हैं, उससे कहीं ज्यादा दिलचस्प हैं। C # और .NET में स्ट्रिंग्स के सबसे दिलचस्प पहलुओं में से एक String.Internate तरीका है। यह समझना कि यह विधि कैसे काम करती है, C # विकास में अपने कौशल को बेहतर बना सकती है। इस पोस्ट में, मैं आपको यह दिखाने के लिए कि यह कैसे काम करता है, स्ट्रिंग के लिए एक छोटा ट्यूटोरियल बना देगा।



नोट: इस पोस्ट के अंत में, ILDasm का उपयोग करके "हुड के नीचे" कुछ दिखाने जा रहा हूं। यदि आपने पहले ILDasm के साथ काम नहीं किया है, तो यह एक बहुत ही उपयोगी .NET टूल को जानने का एक अच्छा अवसर होगा।

तार के साथ काम करने की कुछ मूल बातें

चलिए System.String वर्ग की अपेक्षा के संक्षिप्त विवरण के साथ शुरू करते हैं। (मैं विवरणों में नहीं जाऊंगा - यदि कोई व्यक्ति .NET में स्ट्रिंग्स की मूल बातें के बारे में पोस्ट चाहता है, तो टिप्पणी जोड़ें या बिल्डिंग बेटर सॉफ़्टवेयर में मुझसे संपर्क करें, और मुझे एक साथ एक संभावित लेख पर चर्चा करने में खुशी होगी!)



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



Program.cs:

using System; class Program { static void Main(string[] args) { string a = "hello world"; string b = a; a = "hello"; Console.WriteLine("{0}, {1}", a, b); Console.WriteLine(a == b); Console.WriteLine(object.ReferenceEquals(a, b)); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस कोड में कोई आश्चर्य नहीं होना चाहिए। कार्यक्रम कंसोल को तीन पंक्तियाँ प्रदर्शित करता है (याद रखें, यदि आप विज़ुअल स्टूडियो में काम कर रहे हैं, तो डिबगर के बाहर प्रोग्राम को चलाने के लिए Ctrl-F5 का उपयोग करें; कंसोल विंडो को बंद करने से रोकने के लिए "किसी भी कुंजी दबाएं ..." को भी प्रोग्राम में जोड़ा जाएगा):



हैलो, हैलो दुनिया

झूठा

झूठा



पहला राइटलाइन () दो लाइनों को आउटपुट करता है। दूसरा उनकी तुलना समानता ऑपरेटर == का उपयोग करके करता है, जो गलत रिटर्न देता है क्योंकि तार मेल नहीं खाते हैं। और बाद वाले उनकी तुलना यह देखने के लिए करते हैं कि क्या दोनों चर एक ही स्ट्रिंग ऑब्जेक्ट को संदर्भित करते हैं। चूंकि यह मामला नहीं है, इसलिए विधि मान को गलत प्रदर्शित करती है।

फिर इन दोनों लाइनों को मुख्य () विधि के अंत में जोड़ें:

  Console.WriteLine((a + " world") == b); Console.WriteLine(object.ReferenceEquals((a + " world"), b));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और फिर, आपको एक बहुत स्पष्ट जवाब मिलता है। इक्विटी ऑपरेटर सही है , क्योंकि दोनों स्ट्रिंग्स समान हैं। लेकिन जब आपने "हेलो" और "वर्ल्ड" स्ट्रिंग्स के कॉन्सेप्टेशन का इस्तेमाल किया, तो + ऑपरेटर उन्हें कॉन्टेक्ट करता है और System.String का नया उदाहरण देता है। यही कारण है कि ऑब्जेक्ट। संदर्भ () काफी यथोचित रिटर्न देता है। ReferenceEquals () विधि केवल तभी सही होती है जब दोनों तर्क एक ही ऑब्जेक्ट को संदर्भित करते हैं।

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



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

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

इस लिंक के साथ कुछ गलत है ...

एक नया कंसोल एप्लिकेशन बनाएं। नीचे दिया गया कोड उसके लिए है। लेकिन, संकलन और निष्पादित करने से पहले, कोड को ध्यान से देखें। यह अनुमान लगाने की कोशिश करें कि यह कंसोल में क्या प्रदर्शित करेगा?



Program.cs:

 using System; class Program { static void Main(string[] args) { string hello = "hello"; string helloWorld = "hello world"; string helloWorld2 = hello + " world"; Console.WriteLine("{0}, {1}: {2}, {3}", helloWorld, helloWorld2, helloWorld == helloWorld2, object.ReferenceEquals(helloWorld, helloWorld2)); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अब प्रोग्राम चलाएं। यहाँ यह कंसोल में प्रदर्शित होता है:



हैलो वर्ल्ड, हैलो वर्ल्ड: ट्रू, फाल्स



और इसलिए, यह वही है जो हमने उम्मीद की थी। HelloWorld और helloWorld2 ऑब्जेक्ट में, स्ट्रिंग्स में "हैलो वर्ल्ड" होता है, इसलिए वे समान होते हैं, लेकिन लिंक अलग-अलग होते हैं।

अब इस कोड को अपने प्रोग्राम के निचले भाग में जोड़ें:

  helloWorld2 = "hello world"; Console.WriteLine("{0}, {1}: {2}, {3}", helloWorld, helloWorld2, helloWorld == helloWorld2, object.ReferenceEquals(helloWorld, helloWorld2));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इसे चलाएं। इस बार, कोड कंसोल में निम्नलिखित लाइन प्रदर्शित करता है:



हैलो वर्ल्ड, हैलो वर्ल्ड: ट्रू, ट्रू



रुको, यह पता चला है कि अब HelloWorld और HelloWorld2 एक ही पंक्ति को संदर्भित करते हैं? शायद कुछ को यह व्यवहार अजीब या कम से कम थोड़ा अप्रत्याशित लग सकता है। हमने helloWorld2 का मान बिल्कुल नहीं बदला। कई अंत में कुछ इस तरह सोचते हैं: “चर पहले से ही हैलो दुनिया के बराबर था। इसे हैलो दुनिया में स्थापित करने से एक बार और कुछ भी नहीं बदलना चाहिए। चलिए इसका पता लगाते हैं।

स्ट्रिंग क्या है।बाहर? (इंटर्नमेंट पूल में डूबते हुए ...)

सी # में स्ट्रिंग्स का उपयोग करते समय, सीएलआर कुछ मुश्किल करता है और इसे स्ट्रिंग इंटर्निंग कहा जाता है। यह किसी भी स्ट्रिंग की एक प्रति संग्रहीत करने का एक तरीका है। यदि आप एक लाख स्ट्रिंग चर में सौ या इससे भी बदतर, स्टोर करते हैं, तो समान मान यह निकलेगा कि स्ट्रिंग मानों को संग्रहीत करने के लिए मेमोरी को बार-बार आवंटित किया जाएगा। स्ट्रिंग इंटर्निंग इस समस्या का एक तरीका है। सीएलआर इंटर्नमेंट पूल नामक एक तालिका का समर्थन करता है। इस तालिका में प्रत्येक पंक्ति के लिए एक अद्वितीय लिंक है जिसे या तो घोषित किया गया है या आपके प्रोग्राम के निष्पादन के दौरान प्रोग्राम बनाया गया है। और .NET फ्रेमवर्क इंटर्निंग पूल के साथ बातचीत करने के लिए दो उपयोगी तरीके प्रदान करता है: String.Intern () और String.IsInterned () ।



String.Intern () विधि बहुत ही सरल तरीके से काम करती है। आप इसे एक तर्क के रूप में एक स्ट्रिंग पास करेंगे। यदि यह पंक्ति पहले से ही इंटर्नमेंट पूल में है, तो विधि इस पंक्ति का लिंक लौटा देती है। यदि यह पहले से नहीं है, तो यह पूल में एक पंक्ति जोड़ता है और इसके लिए एक लिंक देता है। यहाँ एक उदाहरण है:

  Console.WriteLine(object.ReferenceEquals( String.Intern(helloWorld), String.Intern(helloWorld2)));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह कोड तब भी सही प्रदर्शित होगा, जब HelloWorld और HelloWorld2 दो अलग-अलग स्ट्रिंग ऑब्जेक्ट्स को संदर्भित करते हैं, क्योंकि उनमें दोनों स्ट्रिंग "Hello World" हैं।

एक पल के लिए रुकिए। यह String.Intern () के साथ थोड़ी अधिक समझ के लायक है क्योंकि कभी-कभी यह विधि पहली नज़र में थोड़ा अतार्किक परिणाम देती है। यहाँ इस व्यवहार का एक उदाहरण है:

  string a = new string(new char[] {'a', 'b', 'c'}); object o = String.Copy(a); Console.WriteLine(object.ReferenceEquals(o, a)); String.Intern(o.ToString()); Console.WriteLine(object.ReferenceEquals(o, String.Intern(a)));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कोड को निष्पादित करने से कंसोल को दो लाइनें प्रिंट होंगी। पहली राइटलाइन () विधि गलत दिखाएगी, और यह स्ट्रिंग के बाद से समझ में आता है। कोपी () विधि स्ट्रिंग की एक नई प्रतिलिपि बनाता है और नई ऑब्जेक्ट के लिए एक लिंक देता है। लेकिन पहले क्यों String.Intern (about.ToString ()) को निष्पादित करके फिर String.Intern (a) के बारे में एक लिंक वापस करेगा? इसके बारे में सोचने के लिए एक पल के लिए रुकें। यदि आप तीन और लाइनें जोड़ते हैं तो यह और भी अधिक स्पष्ट हो जाता है:

  object o2 = String.Copy(a); String.Intern(o2.ToString()); Console.WriteLine(object.ReferenceEquals(o2, String.Intern(a)));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ऐसा लगता है कि कोड की इन पंक्तियों ने ऐसा ही किया, केवल नए ओ 2 ऑब्जेक्ट चर के साथ। लेकिन आखिरी में, WriteLine () झूठी उत्पादन करेगा। तो क्या चल रहा है?



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

शुरुआत में, लाइन नंबर 1 की वस्तु को एक अंक, जिसमें "एबीसी" शामिल है। चर o लाइन नंबर 2 की एक अन्य वस्तु की ओर इशारा करता है जिसमें "एबीसी" भी होता है। String.Intern (o.ToString ()) कॉलिंग लाइन नंबर 2 का संदर्भ आंतरिक पूल में जोड़ता है। अब, जब लाइन नंबर 2 का ऑब्जेक्ट इंटर्नमेंट पूल में है, तो किसी भी समय String.Intern () पैरामीटर "abc" के साथ कॉल करने पर लाइन नंबर 2 की ऑब्जेक्ट का संदर्भ वापस आ जाएगा।

इसलिए, जब आप चर o और String.Intern (a) से ReferenceEquals () विधि पास करते हैं, तो यह True लौटता है, क्योंकि String.Intern (a) ने पंक्ति संख्या 2 के ऑब्जेक्ट का संदर्भ दिया। अब हमने एक नया वैरिएबल O2 बनाया और एक और String ऑब्जेक्ट बनाने के लिए String.Copy () विधि का उपयोग किया। यह लाइन नंबर 3 का ऑब्जेक्ट होगा, जिसमें स्ट्रिंग "एबीसी" भी शामिल है। String.Intern (o2.ToString ()) कॉलिंग इस बार इंटर्नमेंट पूल में कुछ भी नहीं जोड़ता है क्योंकि "abc" पहले से ही है, लेकिन लाइन 2 नंबर के लिए एक पॉइंटर लौटाएगा।

तो यह कॉल इंटर्न () वास्तव में लाइन नंबर 2 के लिए एक संदर्भ देता है, लेकिन हम इसे एक चर पर असाइन करने के बजाय इसे छोड़ देते हैं। हम कुछ ऐसा कर सकते हैं: string q = String.Intern (o2.ToString ()) , जो q चर को पंक्ति # 2 की वस्तु का संदर्भ बना देगा। यही कारण है कि अंतिम लिस्टलाइन () आउटपुट को गलत बनाता है क्योंकि यह लाइन नंबर 3 के लिंक की तुलना लाइन नंबर 2 के लिंक के साथ है।

String.IsInterned () का उपयोग करके जांच करें कि कोई स्ट्रिंग इंटर्न पूल में है या नहीं

एक और, कुछ हद तक विरोधाभासी रूप से नामित विधि है, जो इंटर्नेड स्ट्रिंग्स के साथ काम करते समय उपयोगी है: String.IsInterned () । यह एक स्ट्रिंग ऑब्जेक्ट का संदर्भ लेता है। यदि यह स्ट्रिंग इंटर्नमेंट पूल में है, तो यह स्ट्रिंग के इंटर्न स्ट्रिंग का संदर्भ देता है; यदि यह पहले से ही इंटर्नमेंट पूल में नहीं है, तो विधि शून्य हो जाती है ।

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

जब IsInterned () विधि के साथ काम करते हैं, तो नल-सह-संचालक ऑपरेटर का उपयोग करना सुविधाजनक होता है - ?? यह प्रदर्शित करने के लिए कि स्ट्रिंग इंटर्नमेंट पूल में नहीं है। । उदाहरण के लिए, लेखन:

  string o = String.IsInterned(str) ?? "not interned";
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अब IsInterned () का परिणाम चर o पर वापस आ जाएगा यदि यह शून्य नहीं है, या स्ट्रिंग "इंटर्न नहीं है" यदि इंटर्नमेंट पूल में कोई रेखा नहीं है।

यदि ऐसा नहीं किया जाता है, तो Console.WriteLine () विधि खाली लाइनों का उत्पादन करेगी (जो कि शून्य होने पर यह विधि करती है )।

यहाँ एक सरल उदाहरण है कि String.IsInterned () कैसे काम करता है:

  string s = new string(new char[] {'x', 'y', 'z'}); Console.WriteLine(String.IsInterned(s) ?? "not interned"); String.Intern(s); Console.WriteLine(String.IsInterned(s) ?? "not interned"); Console.WriteLine(object.ReferenceEquals( String.IsInterned(new string(new char[] { 'x', 'y', 'z' })), s));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

पहला WriteLine () स्टेटमेंट कंसोल में "इंटर्न नहीं" प्रदर्शित करेगा क्योंकि "xyz" अभी तक इंटर्नमेंट पूल में नहीं है। दूसरा राइटलाइन () स्टेटमेंट "xyz" को प्रिंट करता है क्योंकि इंटर्नमेंट पूल में पहले से ही "xyz" होता है। और तीसरा WriteLine () True को आउटपुट करेगा, क्योंकि ऑब्जेक्ट s इंटर्नमेंट पूल में जोड़े गए ऑब्जेक्ट की ओर इशारा करता है।

साहित्य अपने आप में सहज है

विधि के अंत में सिर्फ एक पंक्ति जोड़कर और फिर से कार्यक्रम चलाएं:

  onsole.WriteLine(object.ReferenceEquals("xyz", ));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

पूरी तरह से अप्रत्याशित कुछ होगा!

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



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

यह समझना कि कार्यक्रम शुरू होने पर "xyz" पहले से ही इंटर्नमेंट पूल में है, क्योंकि यह स्ट्रिंग कोड में एक शाब्दिक के रूप में दिखाई देती है, प्रोग्राम के व्यवहार में ऐसा बदलाव तुरंत स्पष्ट हो जाता है। String.IsInterned (s) अब रिक्त नहीं है । इसके बजाय, यह शाब्दिक "xyz" का संदर्भ देता है, जो यह भी बताता है कि ReferenceEquals () गलत क्यों लौटाता है। ऐसा इसलिए है क्योंकि स्ट्रिंग एस को कभी भी इंटर्नमेंट पूल में नहीं जोड़ा जाएगा ("xyz" पूल में पहले से ही है, जो किसी अन्य ऑब्जेक्ट की ओर इशारा करता है)।

संकलक आपके विचार से अधिक स्मार्ट है!

कोड की अंतिम पंक्ति को इसमें बदलें:

  Console.WriteLine( object.ReferenceEquals("x" + "y" + "z", s));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रोग्राम चलाएं। यह ठीक वैसे ही काम करता है जैसे कि आप शाब्दिक "xyz" का उपयोग कर रहे थे! संचालक + नहीं है? क्या यह एक विधि नहीं है जो रनटाइम पर सीएलआर पर चलती है? यदि ऐसा है, तो ऐसा कोड होना चाहिए जो शाब्दिक "xyz" के आंतरिककरण को रोकता है।

वास्तव में, यह तब होगा जब आप "x" + "y" + "z" को String.Format ("{0} {1} {2}", 'x', 'y', 'z') से प्रतिस्थापित करेंगे। कोड की दोनों पंक्तियाँ "xyz" लौटाती हैं। फिर, + ऑपरेटर के साथ सहमति बनाने के लिए, क्या हमें व्यवहार मिलता है जैसे कि आप शाब्दिक "xyz" का उपयोग कर रहे थे, हालांकि उसी समय String.Format () को रन टाइम पर निष्पादित किया जाता है?

इस प्रश्न का उत्तर देने का सबसे आसान तरीका यह है कि कोड "x" + "y" + "z" को संकलित करते समय हमें वास्तव में क्या मिलता है।



Program.cs:

 using System; class Program { public static void Main() { Console.WriteLine("x" + "y" + "z"); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अगला कदम यह पता लगाना है कि संकलक ने एक निष्पादन योग्य प्रकार का आवेदन संकलित किया है। इसके लिए, हम ILDasm.exe, MSIL disassembler का उपयोग करेंगे। यह टूल विजुअल स्टूडियो (एक्सप्रेस संस्करण सहित) के हर संस्करण के साथ स्थापित है। और यहां तक ​​कि अगर आप आईएल पढ़ना नहीं जानते हैं, तो आप समझ सकते हैं कि क्या हो रहा है।



Ildasm.exe चलाएँ। यदि आप Windows के 64-बिट संस्करण का उपयोग कर रहे हैं, तो निम्न कमांड चलाएँ: "% ProgramFiles (x86)% \ Microsoft SDKs \ Windows \ v7.0A \ Bin \ Ildasm.exe" (उद्धरण चिह्नों सहित), प्रारंभ >> रन विंडो से , या कमांड लाइन से। यदि आप Windows के 32-बिट संस्करण का उपयोग कर रहे हैं, तो आपको निम्न कमांड चलाना चाहिए: "% ProgramFiles% \ Microsoft SDKs \ Windows \ v7.0A \ Bin \ ildasm.exe" ।







यह ILDasm पहले रन पर कैसा दिखता है:







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







(यदि आपको इस बात पर ब्रश करने की आवश्यकता है कि असेंबली कैसे बनाई जाती है, तो इस पोस्ट को C # और .NET असेंबली और नेमस्पेस की समझ के लिए देखें)।

प्रोग्राम वर्ग का विस्तार करें और मुख्य () विधि पर डबल-क्लिक करें। इन चरणों के बाद, एक अस्वीकृत विधि कोड दिखाई देना चाहिए:







कोड में शाब्दिक "xyz" की उपस्थिति को देखने के लिए आपको IL को जानने की आवश्यकता नहीं है। यदि आप ILDasm को बंद करते हैं, और फिर "x" + "y" + "z" के बजाय "xyz" का उपयोग करने के लिए कोड को बदलते हैं, तो IL कोड पार्स होता है बिल्कुल वैसा ही दिखता है! ऐसा इसलिए है क्योंकि संकलन समय पर "xyz" के साथ "x" + "y" + "z" को बदलने के लिए कंपाइलर काफी स्मार्ट है, इसलिए आपको विधि कॉल पर अतिरिक्त संचालन खर्च नहीं करना होगा जो "xyz" हमेशा वापस आ जाएगा। और जब प्रोग्राम में शाब्दिक रूप से संकलित किया जाता है, तो सीएलआर कार्यक्रम शुरू होने पर इसे इंटर्नमेंट पूल में जोड़ता है।



इस लेख की सामग्री आपको C # और .NET में स्ट्रिंग इंटर्निंग के बारे में एक अच्छा विचार देना चाहिए। सिद्धांत रूप में, यह स्ट्रिंग इंटर्निंग के संचालन को समझने के लिए आवश्यक से भी अधिक है। यदि आप अधिक सीखने में रुचि रखते हैं, तो MSDN के स्ट्रिंग के प्रदर्शन विचार अनुभाग। इन्टरनेट पेज एक अच्छा आधार है ।



पुनश्च: अनुवाद की उनकी कठिन प्रूफरीडिंग और वस्तुनिष्ठ आलोचना के लिए टीम को धन्यवाद।