तार को समाप्‍त करने का सबसे कारगर तरीका?

Question

तारों को समतल करने का सबसे कुशल तरीका क्या है?

Comments

मैं यहां एक प्रमुख चेतावनी देना चाहता हूं कि स्वीकृत उत्तर काफी अधूरा है क्योंकि यह सभी प्रासंगिक मामलों पर चर्चा नहीं करता है।

— usr

@usr वास्तव में ... StringBuilderउपयोग के मामलों के बारे में अधिक विस्तृत जानकारी यहां पाई जा सकती है ।

— तामीर वेर

C # 6 के रूप में मेरा नया पसंदीदा $ "लगातार पाठ यहां {foo} और {bar}" है ... यह String.Formatस्टेरॉयड पर पसंद है। जो, प्रदर्शन के लिहाज से, एक लाइनर की तुलना में एक छोटा सा धीमा है +और String.Concat, लेकिन उन लोगों की तुलना में बहुत बेहतर है StringBuilder, कई कॉलों की तुलना में धीमा है । व्यावहारिक रूप से, प्रदर्शन अंतर ऐसे होते हैं, अगर मुझे सहमति देने के लिए केवल एक ही रास्ता चुनना होता है, तो मैं स्ट्रिंग प्रक्षेपों का उपयोग करके चुनूंगा $... यदि दो तरीके हैं, तो StringBuilderमेरे टूलबॉक्स में जोड़ें । उन दो तरीकों से आप सेट हो गए हैं।

— u8it

String.Joinनीचे इस सवाल का जवाब क्या करता है नहीं +न्याय और, है व्यावहारिक रूप से बोल रहा है, CONCATENATE तार करने के लिए एक बुरी तरह से है, लेकिन यह बुद्धिमान आश्चर्यजनक रूप से तेजी से प्रदर्शन है। जवाब क्यों दिलचस्प है। String.Concatऔर String.Joinदोनों सरणियों पर कार्य कर सकते हैं, लेकिन String.Joinवास्तव में तेज है। जाहिरा तौर पर, String.Joinबहुत परिष्कृत और String.Concatआंशिक रूप से अनुकूलित है , क्योंकि यह इसी तरह से संचालित होता StringBuilderहै कि यह पहले स्ट्रिंग की लंबाई की गणना करता है और फिर UnSafeCharBuffer का उपयोग करके इस ज्ञान से लाभ होने वाले स्ट्रिंग का निर्माण करता है।

— u8it

ठीक है, तो यह तेजी से है, लेकिन String.Joinयह भी एक सरणी जो लगता संसाधन अक्षम सही निर्माण की आवश्यकता है? ... कि बाहर कर देता है +और String.Concatउनके घटक के लिए निर्माण सरणियों वैसे भी। नतीजतन, मैन्युअल रूप से एक सरणी बनाने और इसे खिलाने के लिए String.Joinतुलनात्मक रूप से तेज़ है ... हालांकि, StringBuilderअभी भी String.Joinहर व्यावहारिक तरीके से बेहतर प्रदर्शन करते हैं $, जबकि लंबे स्ट्रिंग्स में केवल थोड़ा धीमा और बहुत तेज़ है ... यह उल्लेख करने के लिए नहीं कि आपके पास यह उपयोग करने के लिए अजीब और बदसूरत String.Joinहै। मौके पर इसके लिए एक सरणी बनाने के लिए।

— u8it

Answer 1

StringBuilder.Append()विधि ज्यादा का उपयोग कर से बेहतर है +ऑपरेटर। लेकिन मैंने पाया है कि, जब 1000 संघटन या उससे कम का निष्पादन होता है, तो इससे String.Join()भी अधिक कुशल है StringBuilder।

StringBuilder sb = new StringBuilder();
sb.Append(someString);

इसके साथ एकमात्र समस्या String.Joinयह है कि आपको एक सामान्य सीमांकक के साथ तारों को समतल करना होगा।

संपादित करें: जैसा कि @ryanversaw ने बताया, आप सीमांकक बना सकते हैं string.Empty।

string key = String.Join("_", new String[] 
{ "Customers_Contacts", customerID, database, SessionID });

Comments

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

— हाबिल

यह एकल पंक्ति के लिए सच नहीं है। मान लें कि आप myString = "foo" + var1 + "bar" + var2 + "hello" + var3 + "world" करते हैं, कंपाइलर स्वचालित रूप से एक string.concat कॉल में बदल जाता है, जो कि उतना ही कुशल है। यह उत्तर गलत है, वहाँ से चुनने के लिए बेहतर उत्तर के बहुत सारे हैं

— csauve

तुच्छ स्ट्रिंग समाकलन के लिए जो कभी सबसे पठनीय होता है उसका उपयोग करें। string a = b + c + d; लगभग हमेशा स्ट्रांगबर्ल के साथ करने की तुलना में तेज होगा, लेकिन अंतर आमतौर पर अप्रासंगिक है। बार-बार एक ही तार में जोड़ते समय (जैसे किसी रिपोर्ट का निर्माण) या बड़े तार के साथ काम करते समय स्ट्रिंगबर्ल (या अपनी पसंद का अन्य विकल्प) का उपयोग करें।

— स्वानी

आपने उल्लेख क्यों नहीं किया string.Concat?

— वेनमो

Answer 2

.NET परफॉर्मेंस गुरु, रिको मारियानी का इस विषय पर एक लेख था । यह उतना आसान नहीं है जितना कि किसी पर शक करना। मूल सलाह यह है:

यदि आपका पैटर्न दिखता है:

x = f1(...) + f2(...) + f3(...) + f4(...)

यह एक कॉनैट है और यह ज़िप्पी है, स्ट्रिंगब्यूरी शायद मदद नहीं करेगा।

यदि आपका पैटर्न दिखता है:

if (...) x += f1(...)
if (...) x += f2(...)
if (...) x += f3(...)
if (...) x += f4(...)

तो आप शायद StringBuilder चाहते हैं।

इस दावे का समर्थन करने के लिए एक और लेख एरिक लिपर्ट से आता है, जहां वह एक पंक्ति में किए गए अनुकूलन का +विस्तार से वर्णन करता है।

Comments

String.Format () के बारे में क्या?

— आयरनलॉग

Answer 3

स्ट्रिंग संघनन के 6 प्रकार हैं:

1. प्लस ( +) प्रतीक का उपयोग करना ।
2. का उपयोग कर string.Concat()।
3. का उपयोग कर string.Join()।
4. का उपयोग कर string.Format()।
5. का उपयोग कर string.Append()।
6. का उपयोग कर StringBuilder।

एक प्रयोग में, यह सिद्ध किया गया है कि string.Concat()दृष्टिकोण के लिए सबसे अच्छा तरीका है यदि शब्द 1000 (लगभग) से कम हैं और यदि शब्द 1000 से अधिक हैं तो StringBuilderउपयोग किया जाना चाहिए।

अधिक जानकारी के लिए, इस साइट की जाँच करें ।

string.Join () बनाम string.Concat ()

String.Concat मेथड string के बराबर है। जॉइन मेथड invocation एक खाली विभाजक के साथ। एक खाली स्ट्रिंग लागू करना तेज़ है, लेकिन ऐसा नहीं करना और भी तेज़ है, इसलिए यहाँ स्ट्रिंग बेहतर है।

Comments

पढ़ना चाहिए यह साबित हो गया है स्ट्रिंग। कॉनकट () या + सबसे अच्छा तरीका है। हां मैं इसे लेख से प्राप्त कर सकता हूं लेकिन यह मुझे एक क्लिक बचाता है। तो, + और कॉनैट एक ही कोड में संकलित करते हैं।

— brumScouse

मैंने इस आधार का उपयोग करने की कोशिश की और मेरी एक विधि को अधिक कुशल बनाने के लिए, जहां मुझे केवल 3 तारों को समतल करने की आवश्यकता थी। मैंने पाया कि +वास्तव में 3 मिलीसेकंड से अधिक तेज़ था string.Concat(), हालांकि मैंने string.Concat()आउटरीज़ से पहले आवश्यक तार की मात्रा पर ध्यान नहीं दिया है +।

— प्रातः

Answer 4

से Chinh Do - StringBuilder हमेशा तेजी से नहीं है :

अंगूठे का नियम

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

• जब श्रृंखलाबद्ध से ज्यादा तीन गतिशील स्ट्रिंग मूल्यों, उपयोगStringBuilder ।

• कई स्ट्रिंग शाब्दिक से एक बड़ी स्ट्रिंग का निर्माण करते समय, या तो @स्ट्रिंग शाब्दिक या इनलाइन + ऑपरेटर का उपयोग करें।

अधिकांश समय StringBuilderआपकी सबसे अच्छी शर्त है, लेकिन ऐसे मामले भी हैं जो उस पोस्ट में दिखाए गए हैं कि आपको प्रत्येक स्थिति के बारे में कम से कम सोचना चाहिए।

Comments

afaik @ केवल एस्केप सीक्वेंस प्रोसेसिंग को बंद कर देता है। msdn.microsoft.com/en-us/library/362314fe.aspx सहमत

— abatishchev

Answer 5

यदि आप एक लूप में काम कर रहे हैं, StringBuilderतो संभवतः जाने का रास्ता है; यह आपको नियमित रूप से नए तार बनाने के ओवरहेड को बचाता है। कोड में, जो केवल एक बार चलेगा, हालांकि, String.Concatशायद ठीक है।

हालाँकि, रिको मारियानी (.NET ऑप्टिमाइज़ेशन गुरु) ने एक क्विज़ बनाया , जिसमें उन्होंने अंत में कहा कि, ज्यादातर मामलों में, वह सलाह देते हैं String.Format।

Comments

मैं उन लोगों के लिए वर्षों से string_format का उपयोग स्ट्रिंग + स्ट्रिंग के उपयोग के लिए कर रहा हूं जिनके साथ मैंने काम किया है। मुझे लगता है कि प्रदर्शन लाभ से परे पठनीयता लाभ एक अतिरिक्त लाभ है।

— स्कॉट लॉरेंस

यह वास्तविक सही उत्तर है। StringBuilder के लिए वर्तमान में स्वीकृत उत्तर गलत है, क्योंकि यह सिंगल लाइन अपेंडेंस का उल्लेख नहीं करता है जिसके लिए string.concat या + अधिक तेज है। थोड़ा ज्ञात तथ्य यह है कि संकलक वास्तव में string.concat में अनुवाद करता है। इसके अलावा, छोरों के लिए या एक से अधिक लाइन concats के लिए मैं एक कस्टम निर्मित स्ट्रिंग निर्माता का उपयोग केवल संलग्न कर देता है कि जब .ToString कहा जाता है - अनिश्चित बफर समस्या StringBuilder है पर काबू पाने

— csauve

string.Format किसी भी परिस्थिति में सबसे तेज़ तरीका नहीं है। मुझे नहीं पता कि किसी मामले को कैसे आगे बढ़ाया जाए।

— usr

@usr - ध्यान दें कि रिको स्पष्ट रूप से यह सबसे तेज नहीं कह रहा है , बस यही उसकी सिफारिश है: "भले ही यह सबसे खराब प्रदर्शन है, और हम पहले से ही जानते थे कि दोनों, आपके सीएलआर प्रदर्शन आर्किटेक्ट्स को सम्‍मिलित करते हैं कि [string.Format] डिफ़ॉल्ट पसंद हो। अत्यधिक संभावना वाली घटना में यह एक संपूर्ण समस्या बन जाती है कि यह समस्या केवल मामूली स्थानीय परिवर्तनों के साथ आसानी से संबोधित करने योग्य है। आम तौर पर आप केवल कुछ अच्छे रख-रखाव में नकदी कर रहे हैं। "

— एडम वी।

@AdamV का सवाल सबसे तेज़ तरीके से है। मैं इसके बारे में असहमत हूं कि हालांकि यह डिफ़ॉल्ट विकल्प नहीं है। यह अनाड़ी वाक्य-विन्यास हो सकता है। पुनर्विक्रेता इच्छानुसार आगे और पीछे परिवर्तित कर सकता है।

— usr

Answer 6

यहाँ मैं अपने बड़े पैमाने के एनएलपी ऐप के लिए एक दशक में सबसे तेज़ विधि विकसित कर चुका हूँ। मेरे पास IEnumerable<T>और विभिन्न प्रकारों ( Char, String) के विभाजक के बिना और अन्य इनपुट प्रकारों के लिए विविधताएं हैं , लेकिन यहां मैं एक सरणी में सभी तारों को समेटने का सरल मामला दिखाता हूं , जिसमें कोई विभाजक नहीं है। यहां नवीनतम संस्करण को C # 7 और .NET 4.7 पर विकसित और इकाई-परीक्षण किया गया है ।

उच्च प्रदर्शन के लिए दो कुंजी हैं; पहले आवश्यक कुल सटीक आकार की पूर्व-गणना करना है। जब इनपुट यहां दिखाया गया है, तो यह चरण तुच्छ है। इसके IEnumerable<T>बजाय हैंडलिंग के लिए , यह पहले कंप्यूटिंग के लिए एक अस्थायी सरणी में तारों को इकट्ठा करने के लायक है। कुल मिलाकर (सरणी को ToString()तकनीकी रूप से प्रति तत्व एक बार से अधिक कॉल से बचने के लिए आवश्यक है , दुष्प्रभाव की संभावना को देखते हुए, ऐसा करने से अपेक्षित शब्दार्थ बदल सकता है। 'स्ट्रिंग जॉइन' ऑपरेशन)।

अगला, अंतिम स्ट्रिंग के कुल आवंटन आकार को देखते हुए, परिणाम स्ट्रिंग में जगह बनाने से प्रदर्शन में सबसे बड़ा बढ़ावा प्राप्त होता है । ऐसा करने के लिए (शायद विवादास्पद) तकनीक को अस्थायी रूप से एक नए की अपरिहार्यता को निलंबित करने की आवश्यकता होती है Stringजिसे शुरू में शून्य से भरा आवंटित किया जाता है। हालांकि इस तरह के किसी भी विवाद को ...

... ध्यान दें कि इस पृष्ठ पर यह एकमात्र थोक-समाधान समाधान है जो निर्माणकर्ता द्वारा आवंटन और प्रतिलिपि के एक अतिरिक्त दौर से बचा जाता है String।

पूरा कोड:

/// <summary>
/// Concatenate the strings in 'rg', none of which may be null, into a single String.
/// </summary>
public static unsafe String StringJoin(this String[] rg)
{
    int i;
    if (rg == null || (i = rg.Length) == 0)
        return String.Empty;

    if (i == 1)
        return rg[0];

    String s, t;
    int cch = 0;
    do
        cch += rg[--i].Length;
    while (i > 0);
    if (cch == 0)
        return String.Empty;

    i = rg.Length;
    fixed (Char* _p = (s = new String(default(Char), cch)))
    {
        Char* pDst = _p + cch;
        do
            if ((t = rg[--i]).Length > 0)
                fixed (Char* pSrc = t)
                    memcpy(pDst -= t.Length, pSrc, (UIntPtr)(t.Length << 1));
        while (pDst > _p);
    }
    return s;
}

[DllImport("MSVCR120_CLR0400", CallingConvention = CallingConvention.Cdecl)]
static extern unsafe void* memcpy(void* dest, void* src, UIntPtr cb);

मुझे यह उल्लेख करना चाहिए कि इस कोड का मेरे द्वारा उपयोग किए जाने से थोड़ा सा संशोधन है। मूल में, मैं वास्तविक प्रतिलिपि बनाने के लिए C # से cpblk IL निर्देश को कॉल करता हूं । यहां कोड में सादगी और पोर्टेबिलिटी के लिए, मैंने इसे पी / इनवोक के बजाय बदल दिया , जैसा कि आप देख सकते हैं। X64 पर उच्चतम प्रदर्शन के लिए ( लेकिन शायद x86 नहीं ) आप इसके बजाय cpblk विधि का उपयोग करना चाह सकते हैं ।memcpy

Comments

string.Joinये सभी चीजें आपके लिए पहले से ही है। इसे स्वयं लिखने की कोई आवश्यकता नहीं है। यह अंतिम स्ट्रिंग के आकार की गणना करता है, उस आकार की एक स्ट्रिंग का निर्माण करता है, और फिर अंतर्निहित वर्ण सरणी को लिखता है। यहां तक ​​कि इस प्रक्रिया में पठनीय चर नामों का उपयोग करने का बोनस भी है।

— सर्विस नोवी

@ सरवाई टिप्पणी के लिए धन्यवाद; वास्तव में String.Joinकुशल हो सकता है। जैसा कि मैंने परिचय में संकेत दिया है, यहाँ कोड उन कार्यों के एक परिवार का सबसे सरल चित्रण है जो मैं ऐसे परिदृश्यों के लिए उपयोग करता हूं जो String.Joinया तो संभाल नहीं करते हैं (जैसे Charविभाजक के लिए अनुकूलन ) या .NET के पिछले संस्करणों में संभाल नहीं किया था। मुझे लगता है कि मुझे इसे सबसे सरल उदाहरण के लिए नहीं चुनना चाहिए था, क्योंकि यह एक ऐसा मामला है जो String.Joinपहले से ही अच्छी तरह से संभालता है, यद्यपि एक अक्षम विभाजक प्रसंस्करण की "अक्षमता," संभावना के साथ अयोग्य है। String.Empty।

— ग्लेन स्लेडेन

यकीन है, इस मामले में कि आपके पास एक विभाजक नहीं है, तो आपको कॉल करना चाहिए Concat, जो यह भी सही ढंग से करता है। किसी भी तरह से आपको कोड लिखने की आवश्यकता नहीं है।

— सेविला

@ सरवी इस टेस्ट हार्नेसString.Join का उपयोग करके मैंने अपने कोड के प्रदर्शन की तुलना की है । 10 लाख 100 शब्द आकार तार प्रत्येक अप करने के लिए की यादृच्छिक संयोजन के संचालन के लिए, ऊपर दिखाए गए कोड को लगातार 34% की तुलना में तेजी है पर 64 के साथ रिलीज निर्माण .NET 4.7 । चूंकि ओपी स्पष्ट रूप से "सबसे कुशल" पद्धति का अनुरोध करता है, इसलिए परिणाम बताता है कि मेरा उत्तर लागू होता है। यदि यह आपकी चिंताओं को संबोधित करता है, तो मैं आपको अपने पतन पर पुनर्विचार करने के लिए आमंत्रित करता हूं। String.Join

— ग्लेन स्लेडेन

मैंने हाल ही में इसे x64 पूर्ण सीएलआर 4.7.1 पर बेंचमार्क किया था और इसे स्ट्रिंग के रूप में दोगुना तेज़ होने के बारे में पाया। लगभग 25% कम मेमोरी के साथ आवंटित किया ( i.imgur.com/SxIpEmL.png ) cbblk या github.com/

— क्वेंटिन-starin

Answer 7

इस MSDN लेख से :

समय और स्मृति दोनों में, एक स्ट्रिंगबर्ल ऑब्जेक्ट बनाने के साथ जुड़े कुछ ओवरहेड हैं। तेज मेमोरी वाली मशीन पर, अगर आप पांच ऑपरेशन कर रहे हैं, तो एक स्ट्रिंगबर्स्ट सार्थक हो जाता है। अंगूठे के एक नियम के रूप में, मैं कहूंगा कि 10 या अधिक स्ट्रिंग ऑपरेशन किसी भी मशीन पर ओवरहेड के लिए एक औचित्य है, यहां तक ​​कि एक धीमी भी।

