.NET में कुशल स्ट्रिंग कॉन्सेप्टन

.NET प्रोग्रामर के लिए, उनके कार्यक्रमों के प्रदर्शन को बेहतर बनाने के लिए पहले युक्तियों में से एक है "स्ट्रिंग स्ट्रैटब्यूटरी को कॉनटेननेट स्ट्रेट का उपयोग करें"। जैसे " अपवाद का उपयोग करना महंगा है, " सहमति का बयान अक्सर गलत समझा जाता है और एक हठधर्मिता में बदल जाता है। सौभाग्य से, यह अपवाद प्रदर्शन के मिथक जितना विनाशकारी नहीं है, लेकिन यह बहुत अधिक सामान्य है।

यह अच्छा होगा यदि आप इस लेख को पढ़ने से पहले मेरे पिछले लेख को .NET में स्ट्रिंग्स के बारे में पढ़ें। और, पठनीयता के नाम पर, अब से मैं .NET में स्ट्रिंग्स को केवल स्ट्रिंग्स के साथ नामित करूंगा, न कि "स्ट्रिंग" या "System.String"।

मैंने इस लेख को सामान्य रूप से .NET फ्रेमवर्क के बारे में लेखों की सूची में शामिल किया था, और सी # -स्पेशल लेखों की सूची में नहीं, क्योंकि मेरा मानना ​​है कि .NET प्लेटफ़ॉर्म पर हूड के अंतर्गत आने वाली सभी भाषाओं में समान स्ट्रिंग संघनन तंत्र है।

जिस समस्या को वे सुलझाने की कोशिश कर रहे हैं

स्ट्रिंग्स की एक बड़ी सरणी को समवर्ती करने की समस्या, जिसमें परिणामी स्ट्रिंग बहुत तेज़ी से और तेज़ी से बढ़ती है, बहुत वास्तविक है, और स्ट्रिंगबर्न को कॉननेटेटेट का उपयोग करने की सलाह बहुत सही है। यहाँ एक उदाहरण है:

using System; public class Test { static void Main() { DateTime start = DateTime.Now; string x = ""; for (int i=0; i < 100000; i++) { x += "!"; } DateTime end = DateTime.Now; Console.WriteLine ("Time taken: {0}", end-start); } } 

मेरे अपेक्षाकृत तेज़ लैपटॉप पर, इस कार्यक्रम को पूरा होने में लगभग 10 सेकंड लगे। यदि आप पुनरावृत्तियों की संख्या को दोगुना करते हैं, तो निष्पादन का समय एक मिनट तक बढ़ जाएगा। .NET 2.0 बीटा 2 पर, परिणाम थोड़े बेहतर हैं, लेकिन इतना नहीं। खराब प्रदर्शन की समस्या यह है कि लाइनें अपरिवर्तनीय हैं, और इसलिए, " += " ऑपरेटर को लागू करते समय, अगले पुनरावृत्ति पर लाइन पहले के अंत में नहीं जोड़ी जाती है। वास्तव में एक्सप्रेशन x += "!"; एक्सप्रेशन x = x+"!"; बिल्कुल बराबर है x = x+"!"; । यहां, संघनन एक पूरी तरह से नई रेखा का निर्माण है, जिसके लिए आवश्यक मात्रा में मेमोरी आवंटित की जाती है, जिसमें मौजूदा मूल्य x की सामग्री की प्रतिलिपि बनाई जाती है, और फिर समवर्ती स्ट्रिंग की सामग्री की प्रतिलिपि बनाई जाती है ( "!" )। परिणामस्वरूप पंक्ति बढ़ती है, इसलिए डेटा की मात्रा जो हर समय आगे और पीछे कॉपी की जाती है, और इसीलिए जब मैंने पुनरावृत्तियों की संख्या दोगुनी की, समय दोगुना से अधिक हो गया।

यह संघटन एल्गोरिथ्म निश्चित रूप से अक्षम है। आखिरकार, अगर कोई आपको खरीदारी की सूची में कुछ जोड़ने के लिए कहता है, तो आप पूरी सूची को जोड़ने से पहले कॉपी नहीं करेंगे, है ना? इसी तरह से हम स्ट्रिंगबुलस्टल के पास जाते हैं।

