👐🏼 ✊🏿 🤽🏻 .NET में स्ट्रिंग सुविधाएँ 🌪️ 👩🏽‍🤝‍👩🏼 👖

किसी भी प्रोग्रामिंग भाषा में स्ट्रिंग डेटा प्रकार सबसे महत्वपूर्ण है। इस डेटा प्रकार का उपयोग किए बिना एक उपयोगी कार्यक्रम लिखना मुश्किल है। हालांकि, कई डेवलपर्स इस प्रकार से जुड़ी कुछ बारीकियों को नहीं जानते हैं। तो आइए .NET में इस प्रकार की कुछ विशेषताओं को देखें।

तो, चलो स्मृति में तारों का प्रतिनिधित्व करके शुरू करते हैं

BNET तार BSTR (बेसिक स्ट्रिंग या बाइनरी स्ट्रिंग) नियम के अनुसार व्यवस्थित होते हैं। स्ट्रिंग डेटा का प्रतिनिधित्व करने के इस तरीके का उपयोग COM (VisualBasic प्रोग्रामिंग भाषा से मूल शब्द जिसमें यह मूल रूप से उपयोग किया गया था) में किया जाता है। जैसा कि C / C ++ में जाना जाता है, PWSZ का उपयोग स्ट्रिंग्स का प्रतिनिधित्व करने के लिए किया जाता है, जो पॉइंटर से लेकर वाइड-कैरेक्टर स्ट्रिंग, जीरो-टर्मिनेटेड के लिए है । रेखा के अंत में स्मृति में इस व्यवस्था के साथ एक शून्य-समाप्त चरित्र है, जिसके द्वारा हम पंक्ति के अंत का निर्धारण कर सकते हैं। PWSZ में स्ट्रिंग की लंबाई केवल मुफ्त मेमोरी की मात्रा तक सीमित है।

BSTR थोड़ा अलग है।

मेमोरी में स्ट्रिंग के BSTR प्रतिनिधित्व की मुख्य विशेषताएं:

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

तो, .NET में स्ट्रिंग्स को BSTR नियम के अनुसार मेमोरी में दर्शाया गया है। बफर में स्ट्रिंग की चार-बाइट लंबाई होती है, इसके बाद UTF-16 प्रारूप में स्ट्रिंग के डबल-बाइट वर्ण होते हैं, इसके बाद दो नल बाइट्स (\ u0000) होते हैं।

इस कार्यान्वयन का उपयोग करने के कई फायदे हैं: स्ट्रिंग की लंबाई को पुनर्गणना करने की आवश्यकता नहीं है, इसे हेडर में संग्रहीत किया जाता है, स्ट्रिंग में कहीं भी शून्य वर्ण हो सकते हैं, और सबसे महत्वपूर्ण स्ट्रिंग पता (पिन किया गया) को अप्रबंधित कोड में पारित किया जा सकता है जहां WARAR * बिना किसी समस्या के अपेक्षित है।

आगे जाकर…

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

मैं उन लेखों से मिला जहाँ यह लिखा था कि एक स्ट्रिंग ऑब्जेक्ट का आकार आकार = 20 + (लंबाई / 2) * 4 के बराबर है, लेकिन यह सूत्र पूरी तरह से सही नहीं है।
आरंभ करने के लिए, स्ट्रिंग एक संदर्भ प्रकार है, इसलिए पहले 4 बाइट्स में सिंकब्लॉकइंडेक्स होता है, और दूसरे 4 बाइट्स में एक सूचक होता है।

पंक्ति का आकार = 4 + 4 + ...

जैसा कि ऊपर उल्लेख किया गया है, स्ट्रिंग की लंबाई बफर में संग्रहीत की जाती है - यह प्रकार का एक क्षेत्र है int, जिसका अर्थ है 4 और बाइट्स।

पंक्ति का आकार = 4 + 4 + 4 + ...