इसलिए यदि आप भरोसा करते हैं कि MSDN StringBuilder के साथ जाता है यदि आपको 10 से अधिक स्ट्रिंग्स ऑपरेशन / कॉन्सैटेनेशन करने हैं - तो '+' के साथ सिंपल स्ट्रींग कॉनैट ठीक है।

Answer 8

यह इंगित करना भी महत्वपूर्ण है कि आपको +ऑपरेटर का उपयोग करना चाहिए यदि आप स्ट्रिंग शाब्दिक हैं ।

जब आप + ऑपरेटर का उपयोग करके स्ट्रिंग शाब्दिक या स्ट्रिंग स्थिरांक को बदलते हैं, तो संकलक एक स्ट्रिंग बनाता है। कोई रन टाइम कॉन्सेप्ट नहीं होता है।

कैसे करें: कॉनटेनटेट मल्टीपल स्ट्रिंग्स (C # प्रोग्रामिंग गाइड)

Answer 9

अन्य उत्तरों को जोड़ते हुए, कृपया ध्यान रखें कि StringBuilder को आवंटित करने के लिए स्मृति की प्रारंभिक मात्रा बताई जा सकती है ।

क्षमता पैरामीटर अक्षर हैं जो स्मृति वर्तमान उदाहरण द्वारा आवंटित में संग्रहित किया जा सकता की अधिकतम संख्या निर्धारित करता है। इसका मूल्य क्षमता संपत्ति को सौंपा गया है । यदि वर्तमान उदाहरण में संग्रहीत किए जाने वाले वर्णों की संख्या इस क्षमता से अधिक है मान , तो StringBuilder ऑब्जेक्ट उन्हें संग्रहीत करने के लिए अतिरिक्त मेमोरी आवंटित करता है।

यदि क्षमता शून्य है, तो कार्यान्वयन-विशिष्ट डिफ़ॉल्ट क्षमता का उपयोग किया जाता है।

बार-बार एक StringBuilder से जुड़ने से जो पूर्व-आवंटित नहीं किया गया है, परिणामस्वरूप नियमित स्ट्रिंग्स को बार-बार समाप्‍त करने की तरह बहुत से अनावश्यक आवंटन हो सकते हैं।

यदि आप जानते हैं कि अंतिम स्ट्रिंग कितनी लंबी होगी, तो सामान्य रूप से इसकी गणना कर सकते हैं, या सामान्य मामले के बारे में एक शिक्षित अनुमान लगा सकते हैं (बहुत अधिक आवंटित करना जरूरी नहीं कि एक बुरी चीज है), आपको यह जानकारी निर्माणकर्ता या को प्रदान करनी चाहिए क्षमता संपत्ति। ख़ास तौर पर जब StringBuilder को String.Concat जैसे अन्य तरीकों से तुलना करने के लिए प्रदर्शन परीक्षण चलाते हैं, जो आंतरिक रूप से एक ही काम करते हैं। कोई भी परीक्षण जो आप ऑनलाइन देखते हैं जिसमें StringBuilder शामिल नहीं है उसकी तुलना में पूर्व-आवंटन गलत है।

यदि आप आकार के बारे में किसी भी प्रकार का अनुमान नहीं लगा सकते हैं, तो आप शायद एक उपयोगिता फ़ंक्शन लिख रहे हैं जो पूर्व-आवंटन को नियंत्रित करने के लिए अपना वैकल्पिक तर्क होना चाहिए।

Answer 10

निम्नलिखित कई तारों को बदलने के लिए एक और वैकल्पिक समाधान हो सकता है।

String str1 = "sometext";
string str2 = "some other text";

string afterConcate = $"{str1}{str2}";

स्ट्रिंग प्रक्षेप

Comments

यह वास्तव में आश्चर्य की बात की एक सामान्य विधि के रूप में आश्चर्यजनक अच्छा है। यह मूल रूप से String.Formatअधिक पठनीय है और इसके साथ काम करना आसान है। बेंच-मार्किंग, यह थोड़ा धीमा है +और String.Concatएक पंक्ति में है, लेकिन पुनरावृत्ति कॉल में उन दोनों की तुलना में बहुत बेहतर है जो StringBuilderकम आवश्यक बनाते हैं ।

— u8it

Answer 11

सबसे कुशल StringBuilder का उपयोग करना है, जैसे:

StringBuilder sb = new StringBuilder();
sb.Append("string1");
sb.Append("string2");
...etc...
String strResult = sb.ToString();

@ जोंज़ी: स्ट्रिंग.कॉन्कट ठीक है अगर आपके पास कुछ छोटी चीजें हैं। लेकिन अगर आप मेगाबाइट डेटा की अवहेलना कर रहे हैं, तो आपका प्रोग्राम टैंक की संभावना करेगा।

Comments

अरे, मेगाबाइट डेटा के लिए समाधान क्या है?

— नील

Answer 12

कोड के इस 2 टुकड़े की कोशिश करो और आप समाधान मिल जाएगा।

 static void Main(string[] args)
    {
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < 10000000; i++)
        {
            s.Append( i.ToString());
        }
        Console.Write("End");
        Console.Read();
    }