StringBuilder का उपयोग करना

और यहाँ उपरोक्त कार्यक्रम के समतुल्य ( x के समान अंतिम मूल्य के अर्थ में समतुल्य) है, जो कि बहुत अधिक है, बहुत तेज़ है:

 using System; using System.Text; public class Test { static void Main() { DateTime start = DateTime.Now; StringBuilder builder = new StringBuilder(); for (int i=0; i < 100000; i++) { builder.Append("!"); } string x = builder.ToString(); DateTime end = DateTime.Now; Console.WriteLine ("Time taken: {0}", end-start); } } 

मेरे लैपटॉप पर, यह कोड इतनी तेजी से चलता है कि समय-मापने वाला तंत्र जो मैं उपयोग करता है वह अक्षम है और संतोषजनक परिणाम नहीं देता है। पुनरावृत्तियों की संख्या में एक मिलियन (यानी, प्रारंभिक संख्या की तुलना में 10 गुना अधिक, जिसमें कार्यक्रम के पहले संस्करण को 10 सेकंड के लिए निष्पादित किया गया था) में वृद्धि के साथ, निष्पादन समय 30-40 मिलीसेकंड तक बढ़ जाता है। इसके अलावा, निष्पादन समय पुनरावृत्तियों की संख्या में लगभग रैखिक रूप से बढ़ता है (यानी पुनरावृत्तियों की संख्या को दोगुना करके, निष्पादन समय भी दोगुना हो जाएगा)। यह प्रदर्शन कूद अनावश्यक प्रतिलिपि ऑपरेशन को समाप्त करके प्राप्त किया जाता है - केवल डेटा जो परिणामस्वरूप पंक्ति से जुड़ा हुआ है, की प्रतिलिपि बनाई गई है। StringBuilder में इसका आंतरिक बफ़र होता है और इसे बनाए रखता है, और जब एक स्ट्रिंग जोड़ा जाता है, तो यह इसकी सामग्री को बफ़र में कॉपी करता है। जब नई जुड़ने वाली लाइनें बफर में फिट नहीं होती हैं, तो इसकी सभी सामग्रियों के साथ नकल की जाती है, लेकिन पहले से ही बड़े आकार के साथ। अनिवार्य रूप से, स्ट्रिंगब्यूलर का आंतरिक बफर एक ही साधारण स्ट्रिंग है; स्ट्रिंग्स केवल उनके सार्वजनिक इंटरफेस के संदर्भ में अपरिवर्तनीय हैं, लेकिन mscorlib विधानसभा की mscorlib से mscorlib । स्ट्रिंग स्ट्रिंग के कंस्ट्रक्टर में स्ट्रिंग के अंतिम आकार (लंबाई) को निर्दिष्ट करके इस कोड को और भी अधिक उत्पादक बनाना संभव होगा (आखिरकार, इस स्थिति में हम कंसट्रक्शन के शुरू होने से पहले स्ट्रिंग के आकार की गणना कर सकते हैं), जिसके लिए स्ट्रिंगबर्लियर का आंतरिक बफर बिल्कुल उपयुक्त बनाया जाएगा। परिणामी स्ट्रिंग आकार, और संघनन की प्रक्रिया में इसे प्रतिलिपि के माध्यम से नहीं बढ़ाना होगा। इस स्थिति में, आप परिणामी स्ट्रिंग की लंबाई को निर्धारित करने से पहले निर्धारित कर सकते हैं, लेकिन फिर भी यदि आप नहीं कर सकते हैं, तो यह कोई फर्क नहीं पड़ता - बफर भरते समय और इसे कॉपी करते समय, स्ट्रिंगब्यूलर नई कॉपी के आकार को दोगुना कर देता है, इसलिए बफर के इतने सारे भरने और कॉपी नहीं होंगे।

तो जब मैं हमेशा स्ट्रैंगब्यूटील का उपयोग करता हूं, तो क्या करना चाहिए?

संक्षेप में, नहीं। उपरोक्त सभी स्पष्ट करता है कि क्यों "स्ट्रिंग के लिए स्ट्रिंग का उपयोग करें" कथन कुछ स्थितियों में सही हो सकता है। इसी समय, कुछ लोग मूल बातें समझे बिना इस कथन को एक हठधर्मिता के रूप में लेते हैं, और परिणामस्वरूप, वे ऐसे कोड को फिर से तैयार करना शुरू करते हैं:

 string name = firstName + " " + lastName; Person person = new Person (name); 

इस तरह:

 // Bad code! Do not use! StringBuilder builder = new StringBuilder(); builder.Append (firstName); builder.Append (" "); builder.Append (lastName); string name = builder.ToString(); Person person = new Person (name); 

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

इसके अलावा, वास्तव में, StringBuilder के साथ दूसरा संस्करण, पहले की तुलना में कम उत्पादक है, हालांकि बहुत अधिक नहीं है। और अगर दूसरा संस्करण पहले की तुलना में अधिक आसानी से माना जाता था, तो पिछले पैराग्राफ से तर्क के बाद मैं कहूंगा - इसका उपयोग करें; लेकिन जब StringBuilder वाला संस्करण कम पठनीय और कम उत्पादक होता है, तो इसका उपयोग करना सिर्फ बकवास है।

यदि हम मानते हैं कि पहला नाम और अंतिम नाम "वास्तविक" चर हैं और न कि स्थिरांक (उस पर अधिक), तो पहला संस्करण एक स्ट्रिंग में संकलित किया जाएगा। फोन कॉल, कुछ इस तरह से:

 string name = String.Concat (firstName, " ", lastName); Person person = new Person (name); 

String.Concat विधि एक इनपुट के रूप में स्ट्रिंग्स (या ऑब्जेक्ट) का एक सेट लेती है और उन्हें एक नई लाइन में, और स्पष्ट रूप से "glues" करती है। String.Concat के अलग-अलग अधिभार हैं - कुछ कई स्ट्रिंग्स लेते हैं, कुछ प्रकार के Object कई चर लेते हैं (जो समाप्‍त होने पर स्ट्रिंग्स में परिवर्तित हो जाते हैं), और कुछ स्ट्रिंग या ऑब्जेक्ट के सरणियों को लेते हैं। सभी ओवरलोड एक ही काम करते हैं। वास्तव में संघनन प्रक्रिया शुरू करने से पहले, String.Concat इसे पास किए गए सभी स्ट्रिंग्स की लंबाई पढ़ता है (कम से कम यदि आप इसे स्ट्रिंग्स पास करते हैं - यदि आप टाइप Object चर पास करते हैं, तो प्रत्येक ऐसे चर के लिए String.Concat एक नया अस्थायी (इंटरमीडिएट) स्ट्रिंग बनाएगा और संक्षिप्त करेगा) पहले से ही)। इसके कारण, संघनन के समय, स्ट्रिंग.कंकेट सही ढंग से "जानता है" जिसके परिणामस्वरूप स्ट्रिंग की लंबाई है, जिसके कारण यह इसके लिए एक बिल्कुल आकार का बफर आवंटित करता है, और इसलिए कोई अनावश्यक प्रतिलिपि संचालन नहीं हैं, आदि।

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

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

स्थिरांक

स्थिरांक की बात आने पर स्थिति और भी तनावपूर्ण हो जाती है (मैं स्ट्रिंग स्ट्रिंग के रूप में घोषित स्ट्रिंग शाब्दिक के बारे में बात कर रहा हूं)। आपको क्या लगता है कि string x = "hello" + " " + "there"; अभिव्यक्ति string x = "hello" + " " + "there"; को संकलित किया जाएगा string x = "hello" + " " + "there"; ? यह मानना ​​तर्कसंगत है कि String.Concat कहा जाएगा, लेकिन ऐसा नहीं है। वास्तव में, इस अभिव्यक्ति को निम्नलिखित में संकलित किया जाएगा: string x = "hello there"; । कंपाइलर जानता है कि स्ट्रिंग x सभी घटक संकलित समय स्थिरांक हैं, और इसलिए उन सभी को कार्यक्रम के संकलन के समय संक्षिप्त किया जाएगा, और "hello there" मान के साथ स्ट्रिंग x को संकलित कोड में संग्रहीत किया जाएगा। StringBuilder के तहत इस तरह के कोड का अनुवाद स्मृति की खपत और सीपीयू संसाधनों के संदर्भ में अप्रभावी है, न कि अक्षमता का उल्लेख करने के लिए।

