🤲 👩‍🎤 👨‍💻 StringBuilder अतीत और वर्तमान 👐🏿 👞 👜

प्रविष्टि

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

जैसा कि आप जानते हैं, .NET में स्ट्रिंग्स अपरिवर्तनीय हैं (असुरक्षित का उपयोग किए बिना), और इसलिए, बड़ी मात्रा में उनके साथ एक कॉनटेनमेंट ऑपरेशन करना एक अच्छा विचार नहीं है। इसका मतलब है कि निम्नलिखित कोड में बहुत गंभीर मेमोरी लोड समस्याएं हैं:

string s = string.Empty; for (int i = 0; i < 100; i++) { s += "T"; }

इस कोड के बारे में इतना बुरा क्या है? और तथ्य यह है कि प्रत्येक पुनरावृत्ति पर एक पंक्ति बनाई जाती है जो पिछले चरण की तुलना में एक इकाई लंबी होती है, इसके बाद पुरानी रेखा से वर्णों की प्रतिलिपि बनाई जाती है। इस प्रकार, शामिल वर्णों की कुल संख्या के बराबर है:

यह सूत्र और कुछ नहीं बल्कि अंकगणितीय प्रगति का योग है:

यही है, इस तरह के एक कॉन्सेप्टन परिदृश्य को O (n ² ) के अनुपात में मेमोरी की आवश्यकता होती है, n स्ट्रिंग की लंबाई है।

ऐसे कोड में समस्याओं को ठीक करने के लिए, हम StringBuilder वर्ग का उपयोग करते हैं, यह जानते हुए कि इसके साथ संचालन करने से स्ट्रिंग के रूप में ऐसी मेमोरी अपशिष्ट नहीं होती है। वास्तव में, StringBuilder एक उत्परिवर्ती स्ट्रिंग है।

 var strB = new StringBuilder(); for (int i = 0; i < 100; i++) { strB.Append("T"); } string str = strB.ToString();

ऐसा कोड, हालांकि सभी दोषों के बिना नहीं, और हवा में कुछ स्मृति को बर्बाद करता है, लेकिन क्या यह पिछले कोड की तुलना में अधिक संयमित है।

StringBuilder वर्ग का कार्यान्वयन पिछले संस्करणों की तुलना में .NET 4.0 में नाटकीय रूप से बदल गया है, इसलिए मुझे लगता है कि यह लिखना दिलचस्प होगा कि इसके साथ क्या हुआ।

.NET 2.0 में StringBuilder

.NET 2.0 में StringBuilder वर्ग के निम्नलिखित क्षेत्र हैं:

 public sealed class StringBuilder : ISerializable { internal const int DefaultCapacity = 16; private const string CapacityField = "Capacity"; private const string MaxCapacityField = "m_MaxCapacity"; private const string StringValueField = "m_StringValue"; private const string ThreadIDField = "m_currentThread"; internal IntPtr m_currentThread; internal int m_MaxCapacity; internal volatile string m_StringValue; <------------------------------------- }

m_currentThread - उस थ्रेड का पहचानकर्ता जिसमें ऑब्जेक्ट का उदाहरण बनाया गया था;
m_MaxCapacity - इस उदाहरण की अधिकतम क्षमता;
m_StringValue एक स्ट्रिंग है जिसमें वर्ण हैं।

वास्तव में, StringBuilder वर्ग आंतरिक रूप से स्ट्रिंग डेटा प्रकार स्ट्रिंग के साथ काम करता है। चूंकि mscorlib.dll की ओर के तार परस्पर भिन्न हैं, इसलिए StringBuilder ने m_StringValue में स्थित स्ट्रिंग को बदलने के लिए कुछ भी खर्च नहीं किया।

