c# सी#में एक चरित्र दोहराने का सबसे अच्छा तरीका




.net string (13)

सी # में स्ट्रिंग जेनरेट करने का सबसे अच्छा तरीका क्या है

मैं सी # सीख रहा हूं और एक ही बात कहने के विभिन्न तरीकों से प्रयोग कर रहा हूं।

Tabs(uint t) एक ऐसा फ़ंक्शन है जो t मात्रा के साथ एक string देता है

उदाहरण के लिए Tabs(3) "\t\t\t" लौटाता है

Tabs(uint numTabs) को लागू करने के इन तीन तरीकों में से कौन सा सबसे अच्छा है?

बेशक यह "सर्वोत्तम" साधनों पर निर्भर करता है।

  1. LINQ संस्करण केवल दो पंक्तियां है, जो कि अच्छा है। लेकिन क्या अनावश्यक समय / संसाधन उपभोग करने के लिए दोबारा कॉल करने और एकत्रित करने के लिए कॉल हैं?

  2. StringBuilder संस्करण बहुत स्पष्ट है लेकिन StringBuilder वर्ग किसी भी तरह धीमा है?

  3. string संस्करण मूल है, जिसका अर्थ है कि इसे समझना आसान है।

  4. क्या इससे कोई फर्क नहीं पड़ता? क्या वे सब बराबर हैं?

सी # के लिए बेहतर महसूस करने में मेरी मदद करने के लिए ये सभी प्रश्न हैं।

private string Tabs(uint numTabs)
{
    IEnumerable<string> tabs = Enumerable.Repeat("\t", (int) numTabs);
    return (numTabs > 0) ? tabs.Aggregate((sum, next) => sum + next) : ""; 
}  

private string Tabs(uint numTabs)
{
    StringBuilder sb = new StringBuilder();
    for (uint i = 0; i < numTabs; i++)
        sb.Append("\t");

    return sb.ToString();
}  

private string Tabs(uint numTabs)
{
    string output = "";
    for (uint i = 0; i < numTabs; i++)
    {
        output += '\t';
    }
    return output; 
}

और अभी तक एक और तरीका है

new System.Text.StringBuilder().Append('\t', 100).ToString()

विस्तार विधियां:

public static string Repeat(this string s, int n)
{
    return new String(Enumerable.Range(0, n).SelectMany(x => s).ToArray());
}

public static string Repeat(this char c, int n)
{
    return new String(c, n);
}

आप एक विस्तार विधि बना सकते हैं

static class MyExtensions
{
    internal static string Repeat(this char c, int n)
    {
        return new string(c, n);
    }
}

फिर आप इसे इस तरह इस्तेमाल कर सकते हैं

Console.WriteLine('\t'.Repeat(10));

String.Concat और Enumerable.Repeat का उपयोग करना। String.Concat जो String.Join का उपयोग करने से कम महंगा होगा

public static Repeat(this String pattern, int count)
{
    return String.Concat(Enumerable.Repeat(pattern, count));
}

var str = new string(Enumerable.Repeat('\t', numTabs).ToArray());

इसे इस्तेमाल करे:

  1. माइक्रोसॉफ्ट जोड़ें। VisualBasic संदर्भ
  2. उपयोग करें: स्ट्रिंग परिणाम = माइक्रोसॉफ्ट। विज़ुअल बासिक .trings.StrDup (5, "हाय");
  3. अगर यह आप के लिए काम करता है तो मुझे बतलाएगा।

इस बारे में क्या:

string tabs = new String('\t', n);

जहां n स्ट्रिंग को दोहराना चाहते हैं, उस समय की संख्या है।

या और अच्छा:

static string Tabs(int n)
{
    return new String('\t', n);
}

सबसे अच्छा संस्करण निश्चित रूप से बिल्टिन तरीके का उपयोग करना है:

string Tabs(int len) { return new string('\t', len); }

अन्य समाधानों में से, सबसे आसान पसंद करते हैं; केवल अगर यह बहुत धीमी साबित हो रहा है, तो एक अधिक कुशल समाधान के लिए प्रयास करें।

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


.NET के सभी संस्करणों में, आप इस प्रकार एक स्ट्रिंग दोहरा सकते हैं:

public static string Repeat(string value, int count)
{
    return new StringBuilder(value.Length * count).Insert(0, value, count).ToString();
}

एक चरित्र दोहराने के लिए, new String('\t', count) आपकी सबसे अच्छी शर्त है। share देखें।


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

return new string(Enumerable.Range(0, indentSize*indent).Select(
  n => n%4 == 0 ? '|' : ' ').ToArray());

आइए मान लें कि आप '\ t' n बार बार दोहराना चाहते हैं, आप इसका उपयोग कर सकते हैं;

String.Empty.PadRight(n,'\t')

विस्तार विधि का उपयोग करने के बारे में क्या?

public static class StringExtensions
{
   public static string Repeat(this char chatToRepeat, int repeat) {

       return new string(chatToRepeat,repeat);
   }
   public  static string Repeat(this string stringToRepeat,int repeat)
   {
       var builder = new StringBuilder(repeat*stringToRepeat.Length);
       for (int i = 0; i < repeat; i++) {
           builder.Append(stringToRepeat);
       }
       return builder.ToString();
   }
}

फिर आप लिख सकते हैं:

Debug.WriteLine('-'.Repeat(100)); // For Chars  
Debug.WriteLine("Hello".Repeat(100)); // For Strings

ध्यान दें कि तारों के बजाए सरल वर्णों के लिए स्ट्रिंगबिल्डर संस्करण का उपयोग करने का एक प्रदर्शन परीक्षण आपको एक प्रमुख प्रीफॉर्मेंस पेनल्टी देता है: मेरे कंप्यूटर पर मेसर्ड प्रदर्शन में अंतर 1:20 के बीच है: Debug.WriteLine ('-'। दोहराना (1000000)) // चार संस्करण और
डीबग। राइटलाइन ("-" दोहराना (1000000)) // स्ट्रिंग संस्करण


आपका पहला उदाहरण जो Enumerable.Repeat का उपयोग करता है। Enumerable.Repeat :

private string Tabs(uint numTabs)
{
    IEnumerable<string> tabs = Enumerable.Repeat(
                                 "\t", (int) numTabs);
    return (numTabs > 0) ? 
            tabs.Aggregate((sum, next) => sum + next) : ""; 
} 

String.Concat साथ अधिक String.Concat फिर से लिखा जा सकता है:

private string Tabs(uint numTabs)
{       
    return String.Concat(Enumerable.Repeat("\t", (int) numTabs));
}






string