समाधि के लिए अंगूठे के नियम

तो, स्ट्रिंगब्यूलर का उपयोग कब करना है, और "सरल" संयोजन कब करना है?

• निश्चित रूप से जब आप एक गैर-तुच्छ लूप में तारों को गाढ़ा करते हैं, और विशेष रूप से जब आप नहीं जानते (संकलन के समय), तो वास्तव में कितने पुनरावृत्तियों का प्रदर्शन किया जाएगा, जब स्ट्रिंगरिंग का उपयोग करें। उदाहरण के लिए, लूप में एक पुनरावृत्ति के भीतर एक समय में एक चरित्र को पढ़कर एक पाठ फ़ाइल की सामग्री को पढ़ना, और प्रदर्शन के मामले में += ऑपरेटर के माध्यम से उस चरित्र को संक्षिप्त रूप से आपके आवेदन को "मारना" होगा।
• निश्चित रूप से += ऑपरेटर का उपयोग करें यदि आप एक बयान में संक्षिप्त करने के लिए आवश्यक सभी तारों को निर्दिष्ट कर सकते हैं। यदि आपको स्ट्रिंग्स की एक सरणी को संक्षिप्त करने की आवश्यकता है, तो String.Concat पर एक स्पष्ट कॉल का उपयोग करें, और यदि इन स्ट्रिंग्स के बीच एक विभाजक की आवश्यकता है, तो String.Join का उपयोग करें ।
• कोड को कई हिस्सों में शाब्दिक रूप से तोड़ने और + माध्यम से उन्हें जोड़ने से डरो मत - परिणाम समान होगा। यदि आपके कोड में एक लंबा शाब्दिक स्ट्रिंग है, तो इसे कई सबस्ट्रिंग में तोड़ने से कोड की पठनीयता में सुधार होगा।
• यदि आपको कहीं और मध्यवर्ती परिणाम की आवश्यकता है , तो वास्तव में मध्यवर्ती परिणाम होने के अलावा (यानी, तार के अस्थायी भंडार के रूप में काम करते हैं, प्रत्येक पुनरावृत्ति पर बदलते हुए), फिर स्ट्रिंगब्यूलर आपकी मदद नहीं करेगा। उदाहरण के लिए, यदि आप पहले और अंतिम नाम को जोड़कर एक पूरा नाम बनाते हैं, और फिर स्ट्रिंग के अंत में तीसरा तत्व (उदाहरण के लिए, लॉगिन) जोड़ते हैं, तो स्ट्रिंगब्रुइट केवल तभी उपयोगी होगा जब आपको स्वयं द्वारा स्ट्रिंग (प्रथम नाम + अंतिम नाम) का उपयोग करने की आवश्यकता न हो। एक लॉगिन के बिना, कहीं और (जैसा कि हमने उदाहरण में किया था, नाम और उपनाम के आधार पर Person उदाहरण बनाकर)।
• यदि आपको कई सब्सट्रेट को समेटने की आवश्यकता है, और आप स्ट्रिंग के माध्यम से एक ही बयान में उन्हें संक्षिप्त नहीं कर सकते हैं। कॉनकट, तो "क्लासिकल" - या स्ट्रिंगबर्टल कंसट्रक्शन का विकल्प एक विशेष भूमिका नहीं निभाएगा। यहाँ, गति उनकी लंबाई पर, साथ ही साथ उस क्रम पर जिसमें रेखाएँ समतल होंगी, में शामिल लाइनों की संख्या पर निर्भर करेगा। अगर आपको लगता है कि कंसट्रक्शन प्रदर्शन की अड़चन है और आप निश्चित रूप से सबसे तेज़ विधि का उपयोग करना चाहते हैं, तो दोनों तरीकों के प्रदर्शन को मापें और उसके बाद ही सबसे तेज़ चुनें।