बनाम

static void Main(string[] args)
    {
        string s = "";
        for (int i = 0; i < 10000000; i++)
        {
            s += i.ToString();
        }
        Console.Write("End");
        Console.Read();
    }

आप पाएंगे कि 1 कोड वास्तव में जल्दी खत्म हो जाएगा और मेमोरी अच्छी मात्रा में होगी।

दूसरा कोड शायद मेमोरी ठीक होगा, लेकिन इसमें अधिक समय लगेगा ... बहुत लंबा। इसलिए यदि आपके पास बहुत सारे उपयोगकर्ताओं के लिए एक आवेदन है और आपको गति की आवश्यकता है, तो 1 का उपयोग करें। यदि आपके पास अल्पकालिक एक उपयोगकर्ता ऐप के लिए एक ऐप है, तो शायद आप दोनों का उपयोग कर सकते हैं या दूसरा डेवलपर्स के लिए अधिक "प्राकृतिक" होगा।

चीयर्स।

Answer 13

सिर्फ दो तारों के लिए, आप निश्चित रूप से स्ट्रिंगब्यूलर का उपयोग नहीं करना चाहते हैं। ऊपर कुछ दहलीज है, जिसमें स्ट्रिंगबर्ल ओवरहेड कई तारों को आवंटित करने के ओवरहेड से कम है।

तो, अधिक से अधिक 2-3 स्ट्रिंग्स के लिए, DannySmurf के कोड का उपयोग करें । अन्यथा, बस + ऑपरेटर का उपयोग करें।

Answer 14

System.String अपरिवर्तनीय है। जब हम एक स्ट्रिंग चर के मूल्य को संशोधित करते हैं तो एक नई मेमोरी को नए मान और पिछले मेमोरी आवंटन को जारी किया जाता है। System.StringBuilder को एक परिवर्तनशील स्ट्रिंग की अवधारणा के लिए डिज़ाइन किया गया था जहां संशोधित स्ट्रिंग के लिए अलग मेमोरी स्थान आवंटित किए बिना कई प्रकार के ऑपरेशन किए जा सकते हैं।

Answer 15

एक और समाधान:

लूप के अंदर, स्ट्रिंग के बजाय सूची का उपयोग करें।

List<string> lst= new List<string>();

for(int i=0; i<100000; i++){
    ...........
    lst.Add(...);
}
return String.Join("", lst.ToArray());;

यह बहुत तेज है।

Answer 16

यह वास्तव में आपके उपयोग पैटर्न पर निर्भर करता है। String.Join, string, Concat और string के बीच एक विस्तृत बेंचमार्क मिल सकता है। String.Format गहन लॉगिंग के लिए उपयुक्त नहीं है

(यह वास्तव में वही उत्तर है जो मैंने इस प्रश्न को दिया था )

Answer 17

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