प्रत्येक पंक्ति के अंत में एक स्ट्रिंग को अनवांटेड कोड (कॉपी किए बिना) में जल्दी से स्थानांतरित करने के लिए, एक शून्य-समाप्त वर्ण है, जिसका अर्थ है 2 बाइट्स, जिसका अर्थ है

पंक्ति का आकार = 4 + 4 + 4 + 2 + ...

यह याद रखना आवश्यक है कि स्ट्रिंग में प्रत्येक वर्ण UTF -16 एन्कोडिंग में है, जिसका अर्थ है कि यह 2 बाइट्स भी लेता है, इसलिए

स्ट्रिंग का आकार = 4 + 4 + 4 + 2 + 2 * लंबाई = 14 + 2 * लंबाई

हम एक और अधिक बारीकियों को ध्यान में रखेंगे, और हम लक्ष्य पर हैं। अर्थात्, CLR में मेमोरी मैनेजर 4 बाइट्स (4, 8, 12, 16, 20, 24, ...) के गुणकों में मेमोरी आवंटित करता है, अर्थात, यदि स्ट्रिंग की कुल लंबाई 34 बाइट्स पर कब्जा कर लेगी, तो 36 बाइट्स आवंटित की जाएंगी। हमें अपने मूल्य को निकटतम चार से अधिक से अधिक गुणा करना होगा, इसके लिए यह आवश्यक है:

स्ट्रिंग आकार = 4 * ((14 + 2 * लंबाई + 3) / 4) (विभाजन स्वाभाविक रूप से पूर्णांक)

संस्करण समस्या: संस्करण 4 से पहले .NET में, स्ट्रिंग वर्ग एक अतिरिक्त m_arrayLength फ़ील्ड के प्रकार int को संग्रहीत करता है, जो 4 बाइट्स लेता है। यह फ़ील्ड स्ट्रिंग के लिए आवंटित बफर की वास्तविक लंबाई है, जिसमें एक अशक्त वर्ण, अर्थात्, लंबाई + 1. है। .NET 4.0 में, इस फ़ील्ड को वर्ग से हटा दिया जाता है, जिसके परिणामस्वरूप स्ट्रिंग प्रकार ऑब्जेक्ट 4 बाइट्स कम लेता है।

M_arrayLength फ़ील्ड (यानी .NET 4.0 और उच्चतर) के बिना एक खाली रेखा का आकार = 4 + 4 + 4 + 2 = 14 बाइट्स है, और इस फ़ील्ड के साथ (यानी, .NET 4.0 से नीचे) यह = 4 + 4 + 4 + 4 है। + 2 = 18 बाइट्स। यदि आप 4 बाइट्स गोल करते हैं, तो क्रमशः 16 और 20 बाइट्स।

स्ट्रिंग सुविधाएँ

इसलिए, हमने जांच की कि तार का प्रतिनिधित्व कैसे किया जाता है, और वे वास्तव में स्मृति में कितना कब्जा करते हैं। अब बात करते हैं उनके फीचर्स की।

.NET में स्ट्रिंग्स की मुख्य विशेषताएं:

वे संदर्भ प्रकार हैं।
वे अपरिवर्तनीय हैं। एक बार, एक स्ट्रिंग बनाने के बाद, हम अब इसे (एक ईमानदार तरीके से) बदल नहीं सकते हैं। इस वर्ग की प्रत्येक विधि कॉल एक नई लाइन लौटाती है, और पिछली पंक्ति कचरा संग्राहक का शिकार बन जाती है।
वे Object.Equals विधि को ओवरराइड करते हैं, जिसके परिणामस्वरूप यह लिंक के मूल्यों की तुलना नहीं करता है, लेकिन स्ट्रिंग्स में वर्णों के मूल्यों की तुलना करता है।

प्रत्येक आइटम पर अधिक विस्तार से विचार करें।

स्ट्रिंग्स - संदर्भ प्रकार

स्ट्रिंग्स वास्तविक संदर्भ प्रकार हैं, अर्थात्, वे हमेशा ढेर पर स्थित होते हैं। कई लोग उन्हें सार्थक प्रकारों के साथ भ्रमित करते हैं, क्योंकि वे उसी तरह व्यवहार करते हैं, उदाहरण के लिए, वे अपरिवर्तनीय हैं और उनकी तुलना मूल्य से होती है, संदर्भ से नहीं, लेकिन याद रखें कि यह एक संदर्भ प्रकार है।

लाइनें अपरिवर्तनीय हैं

लाइनें अपरिवर्तनीय हैं। यह एक कारण के लिए किया जाता है। अपरिवर्तनीयता को कम करने के कई फायदे हैं:

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

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

यह देखते हुए कि लाइनें अपरिवर्तित हैं, वे लगातार हो सकते हैं, लेकिन वे नहीं हैं। .NET में, स्ट्रिंग्स अल्पकालिक हैं। आप इस बारे में अधिक पढ़ सकते हैं कि लिंक पर एरिक लिपर्ट के साथ वास्तव में ऐसा क्यों है

तुलना के लिए, जावा स्ट्रिंग्स को लें। वे अपरिवर्तनीय हैं, जैसा कि .NET में है, लेकिन लगातार भी। जावा में स्ट्रिंग वर्ग का कार्यान्वयन इस तरह दिखता है:

public final class String { private final char value[]; private final int offset; private final int count; private int hash; ..... }

ऑब्जेक्ट हेडर में समान 8 बाइट्स के अलावा, टाइप करने के लिए लिंक और सिंक्रोनाइज़ेशन ऑब्जेक्ट के लिए लिंक सहित, स्ट्रिंग्स में निम्न फ़ील्ड शामिल हैं:

चार चरित्र चरित्र के लिए लिंक;
चार सरणी में स्ट्रिंग के पहले चरित्र का सूचकांक (ऑफसेट यह शुरू हुआ);
प्रति पंक्ति वर्णों की संख्या;
हैशकोड () विधि के लिए पहली कॉल के बाद गणना की गई हैश कोड;

जैसा कि आप देख सकते हैं, जावा में स्ट्रिंग्स .NET की तुलना में अधिक मेमोरी लेते हैं, क्योंकि उनमें अतिरिक्त क्षेत्र होते हैं जो उन्हें लगातार बनाए रखने की अनुमति देते हैं। दृढ़ता के कारण, जावा में String.substring () विधि को O (1) में निष्पादित किया जाता है, क्योंकि इसे .NET में स्ट्रिंग की प्रतिलिपि बनाने की आवश्यकता नहीं होती है, जहां यह विधि O (n) में निष्पादित होती है।

जावा में String.substring () पद्धति का कार्यान्वयन:

 public String substring(int beginIndex, int endIndex) { if (beginIndex < 0) throw new StringIndexOutOfBoundsException(beginIndex); if (endIndex > count) throw new StringIndexOutOfBoundsException(endIndex); if (beginIndex > endIndex) throw new StringIndexOutOfBoundsException(endIndex - beginIndex); return ((beginIndex == 0) && (endIndex == count)) ? this : new String(offset + beginIndex, endIndex - beginIndex, value); } public String(int offset, int count, char value[]) { this.value = value; this.offset = offset; this.count = count; }

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

s = sssubstring (3)

कोड का उपयोग कर सकते हैं

s = नया स्ट्रिंग (sssubstring (3)),

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

जैसा कि यह जावा के नवीनतम संस्करण में निकला, स्ट्रिंग प्रकार कार्यान्वयन बदल गया है। xonix ने यह सुझाव दिया। अब कक्षा में कोई ऑफसेट और लंबाई फ़ील्ड नहीं है, और एक नया हैश 32 प्रकट हुआ है (एक अलग हैशिंग एल्गोरिथ्म के साथ)। इसका मतलब है कि पंक्तियाँ अब लगातार नहीं हैं। अब String.substring विधि हर बार एक नई लाइन बनाएगी।

स्ट्रिंग्स ऑब्जेक्ट को ओवरराइड करता है

स्ट्रिंग क्लास ऑब्जेक्ट को ओवरराइड करती है। परिणाम विधि, जिसके परिणामस्वरूप संदर्भ द्वारा नहीं, बल्कि मूल्य से तुलना की जाती है। मुझे लगता है कि डेवलपर स्ट्रिंग = वर्ग के रचनाकारों के लिए आभारी हैं == ऑपरेटर को ओवरराइड करने के लिए, क्योंकि स्ट्रिंग का उपयोग करने के लिए == कोड का उपयोग करते हुए विधि को कॉल करने की तुलना में अधिक सुरुचिपूर्ण दिखता है।

 if (s1 == s2)

तुलना में

 if (s1.Equals(s2))

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

स्ट्रिंग इंटर्निंग

खैर, और अंत में, स्ट्रिंग इंटर्निंग के बारे में बात करते हैं।
एक सरल उदाहरण पर विचार करें, कोड जो एक स्ट्रिंग को उलट देता है।

 var s = "Strings are immutuble"; int length = s.Length; for (int i = 0; i < length / 2; i++) { var c = s[i]; s[i] = s[length - i - 1]; s[length - i - 1] = c; }

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

वास्तव में, लाइन को बदला जा सकता है, लेकिन इसके लिए आपको असुरक्षित कोड का सहारा लेना होगा। एक उदाहरण पर विचार करें:

 var s = "Strings are immutable"; int length = s.Length; unsafe { fixed (char* c = s) { for (int i = 0; i < length / 2; i++) { var temp = c[i]; c[i] = c[length - i - 1]; c[length - i - 1] = temp; } } }

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

स्ट्रिंग इंटर्निंग एक ऐसा तंत्र है जिसमें समरूप शाब्दिक एक वस्तु को स्मृति में दर्शाते हैं।

यदि आप विवरण में गहराई से नहीं जाते हैं, तो स्ट्रिंग इंटर्निंग का अर्थ इस प्रकार है: एक प्रक्रिया के भीतर (एक प्रक्रिया, एक आवेदन डोमेन नहीं), एक आंतरिक हैश तालिका है, जिनमें से कुंजी तार हैं, और मान उनके संदर्भ हैं। जेआईटी संकलन के दौरान, शाब्दिक लाइनों को क्रमिक रूप से तालिका में दर्ज किया जाता है (तालिका में प्रत्येक पंक्ति केवल एक बार होती है)। रन टाइम में, शाब्दिक तार के संदर्भ इस तालिका से दिए गए हैं। आप String.Internate विधि का उपयोग करके रन टाइम पर आंतरिक तालिका में एक पंक्ति रख सकते हैं। आप यह भी जांच सकते हैं कि क्या String.IsInterned पद्धति का उपयोग करके आंतरिक तालिका में एक पंक्ति निहित है या नहीं।

 var s1 = "habrahabr"; var s2 = "habrahabr"; var s3 = "habra" + "habr"; Console.WriteLine(object.ReferenceEquals(s1, s2));//true Console.WriteLine(object.ReferenceEquals(s1, s3));//true

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

 var s = "Strings are immutable"; int length = s.Length; unsafe { fixed (char* c = s) { for (int i = 0; i < length / 2; i++) { var temp = c[i]; c[i] = c[length - i - 1]; c[length - i - 1] = temp; } } } Console.WriteLine("Strings are immutable");

यहां सब कुछ स्पष्ट प्रतीत होता है और इस तरह के कोड को प्रिंट करना चाहिए स्ट्रिंग्स अपरिवर्तनीय हैं । हालाँकि, नहीं! कोड elbatummi युग sgnirtS मुद्रित करेगा। यह इंटर्नमेंट ही है, स्ट्रिंग एस को बदलना, हम इसकी सामग्री को बदलते हैं, और चूंकि यह एक शाब्दिक है, यह इंटर्न और स्ट्रिंग के एक उदाहरण के रूप में प्रकट होता है।

