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

Was es ist der beste Weg zur Erzeugung einer Zeichenfolge von \t's in C#

Lerne ich C# und das Experimentieren mit verschiedenen Möglichkeiten, zu sagen, die gleiche Sache.

Tabs(uint t) ist eine Funktion zurückgibt, die ein string mit t Höhe von \t's

Beispielsweise Tabs(3) zurück "\t\t\t"

Welche dieser drei Möglichkeiten der Umsetzung Tabs(uint numTabs) ist am besten?

Natürlich, hängt davon ab, was "beste" bedeutet.

LINQ-version ist nur zwei Zeilen, das ist schön. Aber die Aufrufe, zu Wiederholen und zu Aggregieren unnötig Zeit/Ressourcen verschlingen?
Den StringBuilder version ist klar, aber ist die StringBuilder Klasse irgendwie langsamer?
Den string version basic, was bedeutet, es ist leicht zu verstehen.
Spielt es überhaupt keine Rolle? Sind Sie alle gleich?

Alles Fragen, die mir dabei helfen, ein besseres Gefühl für C#.

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

InformationsquelleAutor der Frage Alex Baranosky | 2009-01-04

.net c#string

Was dazu:
```
string tabs = new String('\t', n);
```
Wo n ist die Anzahl der Zeiten, die Sie möchten, wiederholen Sie die Zeichenfolge.

Oder besser:
```
static string Tabs(int n)
{
    return new String('\t', n);
}
```
InformationsquelleAutor der Antwort CMS
102

In allen Versionen .NET, können Sie wiederholt eine Zeichenfolge so:
```
public static string Repeat(string value, int count)
{
    return new StringBuilder(value.Length * count).Insert(0, value, count).ToString();
}
```
Wiederholen ein Zeichen new String('\t', count) ist Ihre beste Wette. Sehen die Antwort von @CMS.

InformationsquelleAutor der Antwort Binoj Antony
92
```
string.Concat(Enumerable.Repeat("ab", 2));
```
Gibt

"abab"

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

"aa"

...

Gibt es eine built-in Funktion zu wiederholen, string oder char .net?

InformationsquelleAutor der Antwort Carter Medlin
54

Die beste version ist sicherlich die Verwendung der builtin Weg:
```
string Tabs(int len) { return new string('\t', len); }
```
Anderen Lösungen, bevorzugen die einfachste; nur wenn dies erweist sich als zu langsam, das Streben nach einer effizienteren Lösung.

Wenn Sie eine StringBuilder und kennen die daraus resultierende Länge im Voraus, dann auch einen entsprechenden Konstruktor, das ist viel effizienter, da es bedeutet, dass nur eine zeitaufwendige Zuweisung erfolgt, und kein unnötiges kopieren von Daten.
Blödsinn: natürlich ist der obige code ist effizienter.

InformationsquelleAutor der Antwort Konrad Rudolph

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

InformationsquelleAutor der Antwort Rodrick Chapman

Was über die Verwendung von extension-Methode?

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

Könnte man dann schreiben :

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

Beachten, dass ein performance-test für die Verwendung der stringbuilder-version für einfache Zeichen anstelle von Zeichenfolgen gibt Ihnen einen großen Aufführung penality :
auf meinem Rechner ist der Unterschied in mesured Leistung 1:20 zwischen:
Debug.WriteLine('-'.Wiederholen(1000000)) //char version und

Debug.WriteLine("-".Wiederholen(1000000)) //string-version

InformationsquelleAutor der Antwort Ronnie

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

InformationsquelleAutor der Antwort Denys Wessels

19

Ich weiß, dass diese Frage fünf Jahre ist es schon alt, aber es gibt eine einfache Methode, Sie zu wiederholen ein string, der sogar funktioniert .Net 2.0.

Wiederholen Sie die Zeichenfolge:
```
string repeated = new String('+', 3).Replace("+", "Hello, ");
```
Gibt

"Hallo, Hallo, Hallo, "

Wiederholen Sie die Zeichenfolge als ein 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(',');
```
Gibt

{"Hello", "Hello", "Hello", ""}

Halten Sie es einfach.

InformationsquelleAutor der Antwort ChaimG
16

Lassen Sie uns sagen, Sie wollen zu wiederholen, '\t' n Anzahl der Zeiten, die Sie verwenden können;
```
String.Empty.PadRight(n,'\t')
```
InformationsquelleAutor der Antwort Amin

Mit String.Concat und Enumerable.Repeat die weniger teuer sind
als mit String.Join

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

InformationsquelleAutor der Antwort bradgonesurfing

Ihre erste Beispiel, das verwendet Enumerable.Repeat:

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

umgeschrieben werden kann kompakter mit String.Concat:

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

InformationsquelleAutor der Antwort Ray Vega

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

InformationsquelleAutor der Antwort w.b

4

Die Antwort hängt wirklich davon ab, die Komplexität, die Sie wollen. Zum Beispiel, ich möchte zu skizzieren, die alle meine Einrückungen mit einem vertikalen Balken, also meinem Einzug string wird wie folgt bestimmt:
```
return new string(Enumerable.Range(0, indentSize*indent).Select(
  n => n%4 == 0 ? '|' : ' ').ToArray());
```
InformationsquelleAutor der Antwort Dmitri Nesteruk

Können Sie erstellen, die eine Erweiterung Methode

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

Dann können Sie es verwenden, wie dies

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

InformationsquelleAutor der Antwort ivan

0

Versuchen Sie dies:
1. Hinzufügen Von Microsoft.VisualBasic-Verweis
2. Verwenden: String Ergebnis = Microsoft.VisualBasic.Strings.StrDup(5,"Hallo");
3. Lassen Sie mich wissen, wenn es für Sie arbeitet.
InformationsquelleAutor der Antwort Toso Pankovski
0

Und noch eine andere Methode
```
new System.Text.StringBuilder().Append('\t', 100).ToString()
```
InformationsquelleAutor der Antwort Artyom

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.