प्रारंभिक लंबाई 16 वर्ण है, और यदि नए वर्ण जोड़ने के लिए पर्याप्त स्थान नहीं है, तो StringBuilder लंबे समय तक दो बार एक स्ट्रिंग के साथ आंतरिक स्ट्रिंग की जगह लेती है और पिछले + नए लोगों से नए बनाए गए सभी वर्णों को कॉपी करती है। एक स्ट्रिंग की लंबाई दोगुनी होने से रैखिक जटिलता (O (n)) की स्मृति में परिणाम होता है, जो द्विघात के विपरीत होता है, जो साधारण तारों में निहित होता है।

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

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

परिशिष्ट () विधि

स्रोत कोड

  public StringBuilder Append(string value) { if (value == null) return this; string currentString = this.m_StringValue; IntPtr currentThread = Thread.InternalGetCurrentThread(); if (this.m_currentThread != currentThread) currentString = string.GetStringForStringBuilder(currentString, currentString.Capacity); int length = currentString.Length; int requiredLength = length + value.Length; if (this.NeedsAllocation(currentString, requiredLength)) //       { //    2          string newString = this.GetNewString(currentString, requiredLength); newString.AppendInPlace(value, length); this.ReplaceString(currentThread, newString); //    } else { currentString.AppendInPlace(value, length); this.ReplaceString(currentThread, currentString); } return this; }

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

सम्मिलित करें () विधि

स्रोत कोड

  public StringBuilder Insert(int index, string value) { if (value == null) return this.Insert(index, value, 0); else return this.Insert(index, value, 1); } public StringBuilder Insert(int index, string value, int count) { IntPtr tid; string threadSafeString = this.GetThreadSafeString(out tid); int length = threadSafeString.Length; if (value != null && value.Length != 0) { if (count != 0) { int requiredLength; try { requiredLength = checked (length + value.Length * count);//    } catch (OverflowException ex) { throw new OutOfMemoryException(); } if (this.NeedsAllocation(threadSafeString, requiredLength))//       { //    2          string newString = this.GetNewString(threadSafeString, requiredLength); newString.InsertInPlace(index, value, count, length, requiredLength);//   this.ReplaceString(tid, newString);//    } else { threadSafeString.InsertInPlace(index, value, count, length, requiredLength); this.ReplaceString(tid, threadSafeString); } return this; } } return this; }

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

निकालें () विधि

स्रोत कोड

 public StringBuilder Remove(int startIndex, int length) { IntPtr tid; string threadSafeString = this.GetThreadSafeString(out tid); int length1 = threadSafeString.Length; //  ,      threadSafeString.RemoveInPlace(startIndex, length, length1); this.ReplaceString(tid, threadSafeString);//    return this; }

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

ToString () विधि

स्रोत कोड

 public override string ToString() { string str = this.m_StringValue; if (this.m_currentThread != Thread.InternalGetCurrentThread() || 2 * str.Length < str.ArrayLength) return string.InternalCopy(str);//   str.ClearPostNullChar(); this.m_currentThread = IntPtr.Zero; return str; //     }

यह विधि, जैसा कि कार्यान्वयन से देखा जा सकता है, या तो स्ट्रिंग की एक प्रति या उस स्ट्रिंग को लौटाता है जिस पर यह संचालित होता है। एक नियम के रूप में, इस पद्धति का पहला कॉल मूल स्ट्रिंग का लिंक लौटाता है, इसलिए यह बहुत जल्दी किया जाता है, हालांकि, प्रत्येक बाद की कॉल स्ट्रिंग को कॉपी करने की ओर ले जाती है। .NET 2.0 में StringBuilder वर्ग इस पद्धति की गति पर जोर देता है।

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

.NET 4.0 में StringBuilder

जैसा कि मैंने कहा, .NET 4.0 में StringBuilder वर्ग का कार्यान्वयन बदल गया है। अब, वर्णों को संग्रहीत करने के लिए स्ट्रिंग के बजाय चार [] का उपयोग किया जाता है, और वर्ग स्वयं स्ट्रिंग स्ट्रिंगब्यूल्डर्स की एक सूचीबद्ध सूची है जैसे रोपस्ट्रीमिंग।

इस परिवर्तन का कारण काफी स्पष्ट है: इस तरह के कार्यान्वयन के साथ, यह कम होने पर मेमोरी को फिर से स्थापित करने के लिए आवश्यक नहीं है, जो पिछले कार्यान्वयन में अंतर्निहित है। इसका मतलब यह भी है कि ToString () विधि थोड़ा धीमा काम करती है, क्योंकि अंतिम तार पहले बनना चाहिए, और परिशिष्ट () विधि तेजी से काम करती है क्योंकि इसे कॉपी करने की आवश्यकता नहीं होती है। हालाँकि, यह StringBuilder के लिए विशिष्ट उपयोग के मामले में फिट बैठता है: Append () के लिए कई कॉल, और फिर ToString () में एक कॉल।

.NET 4.0 में StringBuilder वर्ग के निम्नलिखित क्षेत्र हैं:

 public sealed class StringBuilder : ISerializable { internal const int DefaultCapacity = 16; internal const int MaxChunkSize = 8000; internal char[] m_ChunkChars; <------------------------------------- internal StringBuilder m_ChunkPrevious; <------------------------------------- internal int m_ChunkLength; internal int m_ChunkOffset; internal int m_MaxCapacity; private const string CapacityField = "Capacity"; private const string MaxCapacityField = "m_MaxCapacity"; private const string StringValueField = "m_StringValue"; private const string ThreadIDField = "m_currentThread"; }

m_ChunkChars - लिंक की गई सूची के वर्तमान तत्व (स्ट्रिंग का एक टुकड़ा) के पात्रों से युक्त एक सरणी;
m_ChunkPrepret - सूची में पिछले तत्व ( स्ट्रिंगबर्ल ) से लिंक;
m_ChunkLength - वर्तमान सूची आइटम की वास्तविक लंबाई (उपयोग किए गए वर्णों की संख्या);
m_ChunkOffset - स्ट्रिंग द्वारा प्रयुक्त वर्णों की कुल संख्या (तार्किक लंबाई);
m_MaxCapacity - StringBuilder के वर्तमान उदाहरण की अधिकतम क्षमता।

.NET फ्रेमवर्क 4 और .NET फ्रेमवर्क 4.5 में, जब आप StringBuilder कंस्ट्रक्टर (Int32, Int32) को कॉल करके एक StringBuilder ऑब्जेक्ट को इंस्टाल करते हैं, तो StringBuilder उदाहरण की लंबाई और क्षमता इसकी MaxCapacity संपत्ति के मूल्य से परे बढ़ सकती है। यह विशेष रूप से तब हो सकता है जब एपेंड और एपेंडफार्म सिस्टम को बुलाते हैं।

MaxChunkSize सूची आइटम की अधिकतम लंबाई 8000 है। जैसा कि आप जानते हैं, यह एक कारण के लिए किया गया था। यहाँ वर्ग डेवलपर्स से एक टिप्पणी है:

हम सुनिश्चित करने के लिए बड़े ऑब्जेक्ट हीप (<85K बाइट्स ~ 40K चार्ट) से बाहर चंक सरणियों को रखना चाहते हैं। अधिकतम चंक आकार बड़ा बनाने का मतलब कम आवंटन कोड कहा जाता है, लेकिन अप्रयुक्त पात्रों और धीमी आवेषण / जगह में अधिक अपशिष्ट भी।

हम चाहते हैं कि चरित्र सरणी बड़ी वस्तुओं के लिए ढेर में न पड़े। सूची आइटम का अधिकतम आकार (टुकड़ा) बड़ा बनाने का मतलब होगा कि कम मेमोरी आवंटन की आवश्यकता होती है, लेकिन अधिक वर्ण अप्रयुक्त रहते हैं और संचालन को प्रतिस्थापित / प्रतिस्थापित करते हैं।

सबसे अधिक इस्तेमाल की जाने वाली विधियों को लागू करने पर विचार करें।

परिशिष्ट () विधि

स्रोत कोड

 public unsafe StringBuilder Append(string value) { if (value != null) { char[] chArray = this.m_ChunkChars; int index = this.m_ChunkLength; int length = value.Length; int num = index + length; if (num < chArray.Length)//           { if (length <= 2) { if (length > 0) chArray[index] = value[0]; if (length > 1) chArray[index + 1] = value[1]; } else { fixed (char* smem = value) fixed (char* dmem = &chArray[index]) string.wstrcpy(dmem, smem, length); } this.m_ChunkLength = num; } else this.AppendHelper(value); } return this; } private unsafe void AppendHelper(string value) { fixed (char* chPtr = value) this.Append(chPtr, value.Length); } internal unsafe StringBuilder Append(char* value, int valueCount) { //  int num1 = valueCount + this.m_ChunkLength; if (num1 <= this.m_ChunkChars.Length) { StringBuilder.ThreadSafeCopy(value, this.m_ChunkChars, this.m_ChunkLength, valueCount); this.m_ChunkLength = num1; } else { //   () int count = this.m_ChunkChars.Length - this.m_ChunkLength; if (count > 0) { StringBuilder.ThreadSafeCopy(value, this.m_ChunkChars, this.m_ChunkLength, count); this.m_ChunkLength = this.m_ChunkChars.Length; } //  ,     int num2 = valueCount - count; this.ExpandByABlock(num2); //    () StringBuilder.ThreadSafeCopy(value + count, this.m_ChunkChars, 0, num2); this.m_ChunkLength = num2; } return this; }

परिशिष्ट () विधि निम्नानुसार काम करती है: यदि नई सूची सम्मिलित करने के लिए वर्तमान सूची तत्व में पर्याप्त वर्ण हैं, तो इसकी प्रतिलिपि होती है; यदि नहीं, तो जिस भाग की प्रतिलिपि बनाई गई है, और जो फिट नहीं था, उसके लिए एक नई सूची तत्व बनाया गया है; StringBuilder-a) का उदाहरण, जिसकी सरणी की लंबाई पूरे स्रोत स्ट्रिंग की लंबाई के बराबर या शेष स्ट्रिंग की लंबाई के बराबर है, जो भी अधिक हो। हालांकि, जैसा कि ऊपर कहा गया था, सरणी की अधिकतम लंबाई 8000 है।

सामान्य तौर पर, एक नई सूची आइटम की लंबाई की गणना करने का सूत्र इस तरह दिखता है:

 int length = Math.Max(minBlockCharCount, Math.Min(this.Length, 8000))

जहां minBlockCharCount अपने हिस्से की नकल करने के बाद लाइन की शेष लंबाई है जो वर्तमान उदाहरण में रखी गई है।

इस प्रकार, इस तरह के कोड के संचालन के परिणामस्वरूप

 StringBuilder s = new StringBuilder (); for (int i = 0; i < 10000; i++) { s.Append ("T"); }

सूची मदों की सरणियों की लंबाई: 8000 , 4092, 2048, 1024, 512, 256, 128, 64, 32, 16, 16 के बराबर होगी।

सरणियों की इतनी लंबाई के साथ, स्रोत स्ट्रिंग में एक विशिष्ट वर्ण तक पहुंचने का संचालन लगभग ओ (1) में बहुत तेज़ी से किया जाता है, क्योंकि सूची के कई तत्व नहीं हैं।

सम्मिलित करें () विधि

स्रोत कोड

 public unsafe StringBuilder Insert(int index, string value) { if (value != null) { fixed (char* chPtr = value) this.Insert(index, chPtr, value.Length); } return this; } private unsafe void Insert(int index, char* value, int valueCount) { if (valueCount <= 0) return; StringBuilder chunk; int indexInChunk; //          (StringBuilder) this.MakeRoom(index, valueCount, out chunk, out indexInChunk, false); this.ReplaceInPlaceAtChunk(ref chunk, ref indexInChunk, value, valueCount); }

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

ऐसे कोड का परिणाम क्या होगा?

 StringBuilder s = new StringBuilder (); for (int i = 0; i < 10000; i++) { s.Insert (0, "T"); }

परिणाम परिशिष्ट () का उपयोग कर कोड से अलग होगा, और बहुत गंभीरता से!

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

निकालें () विधि

स्रोत कोड

 public StringBuilder Remove(int startIndex, int length) { if (this.Length == length && startIndex == 0) { // .     . this.Length = 0; return this; } else { if (length > 0) { StringBuilder chunk; int indexInChunk; this.Remove(startIndex, length, out chunk, out indexInChunk); } return this; } } private void Remove(int startIndex, int count, out StringBuilder chunk, out int indexInChunk) { int num = startIndex + count; //  ()         . chunk = this; StringBuilder stringBuilder = (StringBuilder) null; int sourceIndex = 0; while (true) { if (num - chunk.m_ChunkOffset >= 0) { if (stringBuilder == null) { stringBuilder = chunk; sourceIndex = num - stringBuilder.m_ChunkOffset; } if (startIndex - chunk.m_ChunkOffset >= 0) break; } else chunk.m_ChunkOffset -= count; chunk = chunk.m_ChunkPrevious; } indexInChunk = startIndex - chunk.m_ChunkOffset; int destinationIndex = indexInChunk; int count1 = stringBuilder.m_ChunkLength - sourceIndex; //       if (stringBuilder != chunk) { destinationIndex = 0; //    startIndex     () chunk.m_ChunkLength = indexInChunk; //       . stringBuilder.m_ChunkPrevious = chunk; stringBuilder.m_ChunkOffset = chunk.m_ChunkOffset + chunk.m_ChunkLength; //                () if (indexInChunk == 0) { stringBuilder.m_ChunkPrevious = chunk.m_ChunkPrevious; chunk = stringBuilder; } } stringBuilder.m_ChunkLength -= sourceIndex - destinationIndex; if (destinationIndex == sourceIndex) //     return; //          StringBuilder.ThreadSafeCopy(stringBuilder.m_ChunkChars, sourceIndex, stringBuilder.m_ChunkChars, destinationIndex, count1); }

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

ToString () विधि

स्रोत कोड

 public override unsafe string ToString() { if (this.Length == 0) return string.Empty; string str = string.FastAllocateString(this.Length); StringBuilder stringBuilder = this; fixed (char* chPtr = str) { do { if (stringBuilder.m_ChunkLength > 0) { char[] chArray = stringBuilder.m_ChunkChars; int num = stringBuilder.m_ChunkOffset; int charCount = stringBuilder.m_ChunkLength; fixed (char* smem = chArray) string.wstrcpy(chPtr + num, smem, charCount); } stringBuilder = stringBuilder.m_ChunkPrevious; } while (stringBuilder != null); } return str; }

यह विधि StringBuilders की पूरी लिंक की गई सूची से होकर गुजरती है और क्रमिक रूप से सूची के प्रत्येक तत्वों के वर्णों को परिणामी स्ट्रिंग में कॉपी करती है।

प्रदर्शन की तुलना

शायद सबसे दिलचस्प हिस्सा वर्ग के दो संस्करणों के बीच प्रदर्शन की तुलना है।

टेस्ट 1. दी गई लंबाई की एक स्ट्रिंग को स्टोर करने के लिए कितनी मेमोरी की आवश्यकता होती है।

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

परीक्षण 2. परिशिष्ट () विधि

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

परीक्षण 3. सम्मिलित () विधि

हम पहले ही वर्णों से भरे हुए स्ट्रिंग में सम्मिलित कर लेंगे, 1000 वर्ण लंबे।

1. लाइन की शुरुआत में डालें

2. पंक्ति के बीच में डालें

3. पंक्ति के अंत में सम्मिलित करें

टिप्पणियां अनावश्यक हैं - नया कार्यान्वयन कहीं भी चिपकाए जाने पर हार जाता है।

परीक्षण 4. निकालें () विधि

हम पहले से वर्णों से भरे हुए स्ट्रिंग से 10 वर्णों को हटा देंगे, जब तक हम इसे समाप्त नहीं करते।

नया कार्यान्वयन लगभग किसी भी स्थान से हटाए जाने पर जीतता है, क्योंकि अब शेष पंक्ति के वर्णों को बाईं ओर स्थानांतरित करना आवश्यक नहीं है (अधिक सटीक रूप से, इसकी आवश्यकता है, लेकिन अक्सर और पहले की तरह नहीं)।

परीक्षण 5. विधि ToString ()

जैसा कि ऊपर उल्लेख किया गया है, यह विधि पिछले कार्यान्वयन को खो देती है। पिछला कार्यान्वयन उस लाइन की एक लिंक को लौटा देता है जिसके साथ यह संचालित होता है (पहली कॉल पर), और नए को लिंक की गई सूची के प्रत्येक तत्व को दरकिनार करके परिणामी लाइन को टुकड़ों में इकट्ठा करने के लिए मजबूर किया जाता है।

यदि नई प्रविष्टि सम्मिलित करें () विधि का उपयोग करके स्ट्रिंग बनाई गई थी, तो नया कार्यान्वयन बहुत धीमा काम करता है, क्योंकि सूची में 16 वर्णों की लंबाई के साथ कई तत्व (StringBuilders) शामिल होंगे।

परीक्षण 6. एक विशिष्ट सूचकांक को संबोधित करना

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

टेस्ट 7. विशिष्ट परिदृश्य: एपेंड () के लिए बहुत सारे कॉल, और फिर ToString को कॉल करें ()

एक नियम के रूप में, हम एक निश्चित परिदृश्य के अनुसार इस वर्ग के साथ काम करते हैं: एपेंड () विधि के लिए एक से अधिक कॉल, उसके बाद एक कॉल टूस्ट्रिंग ()। इस परिदृश्य की गणना में इस वर्ग के कार्यान्वयन में सटीक बदलाव आया है।

निष्कर्ष

जैसा कि हमने देखा, .NET 2.0 में StringBuilder वर्ग को ToString () विधि की गति के लिए अनुकूलित किया गया था, जबकि .NET 4.0 में इसे परिशिष्ट () विधि की गति के लिए अनुकूलित किया गया था। परिशिष्ट () पद्धति का नया कार्यान्वयन लगभग 2 गुना तेज है, जबकि इन्सर्ट () और ट्यूरिंग () विधियाँ धीमी हैं। लेकिन जब से हम एक विशिष्ट परिदृश्य में इस वर्ग के साथ काम करते हैं: हम कई बार एपेंड () पद्धति को कॉल करते हैं, उसके बाद टोस्ट्रिंग () विधि के लिए एकल कॉल करते हैं, फिर प्रदर्शन में वृद्धि होती है।

कक्षा के नए कार्यान्वयन को देखते हुए, जिसमें केवल एक से अधिक कॉल अपेंडेड () विधि से प्रदर्शन में वृद्धि होती है, कक्षा को अब StringAppender * कहा जा सकता है।)

StringBuilder अतीत और वर्तमान

प्रविष्टि

.NET 2.0 में StringBuilder

परिशिष्ट () विधि

सम्मिलित करें () विधि

निकालें () विधि

ToString () विधि

.NET 4.0 में StringBuilder

परिशिष्ट () विधि

सम्मिलित करें () विधि

निकालें () विधि

ToString () विधि

प्रदर्शन की तुलना

निष्कर्ष

More articles: