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

Was ist der beste Weg, um 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 Funktion, die a stringmit der tAnzahl von \t's zurückgibt

Zum Beispiel Tabs(3)kehrt zurück"\t\t\t"

Welche dieser drei Implementierungsmethoden Tabs(uint numTabs)ist die beste?

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

1. Die LINQ-Version besteht nur aus zwei Zeilen, was sehr schön ist. Aber sind die Aufrufe zum Wiederholen und Aggregieren unnötig zeit- und ressourcenintensiv?

2. Die StringBuilderVersion ist sehr klar, aber ist die StringBuilderKlasse irgendwie langsamer?

3. Die stringVersion ist einfach, was bedeutet, dass sie leicht zu verstehen ist.

4. Ist das überhaupt nicht wichtig? Sind sie alle gleich?

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

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

Was ist damit:

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

Wo nmöchten Sie die Zeichenfolge wiederholen?

Oder besser:

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

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 integrierte Funktion zum Wiederholen von Zeichenfolgen oder Zeichen in .net?

In allen Versionen von .NET können Sie eine Zeichenfolge folgendermaßen wiederholen:

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

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

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 sich dies als zu langsam herausstellt, streben Sie nach einer effizienteren Lösung.

Wenn Sie a verwenden StringBuilderund die resultierende Länge im Voraus kennen, dann verwenden Sie auch einen geeigneten Konstruktor. Dies ist viel effizienter, da nur eine zeitaufwändige Zuordnung erfolgt und keine unnötigen Daten kopiert werden. 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 Leistungstest der Verwendung der Stringbuilder-Version für einfache Zeichen anstelle von Zeichenfolgen zu einer erheblichen Leistungsminderung führt: Auf meinem Computer beträgt der Unterschied in der gemessenen Leistung 1:20 zwischen: Debug.WriteLine ('-'. Repeat (1000000)) // char version und
Debug.WriteLine ("-". Repeat (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.

Angenommen, Sie möchten '\ t' n so oft wiederholen, wie Sie verwenden können.

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

Ihr erstes 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) : ""; 
} 

kann kompakter umgeschrieben werden mit String.Concat:

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

Verwenden String.Concatund Enumerable.Repeatdas ist billiger als verwendenString.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 gewünschten Komplexität ab. Zum Beispiel möchte ich alle meine Einrückungen mit einem vertikalen Balken umreißen, sodass meine Einrückungszeichenfolge wie folgt bestimmt wird:

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

Und noch eine andere Methode

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

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

Sie können eine Erweiterungsmethode erstellen

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

Dann können Sie es so verwenden

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

Ohne Zweifel ist die akzeptierte Antwort der beste und schnellste Weg, um ein einzelnes Zeichen zu wiederholen.

Die Antwort von Binoj Anthony ist eine einfache und recht effiziente Möglichkeit, eine Zeichenfolge zu wiederholen.

Wenn Ihnen jedoch etwas mehr Code nichts ausmacht, können Sie meine Array-Fülltechnik verwenden, um diese Zeichenfolgen noch schneller effizient zu erstellen. In meinen Vergleichstests wurde der folgende 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<T>(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ülltechnik finden Sie unter Schnellste Methode zum Füllen eines Arrays mit einem einzelnen Wert

Versuche dies:

1. Fügen Sie die Microsoft.VisualBasic-Referenz hinzu
2. Verwendung: String result = Microsoft.VisualBasic.Strings.StrDup (5, "hi");
3. Lassen Sie mich wissen, ob es für Sie funktioniert.

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

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

Standard .Net wirklich,