स्ट्रिंग आउटपुट: C # में फॉर्मेट या कॉनकट?

178

मान लीजिए कि आप स्ट्रैंथ को आउटपुट या कॉनकट करना चाहते हैं। आप निम्नलिखित में से किस शैली को पसंद करते हैं?

var p = new { FirstName = "Bill", LastName = "Gates" };
Console.WriteLine("{0} {1}", p.FirstName, p.LastName);
Console.WriteLine(p.FirstName + " " + p.LastName);

क्या आप इसके बजाय प्रारूप का उपयोग करते हैं या क्या आप बस तार को समतल करते हैं? आपकी पसंद क्या है? क्या इनमें से एक आपकी आंखों को नुकसान पहुंचा रहा है?

क्या आपके पास एक का उपयोग करने के लिए कोई तर्कसंगत तर्क है और दूसरे को नहीं?

मैं दूसरे के लिए जाऊंगा।

c# string coding-style string.format

— फिलिप
स्रोत

88

इस कोड को आज़माएं।

यह आपके कोड का थोड़ा संशोधित संस्करण है।
1. मैंने Console.WriteLine को हटा दिया है क्योंकि यह शायद कुछ माप के आदेशों से कम है जो मैं मापने की कोशिश कर रहा हूं।
2. मैं स्टॉपवॉच को लूप से पहले शुरू कर रहा हूं और इसके ठीक बाद रोक रहा हूं, इस तरह मैं सटीक नहीं खो रहा हूं यदि फ़ंक्शन उदाहरण के लिए निष्पादित करने के लिए 26.4 टिक्स लेता है।
3. आपने कुछ पुनरावृत्तियों द्वारा परिणाम को विभाजित करने का तरीका गलत था। देखें कि क्या होता है यदि आपके पास 1000 मिलीसेकंड और 100 मिलीसेकंड हैं। दोनों स्थितियों में, आपको 1000000 से विभाजित करने के बाद 0 एमएस मिलेगा।

Stopwatch s = new Stopwatch();

var p = new { FirstName = "Bill", LastName = "Gates" };

int n = 1000000;
long fElapsedMilliseconds = 0, fElapsedTicks = 0, cElapsedMilliseconds = 0, cElapsedTicks = 0;

string result;
s.Start();
for (var i = 0; i < n; i++)
    result = (p.FirstName + " " + p.LastName);
s.Stop();
cElapsedMilliseconds = s.ElapsedMilliseconds;
cElapsedTicks = s.ElapsedTicks;
s.Reset();
s.Start();
for (var i = 0; i < n; i++)
    result = string.Format("{0} {1}", p.FirstName, p.LastName);
s.Stop();
fElapsedMilliseconds = s.ElapsedMilliseconds;
fElapsedTicks = s.ElapsedTicks;
s.Reset();


Console.Clear();
Console.WriteLine(n.ToString()+" x result = string.Format(\"{0} {1}\", p.FirstName, p.LastName); took: " + (fElapsedMilliseconds) + "ms - " + (fElapsedTicks) + " ticks");
Console.WriteLine(n.ToString() + " x result = (p.FirstName + \" \" + p.LastName); took: " + (cElapsedMilliseconds) + "ms - " + (cElapsedTicks) + " ticks");
Thread.Sleep(4000);

वे मेरे परिणाम हैं:

1000000 x परिणाम = string.ormat ("{0} {1}", p.FirstName, p.LastName); लिया: 618ms - 2213706 टिक
1000000 x परिणाम = (p.FirstName + "" + p.LastName); लिया: 166ms - 595610 टिक

— माइकेल पिसाकोस्की
स्रोत

1

बहुत ही रोचक। मुझे 224ms बनाम 48ms का औसत मिला, एक x4.66 सुधार, जो आपके x3.72 से भी बेहतर है। मुझे आश्चर्य है कि अगर कोई पोस्ट-कंप्लायंस टूल है जो उस के IL को फिर से लिख सकता है string.Formatजो किसी भी कंपोजिट फॉर्मेटिंग फीचर्स (यानी सिंपल सिंपल {0}) का उपयोग नहीं करता है और उन्हें काफी तेज स्ट्रिंग कॉन्सेप्टेशन से बदल देता है। मुझे आश्चर्य है कि इस तरह के करतब एक मौजूदा IL राइटर जैसे PostSharp के साथ प्राप्त करने योग्य हैं।

— एलन ग्रेलनेक

31

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

— लुडिंगटन

1

ईमानदारी से कहूं तो मैं हमेशा

— कॉन्सेप्ट करता

तो गति ही एक दूसरे को चुनने का एकमात्र कारण है?

— नीको

158

मुझे आश्चर्य है कि इतने सारे लोग तुरंत उस कोड को ढूंढना चाहते हैं जो सबसे तेज़ निष्पादित करता है। यदि एक से अधिक पुनरावृत्तियाँ चलती हैं तो प्रक्रिया में एक सेकंड से भी कम समय लगता है, क्या यह अंतिम उपयोगकर्ता के लिए किसी भी तरह से ध्यान देने योग्य है? बहुत संभावना नहीं है।

समयपूर्व अनुकूलन = विफल।

मैं String.Formatविकल्प के साथ जाऊंगा , केवल इसलिए कि यह एक वास्तुशिल्प दृष्टिकोण से सबसे अधिक समझ में आता है। मैं प्रदर्शन के बारे में तब तक ध्यान नहीं देता जब तक कि यह एक मुद्दा नहीं बन जाता (और अगर ऐसा होता, तो मैं खुद से पूछता: क्या मुझे एक बार में एक लाख नामों को संक्षिप्त करने की आवश्यकता है? निश्चित रूप से वे सभी स्क्रीन पर फिट नहीं होंगे ...)

विचार करें कि क्या आपका ग्राहक बाद में इसे बदलना चाहता है ताकि वे कॉन्फ़िगर कर सकें कि क्या प्रदर्शित करना है "Firstname Lastname"या "Lastname, Firstname."प्रारूप विकल्प के साथ, यह आसान है - बस प्रारूप स्ट्रिंग को स्वैप करें। कॉन्कैट के साथ, आपको अतिरिक्त कोड की आवश्यकता होगी। यकीन है कि इस विशेष उदाहरण में एक बड़ी बात की तरह लग रहा है, लेकिन अतिरिक्त नहीं है।

— फ्रेड्रिक कालसेथ
स्रोत

47

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

— भेजने की

23

यह पूरी तरह से गलत है। एक वेब विकास के माहौल में, अक्सर आपके स्ट्रिंग पीढ़ी कोड आपके मॉडल, विचार और नियंत्रकों दोनों में गहरे होंगे और प्रति पृष्ठ लोड के हजारों बार कहे जा सकते हैं। 50% से स्ट्रिंग पीढ़ी कोड का मूल्यांकन करने में समय बिताने की अवधि को कम करना एक बहुत बड़ी जीत हो सकती है।

— बेंजामिन सुस्मान

2

इस तरह का एक सवाल सिर्फ ओपी के एक उदाहरण में लागू नहीं होगा। यह उत्तर उस तरह का है जिसे लोग याद रख सकते हैं कि "मुझे किस तरीके से तार इकट्ठा करना चाहिए?" जैसा कि वे अपने सभी कोड लिखते हैं ।

— फिल मिलर

6

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

— ब्लूराजा - डैनी पफ्लुगुएफ़ट

2

यह सबसे निश्चित रूप से समय से पहले अनुकूलन नहीं है। काफी गिरावट। स्ट्रिंग का प्रदर्शन पूरी तरह से UI को रोक सकता है, विशेष रूप से .NET में यदि आप बहुत अधिक स्वरूपण और स्ट्रिंग बिल्डिंग कर रहे हैं। ubiquity.acm.org/article.cfm?id=1513451

— user99999991

54

ओह प्रिय - अन्य उत्तरों में से एक को पढ़ने के बाद मैंने संचालन के क्रम को उलटने की कोशिश की - इसलिए पहले संघटन का प्रदर्शन, फिर स्ट्रिंग.फोरमैट ...

Bill Gates
Console.WriteLine(p.FirstName + " " + p.LastName); took: 8ms - 30488 ticks
Bill Gates
Console.WriteLine("{0} {1}", p.FirstName, p.LastName); took: 0ms - 182 ticks

तो संचालन का क्रम एक बड़ा अंतर बनाता है, या बहुत पहले ऑपरेशन हमेशा बहुत धीमा है।

यहां एक रन का परिणाम है जहां संचालन एक से अधिक बार पूरा किया जाता है। मैंने आदेशों को बदलने की कोशिश की है लेकिन चीजें आम तौर पर समान नियमों का पालन करती हैं, पहले परिणाम की अनदेखी होने पर:

Bill Gates
Console.WriteLine(FirstName + " " + LastName); took: 5ms - 20335 ticks
Bill Gates
Console.WriteLine(FirstName + " " + LastName); took: 0ms - 156 ticks
Bill Gates
Console.WriteLine(FirstName + " " + LastName); took: 0ms - 122 ticks
Bill Gates
Console.WriteLine("{0} {1}", FirstName, LastName); took: 0ms - 181 ticks
Bill Gates
Console.WriteLine("{0} {1}", FirstName, LastName); took: 0ms - 122 ticks
Bill Gates
String.Concat(FirstName, " ", LastName); took: 0ms - 142 ticks
Bill Gates
String.Concat(FirstName, " ", LastName); took: 0ms - 117 ticks

जैसा कि आप एक ही विधि के बाद के रन देख सकते हैं (मैंने कोड को 3 विधियों में बदल दिया है) वृद्धिशील रूप से तेज हैं। सबसे तेज़ प्रतीत होता है Console.WriteLine (String.Concat (...)) विधि, इसके बाद सामान्य संघनन, और फिर स्वरूपित ऑपरेशन।

पहले ऑपरेशन में सभी समय को वापस लाने से पहले कंसोल में प्रारंभिक देरी कंसोल कंसोल की प्रारंभिक संभावना है, क्योंकि कंसोल ("प्रारंभ!") है।

— रेव्स समजेडसन
स्रोत

2

फिर Console.WriteLine को अपने परीक्षणों से पूरी तरह से हटा दें। यह परिणामों को तिरछा कर रहा है!

— सीएसकेर

मैं हमेशा एक throwaway या "नियंत्रण" परिदृश्य के साथ शुरू जब इस सटीक कारण के लिए प्रदर्शन परीक्षण चलाने

— drzaus

36

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

आकार के लिए इसे पहनकर देखें:

Stopwatch s = new Stopwatch();

int n = 1000000;
long fElapsedMilliseconds = 0, fElapsedTicks = 0, cElapsedMilliseconds = 0, cElapsedTicks = 0, sbElapsedMilliseconds = 0, sbElapsedTicks = 0;

Random random = new Random(DateTime.Now.Millisecond);

string result;
s.Start();
for (var i = 0; i < n; i++)
    result = (random.Next().ToString() + " " + random.Next().ToString());
s.Stop();
cElapsedMilliseconds = s.ElapsedMilliseconds;
cElapsedTicks = s.ElapsedTicks;
s.Reset();

s.Start();
for (var i = 0; i < n; i++)
    result = string.Format("{0} {1}", random.Next().ToString(), random.Next().ToString());
s.Stop();
fElapsedMilliseconds = s.ElapsedMilliseconds;
fElapsedTicks = s.ElapsedTicks;
s.Reset();

StringBuilder sb = new StringBuilder();
s.Start();
for(var i = 0; i < n; i++){
    sb.Clear();
    sb.Append(random.Next().ToString());
    sb.Append(" ");
    sb.Append(random.Next().ToString());
    result = sb.ToString();
}
s.Stop();
sbElapsedMilliseconds = s.ElapsedMilliseconds;
sbElapsedTicks = s.ElapsedTicks;
s.Reset();

Console.WriteLine(n.ToString() + " x result = string.Format(\"{0} {1}\", p.FirstName, p.LastName); took: " + (fElapsedMilliseconds) + "ms - " + (fElapsedTicks) + " ticks");
Console.WriteLine(n.ToString() + " x result = (p.FirstName + \" \" + p.LastName); took: " + (cElapsedMilliseconds) + "ms - " + (cElapsedTicks) + " ticks");
Console.WriteLine(n.ToString() + " x sb.Clear();sb.Append(random.Next().ToString()); sb.Append(\" \"); sb.Append(random.Next().ToString()); result = sb.ToString(); took: " + (sbElapsedMilliseconds) + "ms - " + (sbElapsedTicks) + " ticks");
Console.WriteLine("****************");
Console.WriteLine("Press Enter to Quit");
Console.ReadLine();

नमूना आउटपुट:

1000000 x result = string.Format("{0} {1}", p.FirstName, p.LastName); took: 513ms - 1499816 ticks
1000000 x result = (p.FirstName + " " + p.LastName); took: 393ms - 1150148 ticks
1000000 x sb.Clear();sb.Append(random.Next().ToString()); sb.Append(" "); sb.Append(random.Next().ToString()); result = sb.ToString(); took: 405ms - 1185816 ticks

— MrPhil
स्रोत

1

एक StringBuilder और उत्तर के लिए नमूना उत्पादन जोड़ा

— mikeschuld

मैं देख रहा हूँ कि कैसे string.Formatछोटे प्रदर्शन यहाँ हिट के लायक है। वास्तुशिल्प रूप से यह बेहतर है क्योंकि इसका मतलब है कि आप प्रारूप को अधिक आसानी से बदल सकते हैं। लेकिन स्ट्रिंगर मैं वास्तव में बात नहीं देखता। यहाँ पर हर दूसरे सूत्र में कहा गया है कि आपको स्ट्रिंग को सुगम बनाने के बजाय स्ट्रिंगरबिल्डर का उपयोग करना चाहिए। फायदा क्या है? स्पष्ट रूप से गति नहीं, क्योंकि यह बेंचमार्क साबित होता है।

— रोरीक जूल

22

गरीब अनुवादकों पर दया करें

यदि आपको पता है कि आपका आवेदन अंग्रेजी में रहेगा, तो ठीक है, घड़ी की टिक को बचाएं। हालाँकि, कई संस्कृतियों में आमतौर पर Lastname Firstname, उदाहरण के लिए, पते देखा जाएगा।

इसलिए string.Format(), यदि आप कभी भी अपना आवेदन करने जा रहे हैं , तो उपयोग करें कि अंग्रेजी पहली भाषा नहीं है।

— जेरेमी मैकगी
स्रोत

2

string.Format()अलग-अलग संस्कृतियों में अलग-अलग व्यवहार कैसे होगा ? क्या यह अभी भी पहले नाम तो अंतिम नाम नहीं छापेगा? ऐसा लगता है कि आपको दोनों स्थितियों में अलग-अलग संस्कृति को ध्यान में रखना होगा। मुझे ऐसा लग रहा है कि मुझे यहाँ कुछ याद आ रहा है।

— ब्रॉट्स वेम्ब

2

मैं @DangerZone से सहमत हूं .. आपको कैसे string.Format()पता चलेगा कि आप एक पते के लिए एक नाम का उपयोग कर रहे हैं? अगर संस्कृति के आधार पर string.Format()अदला-बदली {0} {1}होती है, तो मैं इसे टूटा हुआ मानूंगा।

— एलेक्स मैकमिलन

2

मेरा मानना है कि जेरेमी जिस बिंदु को बनाने की कोशिश कर रहा था, वह यह है कि विभिन्न देशों के समर्थन के लिए वर्णित परिदृश्य में, भाषा के संसाधन के लिए प्रारूप स्ट्रिंग को निकालने के लिए उपयुक्त हो सकता है। अधिकांश देशों के लिए यह स्ट्रिंग "{0} {1}" होगी, लेकिन उन देशों के लिए जहां उपनाम-पहला विशिष्ट संचालन है (जैसे हंगरी, हांगकांग, कंबोडिया, चीन, जापान, कोरिया, मेडागास्कर, ताइवान, वियतनाम, और भारत के कुछ हिस्सों) इसके बजाय "{1} {0}" स्ट्रिंग होगा।

— रिचर्ड जे फोस्टर

वास्तव में। या, अधिक सूक्ष्मता से, व्यक्ति की विशेषता के रूप में प्रारूप स्ट्रिंग जोड़ें। उदाहरण के लिए, मैं अपने उपनाम को अपने पहलेनाम के बाद रखना पसंद करता हूं, लेकिन मेरा सहयोगी बेंग नहीं है।

— जेरेमी मैकगी

14

यहाँ 100,000 से अधिक पुनरावृत्तियों पर मेरे परिणाम हैं:

Console.WriteLine("{0} {1}", p.FirstName, p.LastName); took (avg): 0ms - 689 ticks
Console.WriteLine(p.FirstName + " " + p.LastName); took (avg): 0ms - 683 ticks

और यहाँ बेंच कोड है:

Stopwatch s = new Stopwatch();

var p = new { FirstName = "Bill", LastName = "Gates" };

//First print to remove the initial cost
Console.WriteLine(p.FirstName + " " + p.LastName);
Console.WriteLine("{0} {1}", p.FirstName, p.LastName);

int n = 100000;
long fElapsedMilliseconds = 0, fElapsedTicks = 0, cElapsedMilliseconds = 0, cElapsedTicks = 0;

for (var i = 0; i < n; i++)
{
    s.Start();
    Console.WriteLine(p.FirstName + " " + p.LastName);
    s.Stop();
    cElapsedMilliseconds += s.ElapsedMilliseconds;
    cElapsedTicks += s.ElapsedTicks;
    s.Reset();
    s.Start();
    Console.WriteLine("{0} {1}", p.FirstName, p.LastName);
    s.Stop();
    fElapsedMilliseconds += s.ElapsedMilliseconds;
    fElapsedTicks += s.ElapsedTicks;
    s.Reset();
}

Console.Clear();

Console.WriteLine("Console.WriteLine(\"{0} {1}\", p.FirstName, p.LastName); took (avg): " + (fElapsedMilliseconds / n) + "ms - " + (fElapsedTicks / n) + " ticks");
Console.WriteLine("Console.WriteLine(p.FirstName + \" \" + p.LastName); took (avg): " + (cElapsedMilliseconds / n) + "ms - " + (cElapsedTicks / n) + " ticks");

इसलिए, मुझे नहीं पता कि किसके उत्तर के रूप में चिह्नित करना है :)

— फिलिप
स्रोत

इस उत्तर के लिए पृष्ठभूमि नीला क्यों है?

— user88637

@yossi यह नीला है क्योंकि इसका उत्तर पूछने वाले के समान है

— Davy8

9

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

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

यदि आप .NET 3.5 का उपयोग कर रहे हैं, तो आप इस तरह से एक्सटेंशन विधि का उपयोग कर सकते हैं और इस तरह कफ सिंटैक्स से एक आसान बहना प्राप्त कर सकते हैं :

string str = "{0} {1} is my friend. {3}, {2} is my boss.".FormatWith(prop1,prop2,prop3,prop4);

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

string name = String.Format(ApplicationStrings.General.InformalUserNameFormat,this.FirstName,this.LastName);

— नाथन
स्रोत

7

बहुत सरल हेरफेर के लिए, मैं संघनन का उपयोग करता हूं, लेकिन एक बार जब आप 2 या 3 तत्वों से परे हो जाते हैं तो प्रारूप IMO अधिक उपयुक्त हो जाता है।

String.Format को पसंद करने का एक और कारण है। .NET स्ट्रिंग्स अपरिवर्तनीय हैं और इसे इस तरह से करने से कम अस्थायी / मध्यवर्ती प्रतियां बनती हैं।

— user2189331
स्रोत

6

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

निम्नलिखित कोड का उपयोग करना:

    System.Diagnostics.Stopwatch s = new System.Diagnostics.Stopwatch();

    var p = new { FirstName = "Bill", LastName = "Gates" };

    s.Start();
    Console.WriteLine("{0} {1}", p.FirstName, p.LastName);
    s.Stop();
    Console.WriteLine("Console.WriteLine(\"{0} {1}\", p.FirstName, p.LastName); took: " + s.ElapsedMilliseconds + "ms - " + s.ElapsedTicks + " ticks");

    s.Reset();
    s.Start();
    Console.WriteLine(p.FirstName + " " + p.LastName);
    s.Stop();

    Console.WriteLine("Console.WriteLine(p.FirstName + \" \" + p.LastName); took: " + s.ElapsedMilliseconds + "ms - " + s.ElapsedTicks + " ticks");

मुझे निम्नलिखित परिणाम मिले:

Bill Gates
Console.WriteLine("{0} {1}", p.FirstName, p.LastName); took: 2ms - 7280 ticks
Bill Gates
Console.WriteLine(p.FirstName + " " + p.LastName); took: 0ms - 67 ticks

स्वरूपण विधि का उपयोग करना 100 से अधिक बार धीमा है !! कॉन्टेनेटेशन ने 1ms के रूप में भी पंजीकरण नहीं किया, यही वजह है कि मैं टाइमर टिक का भी उत्पादन करता हूं।

— एडम हैले
स्रोत

2

लेकिन निश्चित रूप से आपको माप प्राप्त करने के लिए एक से अधिक बार ऑपरेशन करना चाहिए।

— एरिक्कलिन

2

और Console.Writeline () को कॉल खोना क्योंकि यह प्रश्न के दायरे से बाहर है?

— ऐडाणापर्ड

क्या आपने एक स्ट्रिंगर के साथ परीक्षण किया? ;)

— नीको

6

ऐसा करने के लिए C # 6.0 इंटरपोल किए गए स्ट्रिंग्स का उपयोग किया जा सकता है, जो प्रारूप को और भी सरल बनाता है।

var name = "Bill";
var surname = "Gates";
MessageBox.Show($"Welcome to the show, {name} {surname}!");

एक प्रक्षेपित स्ट्रिंग अभिव्यक्ति एक टेम्पलेट स्ट्रिंग की तरह दिखती है जिसमें अभिव्यक्ति होती है। एक प्रक्षेपित स्ट्रिंग अभिव्यक्ति अभिव्यक्तियों के परिणामों के ToString रिप्रेशनेशन के साथ निहित अभिव्यक्तियों को प्रतिस्थापित करके एक स्ट्रिंग बनाती है।

Interpolated स्ट्रिंग्स का String.Format के समान प्रदर्शन होता है, लेकिन बेहतर पठनीयता और छोटे वाक्यविन्यास के कारण, इस तथ्य के कारण कि मूल्यों और अभिव्यक्तियों को इन-लाइन डाला जाता है।

कृपया इस डॉटनेटपर्स लेख को स्ट्रिंग इंटरपोलेशन पर भी देखें ।

यदि आप अपने तार को प्रारूपित करने के लिए एक डिफ़ॉल्ट तरीके की तलाश कर रहे हैं, तो यह पठनीयता और प्रदर्शन के संदर्भ में समझ में आता है (सिवाय इसके कि माइक्रोसेकंड आपके विशिष्ट उपयोग के मामले में फर्क करने वाला है)।

— सार्गीस
स्रोत

5

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

String.Format उद्धरण और pluses के बहुत से बचाता है ...

Console.WriteLine("User {0} accessed {1} on {2}.", user.Name, fileName, timestamp);
vs
Console.WriteLine("User " + user.Name + " accessed " + fileName + " on " + timestamp + ".");

केवल कुछ वर्णकों ने बचाया, लेकिन मुझे लगता है, इस उदाहरण में, प्रारूप इसे बहुत क्लीनर बनाता है।

— माइक
स्रोत

5

एक बेहतर परीक्षा होगी अपनी मेमोरी को परफॉमन और सीएलआर मेमोरी काउंटर का उपयोग करके देखना। मेरी समझ यह है कि पूरे कारण जिसे आप स्ट्रिंग का उपयोग करना चाहते हैं। केवल कॉनरेटिंग स्ट्रिंग्स के बजाय स्टॉर्मफर्मैट है, क्योंकि स्ट्रिंग्स अपरिवर्तनीय हैं, आप अनावश्यक रूप से कचरा कलेक्टर को अस्थायी स्ट्रिंग्स के साथ बोझ कर रहे हैं जिसे अगले पास में पुनः प्राप्त करने की आवश्यकता है।

StringBuilder और String.Format, हालांकि संभावित धीमा, अधिक स्मृति कुशल हैं।

स्ट्रिंग संघनन के बारे में इतना बुरा क्या है?

— डेविड हिल
स्रोत

मैं सहमत हूँ; प्रत्येक स्ट्रिंग ऑपरेशन स्ट्रिंग की एक नई प्रतिलिपि बनाता है। वह सभी स्मृति कचरा कलेक्टर द्वारा जल्द या बाद में पुनः प्राप्त की जाएगी। तो, बहुत सारे तार आवंटित करने से आपको बाद में काटने के लिए वापस आ सकता है।

— मार्निक्स वैन वैलेन

5

आम तौर पर मैं पूर्व को पसंद करता हूं, विशेष रूप से जब तार लंबे हो जाते हैं तो इसे पढ़ना बहुत आसान हो सकता है।

अन्य लाभ यह है कि मेरा मानना है कि प्रदर्शन में से एक है, क्योंकि बाद में कंसोल के लिए अंतिम स्ट्रिंग को पारित करने से पहले वास्तव में 2 स्ट्रिंग निर्माण स्टेटमेंट करता है। String.Format मेरा मानना है कि कवर के तहत एक StringBuilder का उपयोग करता है, इसलिए कई संगति से बचा जाता है।

हालांकि यह ध्यान दिया जाना चाहिए कि यदि आप जो पैरामीटर String.Format (और कंसोल जैसे अन्य तरीके) में पास कर रहे हैं, वे वैल्यू टाइप हैं, तो उन्हें पास होने से पहले बॉक्स किया जाएगा, जो अपनी स्वयं की प्रदर्शन हिट प्रदान कर सकते हैं। इस पर ब्लॉग पोस्ट यहाँ ।

— रिवाइज समजसन
स्रोत

1

वह ब्लॉग पोस्ट अब यहाँ है: jeffbarnes.net/blog/post/2006/08/08/… । मैं संपादित करने के लिए अपर्याप्त प्रतिनिधि से पीड़ित हूं।

— रिचर्ड स्लेटर

5

अब 19 अगस्त, 2015 से एक सप्ताह, यह प्रश्न ठीक सात (7) साल पुराना होगा। अब ऐसा करने का एक बेहतर तरीका है। मेंटेनेंस के मामले में बेहतर है क्योंकि मैंने सिर्फ कंफर्टेबल स्ट्रिंग्स की तुलना में कोई परफॉर्मेंस टेस्ट नहीं किया है (लेकिन इन दिनों क्या फर्क पड़ता है? कुछ मिलीसेकेंड का अंतर?)। C # 6.0 के साथ करने का नया तरीका :

var p = new { FirstName = "Bill", LastName = "Gates" };
var fullname = $"{p.FirstName} {p.LastName}";

यह नई सुविधा बेहतर है , IMO, और वास्तव में हमारे मामले में बेहतर है क्योंकि हमारे पास कोड हैं जहां हम querystrings का निर्माण करते हैं जिनके मूल्य कुछ कारकों पर निर्भर करते हैं। जहाँ हम 6 तर्क हैं, एक क्वेरिस्ट्रिंग की कल्पना करें। उदाहरण के लिए ऐसा करने के बजाय:

var qs = string.Format("q1={0}&q2={1}&q3={2}&q4={3}&q5={4}&q6={5}", 
    someVar, anotherVarWithLongName, var3, var4, var5, var6)

, इस तरह से लिखा जा सकता है और इसे पढ़ना आसान है:

var qs=$"q1={someVar}&q2={anotherVarWithLongName}&q3={var3}&q4={var4}&q5={var5}&q6={var6}";

— वॉन वी।
स्रोत

दरअसल, C # 6.0 का नया तरीका पिछले विकल्पों की तुलना में बेहतर है - कम से कम पठनीयता के दृष्टिकोण से।

— फिलिप

ये सही है। और यह भी सुरक्षित है क्योंकि आपको इस बारे में चिंतित होने की आवश्यकता नहीं है कि कौन सी वस्तु किस सूचकांक (प्लेसहोल्डर) में जाती है क्योंकि आप सीधे उन वस्तुओं को डालेंगे जहां आप इसे रखना चाहते हैं।

— वॉन वि।

BTW, यह वास्तव में फॉर्मेट (कम से कम रोजलिन के साथ) कहता है।

— फिलिप

BTW, इस पोस्टर को "स्ट्रिंग प्रक्षेप" कहा जाता है, और इस धागे में कहीं और संबोधित किया गया है।

— सीएसकेर

4

स्वरूपण इसे करने का ".NET" तरीका है। कुछ रीफैक्टरिंग टूल (रिफ्लैक्टर! एक के लिए) भी प्रारूप शैली का उपयोग करने के लिए कॉकटैट-शैली कोड को रिफ्लेक्टर करने का प्रस्ताव देगा।
कंपाइलर के लिए ऑप्टिमाइज़ करना आसान है (हालाँकि दूसरा संभवत: 'कॉनसैट ’पद्धति का उपयोग करने के लिए फिर से तैयार किया जाएगा)।
स्वरूपण आमतौर पर पढ़ने के लिए स्पष्ट है (विशेषकर "फैंसी" स्वरूपण)।
स्वरूपण का अर्थ है कि सभी चर पर '.ToString' में निहित कॉल, जो पठनीयता के लिए अच्छा है।
"इफेक्टिव सी #" के अनुसार, .NET 'राइटलाइन' और 'फॉर्मेट' के कार्यान्वयन में गड़बड़ होती है, वे सभी मूल्य प्रकारों (जो कि खराब है) को ऑटोबॉक्स करते हैं। "प्रभावी सी #" स्पष्ट रूप से '.ToString' कॉल प्रदर्शन करने के लिए, जो IMHO फर्जी है (देखें सलाह देता है जेफ के पोस्टिंग )
फिलहाल, संकलक द्वारा प्रारूपण प्रकार संकेत की जांच नहीं की जाती है, जिसके परिणामस्वरूप रनटाइम त्रुटियां होती हैं। हालाँकि, इसे भविष्य के संस्करणों में संशोधित किया जा सकता है।

— कोनराड रुडोल्फ
स्रोत

4

मैं पठनीयता के आधार पर चयन करता हूं। जब चर के आसपास कुछ पाठ होता है तो मैं प्रारूप विकल्प पसंद करता हूं। इस उदाहरण में:

Console.WriteLine("User {0} accessed {1} on {2}.", 
                   user.Name, fileName, timestamp);

आप चर नामों के बिना भी अर्थ को समझते हैं, जबकि अवतरण उद्धरण और + संकेतों के साथ बंद किया जाता है और मेरी आँखों को भ्रमित करता है:

Console.WriteLine("User " + user.Name + " accessed " + fileName + 
                  " on " + timestamp + ".");

(मैंने माइक का उदाहरण उधार लिया क्योंकि मुझे यह पसंद है)

यदि स्वरूप स्ट्रिंग चर नामों के बिना ज्यादा मायने नहीं रखता है, तो मुझे कॉनैट का उपयोग करना होगा:

   Console.WriteLine("{0} {1}", p.FirstName, p.LastName);

प्रारूप विकल्प मुझे चर नाम पढ़ता है और उन्हें संबंधित संख्याओं में मैप करता है। कॉनैट विकल्प की आवश्यकता नहीं है। मैं अभी भी उद्धरण और + संकेतों से भ्रमित हूं, लेकिन विकल्प बदतर है। माणिक?

   Console.WriteLine(p.FirstName + " " + p.LastName);

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

प्रारूप के साथ अन्य लाभ यह है कि प्रारूप स्ट्रिंग को कॉन्फ़िगरेशन फ़ाइल में रखा जा सकता है। त्रुटि संदेश और UI पाठ के साथ बहुत आसान है।

— DonkeyMaster
स्रोत

4

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

यदि यह उपयोगकर्ता को दिखाया जाने वाला है, तो मैं String.Format का उपयोग करूँगा, इसलिए यदि मुझे ज़रूरत है तो मैं इसका स्थानीयकरण कर सकता हूं - और FxCop इसे मेरे लिए जाँच करेगा, बस मामले में :)

यदि इसमें नंबर या कोई अन्य गैर-स्ट्रिंग चीजें (जैसे दिनांक) शामिल हैं, तो मैं स्ट्रिंग का उपयोग करूंगा । यह प्रारूपण पर मुझे अधिक नियंत्रण प्रदान करने के कारण String.Format का उपयोग करेगा ।

यदि यह SQL जैसी क्वेरी बनाने के लिए है, तो मैं Linq का उपयोग करूँगा ।

यदि लूप के अंदर तारों को समतल करने के लिए , मैं प्रदर्शन समस्याओं से बचने के लिए StringBuilder का उपयोग करूंगा ।

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

— विल्का को दर्शाता है
स्रोत

3

यदि आप किसी ऐसी चीज़ से निपट रहे हैं जिसे पढ़ने में आसान होना चाहिए (और यह सबसे कोड है), तो मैं ऑपरेटर ओवरलोड संस्करण के साथ छड़ी करूंगा:

कोड को लाखों बार निष्पादित किया जाना चाहिए
आप टन के कंसर्ट कर रहे हैं (4 से अधिक टन है)
कोड को कॉम्पैक्ट फ्रेमवर्क की ओर लक्षित किया गया है

इन परिस्थितियों में से कम से कम दो के तहत, मैं इसके बजाय StringBuilder का उपयोग करेगा।

— इमारत का बंद
स्रोत

3

यदि आप परिणाम का स्थानीयकरण करने का इरादा रखते हैं, तो String.Format आवश्यक है क्योंकि विभिन्न प्राकृतिक भाषाओं में समान क्रम में डेटा भी नहीं हो सकता है।

— क्रिश्चियन हैटर
स्रोत

2

मुझे लगता है कि यह इस बात पर बहुत निर्भर करता है कि आउटपुट कितना जटिल है। मैं उस समय जो भी सबसे अच्छा काम करता हूं, उसका चयन करता हूं।

