Wie man Zeichen in C# richtig wiederholt: Vom naiven Code zur Optimierung

Einleitung: Warum die Frage nach der Zeichenwiederholung kultig wurde

Wenn Sie jemals in C# programmiert haben, sind Sie sicherlich auf die Aufgabe gestoßen: „Ich muss einen String erstellen, der aus N gleichen Zeichen besteht.“ Was könnte einfacher sein, könnte man meinen. Aber genau diese Frage hat auf Stack Overflow tausende Aufrufe und Dutzende Antworten gesammelt. Warum? Weil sich hinter der scheinbaren Einfachheit eine ganze Welt der Leistungsoptimierung und Fallstricke verbirgt.

In diesem Artikel zeigen wir nicht nur, wie man ein Zeichen in C# wiederholt. Wir gehen den Weg von der naiven Lösung hin zu professionellen Techniken, die in hochbelasteten Systemen verwendet werden. Sie erfahren, welche Methode am besten zum Wiederholen eines Zeichens in verschiedenen Szenarien geeignet ist und warum einige beliebte Ratschläge tatsächlich schädlich sind.

Für wen ist dieser Artikel nützlich?

\n
• Anfängern in der C#-Entwicklung, die nicht nur funktionierenden, sondern effizienten Code schreiben möchten
\n
• Erfahrenen Programmierern, die nach Möglichkeiten suchen, String-Operationen zu optimieren
\n
• Allen, die sich auf technische Vorstellungsgespräche vorbereiten und mit Kenntnissen der internen Funktionsweise von .NET glänzen möchten
\n

Das Problem: Warum man keine for-Schleife schreiben sollte

Wenn ein Anfänger hört „Zeichen N-mal wiederholen“, kommt ihm als Erstes eine for-Schleife in den Sinn:

string RepeatChar(char c, int count)\n{\n    string result = "";\n    for (int i = 0; i < count; i++)\n        result += c;\n    return result;\n}\n

Diese Lösung funktioniert, ist aber katastrophal langsam. Warum? Weil Strings in C# unveränderlich sind. Jede +=-Operation erstellt einen neuen String, kopiert den alten Inhalt plus ein Zeichen hinein. Die Komplexität eines solchen Algorithmus ist O(n²). Bei 10 Zeichen ist das nicht spürbar, aber bei 100.000 ist es eine Ewigkeit.

Schauen wir uns die realen Zahlen an. Testen wir diese Methode mit count = 100.000. Auf einem modernen Prozessor dauert das … mehrere Sekunden. Und wenn ein Zeichen eine Million Mal wiederholt werden muss? Das Programm „hängt“ einfach.

Fazit: Eine Schleife mit Verkettung ist böse. Es gibt jedoch andere, effizientere Ansätze.

Die wichtigsten Methoden zum Wiederholen eines Zeichens in C#

Betrachten wir alle gängigen Methoden, die auf Stack Overflow und in realen Projekten diskutiert werden. Wir testen jede auf Leistung und analysieren, wann welche verwendet werden sollte.

1. Der klassische StringBuilder

Der erste Schritt zur Optimierung ist die Verwendung von StringBuilder. Er erstellt bei jedem Hinzufügen keinen neuen String, sondern arbeitet mit einem Puffer:

string RepeatWithStringBuilder(char c, int count)\n{\n    StringBuilder sb = new StringBuilder(count);\n    for (int i = 0; i < count; i++)\n        sb.Append(c);\n    return sb.ToString();\n}\n

Beachten Sie: Wir haben sofort die Anfangskapazität count festgelegt. Das ist wichtig! Wenn keine Kapazität angegeben wird, muss StringBuilder mehrmals Speicher neu zuweisen, was die Leistung beeinträchtigt.

Leistung: O(n). Für 100.000 Zeichen benötigt diese Methode ~1-2 ms.

2. Zeichen-Array + new string

Und das ist eine der schnellsten Methoden in .NET. Wir erstellen ein Array mit der benötigten Länge, füllen es mit dem Zeichen und übergeben es an den String-Konstruktor:

string RepeatWithArray(char c, int count)\n{\n    char[] chars = new char[count];\n    Array.Fill(chars, c);\n    return new string(chars);\n}\n

Warum ist das schnell? Weil wir direkt mit dem Speicher arbeiten: Das Array wird in einem Durchlauf gefüllt, und der Konstruktor new string(char[]) kopiert die Daten einfach in den internen Puffer des Strings. Keine überflüssigen Operationen.

Leistung: