Der beste Weg, um ein Zeichen in C # zu wiederholen

Was ist der beste Weg, eine Zeichenfolge von \t ‘s in C # zu generieren

Ich lerne C # und experimentiere mit verschiedenen Arten, dasselbe zu sagen.

Tabs(uint t) ist eine function, die eine string mit der Anzahl \t s zurückgibt

Zum Beispiel gibt Tabs(3) "\t\t\t"

Welche dieser drei Möglichkeiten zur Implementierung von Tabs(uint numTabs) ist am besten?

Das hängt natürlich davon ab, was “am besten” bedeutet.

  1. Die LINQ-Version ist nur zwei Zeilen, was schön ist. Aber sind die Aufrufe zum Wiederholen und Aggregieren unnötigerweise zeit- und ressourcenaufwendig?

  2. Die StringBuilder Version ist sehr klar, aber ist die StringBuilder class irgendwie langsamer?

  3. Die string Version ist einfach, was bedeutet, dass sie einfach zu verstehen ist.

  4. Ist das überhaupt egal? Sind sie alle gleich?

Das sind alles Fragen, die mir helfen, ein besseres Gefühl für C # zu bekommen.

 private string Tabs(uint numTabs) { IEnumerable 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; } 

Was ist damit?

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

Dabei steht n für die Anzahl der Wiederholungen der Zeichenfolge.

Oder besser:

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

In allen Versionen von .NET können Sie eine Zeichenfolge wie folgt wiederholen:

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

Um einen Charakter zu wiederholen, ist der new String('\t', count) die beste Wahl. Siehe die Antwort von @CMS .

 string.Concat(Enumerable.Repeat("ab", 2)); 

Kehrt zurück

“Abab”

Und

 string.Concat(Enumerable.Repeat("a", 2)); 

Kehrt zurück

“aa”

von…

Gibt es eine eingebaute function, um string oder char in .net zu wiederholen?

Die beste Version ist sicherlich die eingebaute Methode:

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

Von den anderen Lösungen bevorzugen Sie die einfachste; nur wenn dies zu langsam ist, streben Sie nach einer effizienteren Lösung.

Wenn Sie einen StringBuilder und dessen resultierende Länge im Voraus kennen, dann verwenden Sie auch einen geeigneten Konstruktor, dies ist viel effizienter, da dies bedeutet, dass nur eine zeitaufwendige Zuweisung stattfindet und kein unnötiges Kopieren von Daten stattfindet. Unsinn: Natürlich ist der obige Code effizienter.

Erweiterungsmethoden:

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

Was ist mit der Erweiterungsmethode?


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

Sie könnten dann schreiben:

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

Beachten Sie, dass ein performancestest der Verwendung der Stringbuilder-Version für einfache Zeichen anstelle von Zeichenfolgen eine größere Penance-Penalität ergibt: Auf meinem Computer liegt der Unterschied in der gemessenen performance bei 1:20 zwischen: Debug.WriteLine ('-'. Repeat (1000000)) // Zeichenversion und
Debug.WriteLine ("-". Wiederholen (1000000)) // String-Version

Wie wäre es damit:

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

Ich weiß, dass diese Frage bereits fünf Jahre alt ist, aber es gibt eine einfache Möglichkeit, eine Zeichenfolge zu wiederholen, die sogar in .Net 2.0 funktioniert.

So wiederholen Sie eine Zeichenfolge:

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

Kehrt zurück

“Hallo hallo hallo, ”

So wiederholen Sie eine Zeichenfolge als Array:

 // 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(','); 

Kehrt zurück

{“Hallo hallo hallo”, “”}

Halte es einfach.

Nehmen wir an, Sie möchten ‘\ t’ n mehrmals wiederholen, Sie können verwenden;

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

Ihr erstes Beispiel mit Enumerable.Repeat :

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

kann mit String.Concat kompakter String.Concat :

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

Mit String.Concat und Enumerable.Repeat die weniger String.Join als mit 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()); 

Die Antwort hängt wirklich von der Komplexität ab, die Sie wünschen. Ich möchte beispielsweise alle meine Einzüge mit einem vertikalen Balken umreißen, sodass meine Einzugsstring wie folgt bestimmt wird:

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

Sie können eine Erweiterungsmethode erstellen

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

Dann kannst du es so benutzen

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

Und noch eine andere Methode

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

Ohne Zweifel ist die akzeptierte Antwort der beste und schnellste Weg, um einen einzelnen Charakter zu wiederholen.

Binoj Anthonys Antwort ist eine einfache und recht effiziente Art, eine Saite zu wiederholen.

Wenn Ihnen etwas mehr Code nichts ausmacht, können Sie meine Array-Füllmethode verwenden, um diese Zeichenfolgen noch schneller zu erstellen. In meinen Vergleichstests wurde der Code in etwa 35% der Zeit des StringBuilder.Insert-Codes ausgeführt.

 public static string Repeat(this string value, int count) { var values = new char[count * value.Length]; values.Fill(value.ToCharArray()); return new string(values); } public static void Fill(this T[] destinationArray, params T[] value) { if (destinationArray == null) { throw new ArgumentNullException("destinationArray"); } if (value.Length > destinationArray.Length) { throw new ArgumentException("Length of value array must not be more than length of destination"); } // set the initial array value Array.Copy(value, destinationArray, value.Length); int copyLength, nextCopyLength; for (copyLength = value.Length; (nextCopyLength = copyLength < < 1) < destinationArray.Length; copyLength = nextCopyLength) { Array.Copy(destinationArray, 0, destinationArray, copyLength, copyLength); } Array.Copy(destinationArray, 0, destinationArray, copyLength, destinationArray.Length - copyLength); } 

Weitere Informationen zu dieser Array-Füllmethode finden Sie unter Schnellste Methode zum Füllen eines Arrays mit einem einzelnen Wert

Für mich ist in Ordnung:

 public static class Utils { public static string LeftZerosFormatter(int zeros, int val) { string valstr = val.ToString(); valstr = new string('0', zeros) + valstr; return valstr.Substring(valstr.Length - zeros, zeros); } } 

Versuche dies:

  1. Fügen Sie Microsoft.VisualBasic-Referenz hinzu
  2. Verwendung: String result = Microsoft.VisualBasic.Strings.StrDup (5, “hi”);
  3. Lass es mich wissen, wenn es für dich funktioniert.

Obwohl ich einem früheren Vorschlag sehr ähnlich bin, möchte ich es einfach halten und folgendes anwenden:

 string MyFancyString = "*"; int strLength = 50; System.Console.WriteLine(MyFancyString.PadRight(strLength, "*"); 

Standard .Net wirklich,