काम के आधार पर सही उपकरण चुनें: D जो भी सबसे साफ दिखता है!

— Mercutio
स्रोत

2

मैं दूसरा भी पसंद करता हूं लेकिन उस स्थिति का समर्थन करने के लिए मेरे पास इस समय कोई तर्कसंगत तर्क नहीं है।

— चक
स्रोत

2

अच्छा है!

अभी जोड़ा गया

        s.Start();
        for (var i = 0; i < n; i++)
            result = string.Concat(p.FirstName, " ", p.LastName);
        s.Stop();
        ceElapsedMilliseconds = s.ElapsedMilliseconds;
        ceElapsedTicks = s.ElapsedTicks;
        s.Reset();

और यह और भी तेज है (मुझे लगता है कि स्ट्रिंग। कॉनकैट को दोनों उदाहरणों में कहा जाता है, लेकिन पहले वाले को किसी प्रकार के अनुवाद की आवश्यकता होती है)।

1000000 x result = string.Format("{0} {1}", p.FirstName, p.LastName); took: 249ms - 3571621 ticks
1000000 x result = (p.FirstName + " " + p.LastName); took: 65ms - 944948 ticks
1000000 x result = string.Concat(p.FirstName, " ", p.LastName); took: 54ms - 780524 ticks

— फिलिप
स्रोत

2

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

— एलन गुरलीनक

2

चूंकि मुझे नहीं लगता कि यहां उत्तर सब कुछ कवर करते हैं, इसलिए मैं यहां एक छोटा जोड़ बनाना चाहता हूं।

Console.WriteLine(string format, params object[] pars)कॉल करता है string.Format। '+' से तात्पर्य है स्ट्रिंग संयोजन। मुझे नहीं लगता कि यह हमेशा स्टाइल के साथ करना है; मैं जिस संदर्भ में हूं, उसके आधार पर दो शैलियों को मिलाना चाहता हूं।

संक्षिप्त जवाब

आपके द्वारा लिए गए निर्णय को स्ट्रिंग आवंटन के साथ करना होगा। मैं इसे सरल बनाने की कोशिश करूंगा।

बोलो तुम्हारे पास है

string s = a + "foo" + b;

यदि आप इसे निष्पादित करते हैं, तो यह निम्नानुसार मूल्यांकन करेगा:

string tmp1 = a;
string tmp2 = "foo" 
string tmp3 = concat(tmp1, tmp2);
string tmp4 = b;
string s = concat(tmp3, tmp4);

tmpयहाँ वास्तव में एक स्थानीय चर नहीं है, लेकिन यह JIT के लिए अस्थायी है (यह IL स्टैक पर धकेल दिया गया है)। यदि आप स्टैक पर स्ट्रिंग दबाते हैं (जैसे कि ldstrआईएल के लिए शाब्दिक रूप से), तो आप स्टैक पर स्ट्रिंग पॉइंटर का संदर्भ देते हैं।

जिस क्षण आप concatइस संदर्भ को कहते हैं , वह एक समस्या बन जाता है, क्योंकि कोई स्ट्रिंग संदर्भ उपलब्ध नहीं है जिसमें दोनों तार शामिल हैं। इसका मतलब है कि .NET को मेमोरी के एक नए ब्लॉक को आवंटित करने की आवश्यकता है, और फिर इसे दो स्ट्रिंग्स के साथ भरें। यह एक समस्या है, इसका कारण यह है कि आवंटन अपेक्षाकृत महंगा है।

जो इस सवाल को बदल देता है: आप concatसंचालन की संख्या कैसे कम कर सकते हैं ?

तो, मोटे तौर पर उत्तर यह है: string.Format> 1 कंसर्ट के लिए, '+' 1 कॉनकैट के लिए ठीक काम करेगा। और अगर आप सूक्ष्म प्रदर्शन अनुकूलन करने की परवाह नहीं string.Formatकरते हैं, तो सामान्य मामले में ठीक काम करेगा।

संस्कृति के बारे में एक नोट

और फिर वहाँ कुछ संस्कृति कहा जाता है ...

string.Formatआपको CultureInfoअपने स्वरूपण में उपयोग करने में सक्षम बनाता है । एक साधारण ऑपरेटर '+' वर्तमान संस्कृति का उपयोग करता है।

यदि आप फ़ाइल प्रारूप और f.ex लिख रहे हैं तो यह विशेष रूप से एक महत्वपूर्ण टिप्पणी है। doubleमान जो आप एक स्ट्रिंग में 'जोड़'ते हैं। विभिन्न मशीनों पर, यदि आप string.Formatस्पष्ट रूप से उपयोग नहीं करते हैं, तो आप अलग-अलग तारों के साथ समाप्त हो सकते हैं CultureInfo।

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

अधिक निराधार उत्तर

यदि आप पहले से ही स्ट्रिंग के सटीक आकार को नहीं जानते हैं, तो इस तरह की नीति का उपयोग करना सबसे अच्छा है कि आप अपने द्वारा उपयोग किए जाने वाले बफ़र्स को समग्र रूप से उपयोग करें। स्‍लैक स्‍पेस पहले भरा जाता है, उसके बाद डाटा को कॉपी किया जाता है।

बढ़ते का मतलब है कि मेमोरी का एक नया ब्लॉक आवंटित करना और पुराने डेटा को नए बफर में कॉपी करना। स्मृति के पुराने ब्लॉक को तब छोड़ा जा सकता है। आपको इस बिंदु पर नीचे की रेखा मिलती है: बढ़ते हुए एक महंगा ऑपरेशन है।

