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




.net string (11)

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

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

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; 
}

.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 देखें।


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

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

आपका पहला उदाहरण जो 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));
}

इस बारे में कैसा है:

//Repeats a character specified number of times
public static string Repeat(char character,int numberOfIterations)
{
    return "".PadLeft(numberOfIterations, character);
}

//Call the Repeat method
Console.WriteLine(Repeat('\t',40));

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

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

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

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

मुझे पता है कि यह सवाल पहले से ही पांच साल पुराना है लेकिन स्ट्रेट को दोहराने का एक आसान तरीका है जो नेट 2.0 में भी काम करता है।

एक स्ट्रिंग दोहराने के लिए:

string repeated = new String('+', 3).Replace("+", "Hello, ");

रिटर्न

"नमस्ते नमस्ते नमस्ते, "

एक सरणी के रूप में एक स्ट्रिंग दोहराने के लिए:

// Two line version.
string repeated = new String('+', 3).Replace("+", "Hello,");
string[] repeatedArray = repeated.Split(',');

// One line version.
string[] repeatedArray = new String('+', 3).Replace("+", "Hello,").Split(',');

रिटर्न

{"नमस्ते नमस्ते नमस्ते", ""}

इसे सरल रखें।


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

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)) // स्ट्रिंग संस्करण


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

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

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

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


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());




string