असेंबली में विशेष CompilationRelaxationsAttribute विशेषता को लागू करके स्ट्रिंग इंटर्निंग से बचा जा सकता है। CompilationRelaxationsAttribute विशेषता CLR JIT संकलक द्वारा उत्पन्न कोड की सटीकता को नियंत्रित करता है। इस विशेषता का निर्माण कंपाइलररेलैक्सेशन एन्यूमरेशन को स्वीकार करता है, जिसमें वर्तमान में केवल कंप्लायेररेलैक्सेशन शामिल हैं। नॉनस्ट्रिंगइंटरटेनिंग - जो असेंबली की आवश्यकता के रूप में चिह्नित नहीं करता है।

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

यह पता चलता है कि .NET में तार अभी भी बदले जा सकते हैं यदि आप वास्तव में चाहते हैं, तो असुरक्षित कोड का उपयोग करके।

यदि असुरक्षित के बिना क्या होगा?

यह पता चला है कि प्रतिबिंब तंत्र का उपयोग करके, स्ट्रिंग की सामग्री को बदलना और असुरक्षित कोड का उपयोग किए बिना संभव था। यह ट्रिक .NET वर्जन 2.0 में शामिल किया जा सकता है, तब स्ट्रिंग क्लास के डेवलपर्स ने हमें इस तरह के अवसर से वंचित किया।
.NET 2.0 में, स्ट्रिंग वर्ग में दो आंतरिक विधियाँ हैं: SetChar , जो सीमा से बाहर जाने के लिए जाँच करता है, और InternalSetCharNoBoundsCheck , जो सीमा से बाहर जाने के लिए जाँच नहीं करता है, जो एक विशिष्ट सूचकांक पर निर्दिष्ट वर्ण सेट करता है। यहाँ उनका कार्यान्वयन है:

 internal unsafe void SetChar(int index, char value) { if ((uint)index >= (uint)this.Length) throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index")); fixed (char* chPtr = &this.m_firstChar) chPtr[index] = value; } internal unsafe void InternalSetCharNoBoundsCheck (int index, char value) { fixed (char* chPtr = &this.m_firstChar) chPtr[index] = value; }

इस प्रकार, निम्नलिखित कोड का उपयोग करके, आप असुरक्षित कोड का उपयोग किए बिना भी स्ट्रिंग की सामग्री को बदल सकते हैं।

 var s = "Strings are immutable"; int length = s.Length; var method = typeof(string).GetMethod("InternalSetCharNoBoundsCheck", BindingFlags.Instance | BindingFlags.NonPublic); for (int i = 0; i < length / 2; i++) { var temp = s[i]; method.Invoke(s, new object[] { i, s[length - i - 1] }); method.Invoke(s, new object[] { length - i - 1, temp }); } Console.WriteLine("Strings are immutable");

यह कोड, जैसा कि अपेक्षित था, एल्बाटुमी युग sgnirtS प्रिंट करेगा।

संस्करण प्रश्न: .NET फ्रेमवर्क के विभिन्न संस्करणों में, string.Empty इंटर्न कर सकते हैं या नहीं।
कोड पर विचार करें:

 string str1 = String.Empty; StringBuilder sb = new StringBuilder().Append(String.Empty); string str2 = String.Intern(sb.ToString()); if (object.ReferenceEquals(str1, str2)) Console.WriteLine("Equal"); else Console.WriteLine("Not Equal");

.NET फ्रेमवर्क 1.0 में, .NET फ्रेमवर्क 1.1, और .NET फ्रेमवर्क 3.5 SP1, str1 और str2 बराबर हैं। .NET फ्रेमवर्क 2.0 सर्विस पैक 1 (SP1) और .NET फ्रेमवर्क 3.0 में, str1 और str2 समान नहीं हैं। वर्तमान में string.Empty इंटर्निंग है।

प्रदर्शन सुविधाएँ

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

मुझे उम्मीद है कि यह लेख सहायक रहा है ...

.NET में स्ट्रिंग सुविधाएँ