ऐसा करने का सबसे व्यावहारिक तरीका एक समग्र नीति का उपयोग करना है। सबसे आम नीति 2 की शक्तियों में बफ़र्स को समग्र रूप से अलग करना है। बेशक, आपको इसे इससे थोड़ा अधिक समझदारी से करना होगा (क्योंकि यह 1,2,4,8 से बढ़ने का कोई मतलब नहीं है, यदि आप पहले से ही जानते हैं कि आपको 128 वर्णों की आवश्यकता है ) लेकिन आपको तस्वीर मिल गई। नीति यह सुनिश्चित करती है कि आपको ऊपर वर्णित कई महंगे ऑपरेशनों की आवश्यकता नहीं है।

StringBuilderएक ऐसा वर्ग है जो मूल रूप से दो की शक्तियों में अंतर्निहित बफर को समग्र करता है। हुड के तहत string.Formatउपयोग करता है StringBuilder।

यह आपके निर्णय को समग्र-और-परिशिष्ट (-multiple) (w / wo कल्चर) या सिर्फ आवंटित और परिशिष्ट के बीच एक बुनियादी व्यापार-बंद बनाता है।

— atlaste
स्रोत

1

व्यक्तिगत रूप से, आप जो भी उपयोग कर रहे हैं, दूसरा वह सीधे क्रम में है, यह आउटपुट होगा। जबकि पहले के साथ आपको {0} और {1} को उचित वर्जन के साथ मैच करना होगा, जो गड़बड़ करना आसान है।

कम से कम यह सी ++ स्प्रिंट के रूप में बुरा नहीं है जहां अगर आपको चर प्रकार गलत मिलता है तो पूरी चीज उड़ जाएगी।

इसके अलावा, चूंकि दूसरी सभी इनलाइन है और इसमें सभी {0} चीजों के लिए कोई खोज और प्रतिस्थापन नहीं करना है, बाद में तेजी से होना चाहिए ... हालांकि मुझे यकीन नहीं है।

— एडम हैले
स्रोत

1

मैं वास्तव में पहले वाले को पसंद करता हूं क्योंकि जब पाठ के साथ बहुत सारे चर होते हैं तो मुझे पढ़ना आसान लगता है। इसके अलावा, स्ट्रिंग का उपयोग करते समय उद्धरणों से निपटना आसान है। फ़र्मैट (), उह, प्रारूप। यहाँ स्ट्रिंग संघनन का सभ्य विश्लेषण है।

— adparadox
स्रोत

1

मैं हमेशा स्ट्रिंग गया हूँ। फ़र्मैट () मार्ग। नातान के उदाहरण जैसे वेरिएबल्स में फॉर्मेट को स्टोर करने में सक्षम होने के नाते यह एक बेहतरीन फायदा है। कुछ मामलों में मैं एक चर को जोड़ सकता हूं, लेकिन एक बार से अधिक चर को स्वरूपित करने के लिए मैं परावर्तक किया जा रहा है।

— स्कॉट म्यूक
स्रोत

1

ओह, और सिर्फ पूर्णता के लिए, निम्नलिखित कुछ सामान्य सामान्य से अधिक तेजी से टिक है:

Console.WriteLine(String.Concat(p.FirstName," ",p.LastName));

— samjudson
स्रोत

1

पहले वाला (प्रारूप) मुझे बेहतर लगता है। यह अधिक पठनीय है और आप अतिरिक्त अस्थायी स्ट्रिंग ऑब्जेक्ट नहीं बना रहे हैं।

— Rismo
स्रोत

1

मैं जिज्ञासु था कि जहां स्ट्रिंगब्रुलेस्ट इन परीक्षणों के साथ खड़ा था। नीचे दिए गए परिणाम ...

class Program {
   static void Main(string[] args) {

      var p = new { FirstName = "Bill", LastName = "Gates" };

      var tests = new[] {
         new { Name = "Concat", Action = new Action(delegate() { string x = p.FirstName + " " + p.LastName; }) },
         new { Name = "Format", Action = new Action(delegate() { string x = string.Format("{0} {1}", p.FirstName, p.LastName); }) },
         new { Name = "StringBuilder", Action = new Action(delegate() {
            StringBuilder sb = new StringBuilder();
            sb.Append(p.FirstName);
            sb.Append(" ");
            sb.Append(p.LastName);
            string x = sb.ToString();
         }) }
      };

      var Watch = new Stopwatch();
      foreach (var t in tests) {
         for (int i = 0; i < 5; i++) {
            Watch.Reset();
            long Elapsed = ElapsedTicks(t.Action, Watch, 10000);
            Console.WriteLine(string.Format("{0}: {1} ticks", t.Name, Elapsed.ToString()));
         }
      }
   }

   public static long ElapsedTicks(Action ActionDelg, Stopwatch Watch, int Iterations) {
      Watch.Start();
      for (int i = 0; i < Iterations; i++) {
         ActionDelg();
      }
      Watch.Stop();
      return Watch.ElapsedTicks / Iterations;
   }
}

परिणाम:

कॉनकट: 406 टिक्स
Concat: 356 टिक्स
Concat: 411 टिक
Concat: 299 टिक
Concat: 266 टिक्स
प्रारूप: 5269 टिक
प्रारूप: 954 टिक
प्रारूप: 1004 टिक
प्रारूप: 984 टिक
प्रारूप: 974 टिक
स्ट्रिंगबर्स्ट: 629 टिक
स्ट्रिंगबर्स्ट: 484 टिक
स्ट्रिंगबर्स्ट: 482 टिक
स्ट्रिंगबर्स्ट: 508 टिक
स्ट्रिंगबर्स्ट: 504 टिक

— स्पॉल्सन को दर्शाता है
स्रोत

1

MCSD प्रस्तुत करने की सामग्री के अनुसार, Microsoft सुझाव देता है कि बहुत कम संख्या (शायद 2 से 4) के साथ काम करते समय + ऑपरेटर का उपयोग किया जाए। मुझे अब भी यकीन नहीं है कि क्यों, लेकिन यह विचार करने के लिए कुछ है।

— बाबक नफ़स
स्रोत