Der effizienteste Weg, um Strings zu verketten?

Was ist der effizienteste Weg, um Zeichenfolgen zu verketten?

Die StringBuilder.Append()Methode ist viel besser als die Verwendung des +Operators. Aber ich habe festgestellt, dass es bei der Ausführung von 1000 Verkettungen oder weniger String.Join()noch effizienter ist als StringBuilder.

StringBuilder sb = new StringBuilder();
sb.Append(someString);

Das einzige Problem dabei String.Joinist, dass Sie die Zeichenfolgen mit einem gemeinsamen Trennzeichen verketten müssen.

Bearbeiten: Wie @ryanversaw betonte, können Sie das Trennzeichen festlegenstring.Empty .

string key = String.Join("_", new String[] 
{ "Customers_Contacts", customerID, database, SessionID });

Rico Mariani , der .NET Performance Guru, hatte einen Artikel zu diesem Thema. Es ist nicht so einfach, wie man vermuten könnte. Der grundlegende Rat lautet:

Wenn Ihr Muster so aussieht:

x = f1(...) + f2(...) + f3(...) + f4(...)

Das ist ein Concat und es ist flink, StringBuilder wird wahrscheinlich nicht helfen.

Wenn Ihr Muster so aussieht:

if (...) x += f1(...)
if (...) x += f2(...)
if (...) x += f3(...)
if (...) x += f4(...)

dann möchten Sie wahrscheinlich StringBuilder.

Ein weiterer Artikel zur Unterstützung dieser Behauptung stammt von Eric Lippert, in dem er die Optimierungen, die für +Verkettungen in einer Zeile durchgeführt wurden, ausführlich beschreibt.

Es gibt 6 Arten von Zeichenfolgenverkettungen:

1. Verwenden Sie das Pluszeichen ( +).
2. Verwenden von string.Concat().
3. Verwenden von string.Join().
4. Verwenden von string.Format().
5. Verwenden von string.Append().
6. Verwenden von StringBuilder.

In einem Experiment wurde dies bewiesen string.Concat() der beste Weg ist, wenn die Wörter weniger als 1000 (ungefähr) sind und wenn die Wörter mehr als 1000 sind, dann StringBuildersollte verwendet werden.

Weitere Informationen finden Sie auf dieser Website .

string.Join () vs string.Concat ()

Die string.Concat-Methode entspricht hier dem Aufruf der string.Join-Methode mit einem leeren Trennzeichen. Das Anhängen einer leeren Zeichenfolge ist schnell, aber nicht schneller. Daher wäre die Methode string.Concat hier überlegen.

Von Chinh Do - StringBuilder ist nicht immer schneller :

Faustregeln

• Bei der Verkettung von dreiVerwenden Sie dynamischen Zeichenfolgenwerten oder weniger die herkömmliche Zeichenfolgenverkettung.

• Verwenden Sie, wenn Sie mehr als drei dynamische Zeichenfolgenwerte verketten StringBuilder.

• Verwenden Sie beim Erstellen einer großen Zeichenfolge aus mehreren Zeichenfolgenliteralen entweder das @Zeichenfolgenliteral oder den Inline + -Operator.

Die meiste Zeit StringBuilderist Ihre beste Wahl, aber es gibt Fälle, wie in diesem Beitrag gezeigt, in denen Sie zumindest über jede Situation nachdenken sollten.

Wenn Sie in einer Schleife arbeiten, StringBuilderist dies wahrscheinlich der richtige Weg. Dies erspart Ihnen den Aufwand, regelmäßig neue Zeichenfolgen zu erstellen. In Code, der nur einmal ausgeführt wird, String.Concatist dies wahrscheinlich in Ordnung.

Rico Mariani (.NET-Optimierungsguru) hat jedoch ein Quiz zusammengestellt, in dem er am Ende erklärte, dass er in den meisten Fällen empfiehlt String.Format.

Hier ist die schnellste Methode, die ich in einem Jahrzehnt für meine große NLP-App entwickelt habe. Ich habe Variationen für IEnumerable<T>und andere Eingabetypen mit und ohne Trennzeichen unterschiedlicher Typen ( Char, String), aber hier zeige ich den einfachen Fall, dass alle Zeichenfolgen in einem Array zu einer einzelnen Zeichenfolge ohne Trennzeichen verkettet werden . Die neueste Version hier wurde unter C # 7 und .NET 4.7 entwickelt und getestet .

Es gibt zwei Schlüssel für eine höhere Leistung. Die erste besteht darin, die genaue erforderliche Gesamtgröße vorab zu berechnen. Dieser Schritt ist trivial, wenn die Eingabe ein Array ist, wie hier gezeigt. Für die Behandlung IEnumerable<T>lohnt es sich, zuerst die Zeichenfolgen in einem temporären Array zu sammeln, um diese Summe zu berechnen (das Array ist erforderlich, um einen Aufruf zu vermeidenToString() mehr als einmal pro Element da dies technisch gesehen die Möglichkeit einer möglichen Änderung der erwarteten Semantik haben könnte einer 'String Join'-Operation).

Angesichts der Gesamtzuordnungsgröße der endgültigen Zeichenfolge wird der größte Leistungsschub erzielt, wenn die Ergebniszeichenfolge direkt erstellt wird . Dies erfordert die (möglicherweise umstrittene) Technik, die Unveränderlichkeit eines neuen, Stringder zunächst mit Nullen versehen ist, vorübergehend auszusetzen . Abgesehen von solchen Kontroversen ...

... beachten Sie, dass dies die einzige Massenverkettungslösung auf dieser Seite ist, die eine zusätzliche Zuordnungs- und Kopierrunde durch den StringKonstruktor vollständig vermeidet .

Vollständiger Code:

/// <summary>
/// Concatenate the strings in 'rg', none of which may be null, into a single String.
/// </summary>
public static unsafe String StringJoin(this String[] rg)
{
    int i;
    if (rg == null || (i = rg.Length) == 0)
        return String.Empty;

    if (i == 1)
        return rg[0];

    String s, t;
    int cch = 0;
    do
        cch += rg[--i].Length;
    while (i > 0);
    if (cch == 0)
        return String.Empty;

    i = rg.Length;
    fixed (Char* _p = (s = new String(default(Char), cch)))
    {
        Char* pDst = _p + cch;
        do
            if ((t = rg[--i]).Length > 0)
                fixed (Char* pSrc = t)
                    memcpy(pDst -= t.Length, pSrc, (UIntPtr)(t.Length << 1));
        while (pDst > _p);
    }
    return s;
}

[DllImport("MSVCR120_CLR0400", CallingConvention = CallingConvention.Cdecl)]
static extern unsafe void* memcpy(void* dest, void* src, UIntPtr cb);

Ich sollte erwähnen, dass dieser Code eine geringfügige Änderung gegenüber dem aufweist, was ich selbst verwende. Im Original rufe ich die Anweisung cpblk IL von C # auf, um das eigentliche Kopieren durchzuführen . Zur Vereinfachung und Portabilität des Codes hier habe ich diesen memcpystattdessen durch P / Invoke ersetzt , wie Sie sehen können. Für höchste Leistung unter x64 ( aber möglicherweise nicht unter x86 ) möchten Sie möglicherweise stattdessen die cpblk- Methode verwenden.

Aus diesem MSDN-Artikel :

Das Erstellen eines StringBuilder-Objekts ist zeitlich und im Speicher mit einem gewissen Aufwand verbunden. Auf einem Computer mit schnellem Speicher lohnt sich ein StringBuilder, wenn Sie ungefähr fünf Operationen ausführen. Als Faustregel würde ich sagen, dass 10 oder mehr Zeichenfolgenoperationen eine Rechtfertigung für den Overhead auf jeder Maschine sind, auch auf einer langsameren.

Wenn Sie also MSDN vertrauen, gehen Sie mit StringBuilder, wenn Sie mehr als 10 Zeichenfolgenoperationen / -verkettungen ausführen müssen - andernfalls ist eine einfache Zeichenfolgenübereinstimmung mit '+' in Ordnung.

Es ist auch wichtig darauf hinzuweisen, dass Sie den +Operator verwenden sollten, wenn Sie Zeichenfolgenliterale verketten .

Wenn Sie Zeichenfolgenliterale oder Zeichenfolgenkonstanten mit dem Operator + verketten, erstellt der Compiler eine einzelne Zeichenfolge. Es tritt keine Laufzeitverkettung auf.

Gewusst wie: Verketten mehrerer Zeichenfolgen (C # -Programmierhandbuch)

Beachten Sie, dass StringBuilder zusätzlich zu den anderen Antworten eine anfängliche Speichermenge zugewiesen werden kann .

Der Kapazitätsparameter definiert die maximale Anzahl von Zeichen, die in dem von der aktuellen Instanz zugewiesenen Speicher gespeichert werden können. Sein Wert wird der Capacity- Eigenschaft zugewiesen . Wenn die Anzahl der in der aktuellen Instanz zu speichernden Zeichen diesen Kapazitätswert überschreitet , weist das StringBuilder-Objekt zusätzlichen Speicher zum Speichern zu.

Wenn die Kapazität Null ist, wird die implementierungsspezifische Standardkapazität verwendet.

Das wiederholte Anhängen an einen nicht vorab zugewiesenen StringBuilder kann zu vielen unnötigen Zuweisungen führen, ebenso wie das wiederholte Verketten regulärer Zeichenfolgen.

Wenn Sie wissen, wie lang die endgültige Zeichenfolge sein wird, sie trivial berechnen oder eine fundierte Vermutung über den allgemeinen Fall anstellen können (zu viel zuzuweisen ist nicht unbedingt eine schlechte Sache), sollten Sie diese Informationen dem Konstruktor oder dem Kapazitätseigenschaft . Insbesondere beim Ausführen von Leistungstests, um StringBuilder mit anderen Methoden wie String.Concat zu vergleichen, die intern dasselbe tun. Jeder Test, den Sie online sehen und der keine StringBuilder-Vorzuweisung in seine Vergleiche einbezieht, ist falsch.

Wenn Sie keine Vermutung über die Größe anstellen können, schreiben Sie wahrscheinlich eine Dienstprogrammfunktion, die über ein eigenes optionales Argument zur Steuerung der Vorzuweisung verfügen sollte.

Das Folgende kann eine weitere alternative Lösung sein, um mehrere Zeichenfolgen zu verketten.

String str1 = "sometext";
string str2 = "some other text";

string afterConcate = $"{str1}{str2}";

String-Interpolation

Am effizientesten ist es, StringBuilder wie folgt zu verwenden:

StringBuilder sb = new StringBuilder();
sb.Append("string1");
sb.Append("string2");
...etc...
String strResult = sb.ToString();

@jonezy: String.Concat ist in Ordnung, wenn Sie ein paar kleine Dinge haben. Wenn Sie jedoch Megabyte an Daten verketten, wird Ihr Programm wahrscheinlich tanken.

Probieren Sie diese 2 Codeteile aus und Sie werden die Lösung finden.

 static void Main(string[] args)
    {
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < 10000000; i++)
        {
            s.Append( i.ToString());
        }
        Console.Write("End");
        Console.Read();
    }

Vs

static void Main(string[] args)
    {
        string s = "";
        for (int i = 0; i < 10000000; i++)
        {
            s += i.ToString();
        }
        Console.Write("End");
        Console.Read();
    }

Sie werden feststellen, dass der erste Code sehr schnell endet und der Speicher in einer guten Menge vorhanden ist.

Der zweite Code ist vielleicht in Ordnung, aber es wird länger dauern ... viel länger. Wenn Sie also eine Anwendung für viele Benutzer haben und Geschwindigkeit benötigen, verwenden Sie die erste. Wenn Sie eine App für eine kurzfristige Ein-Benutzer-App haben, können Sie möglicherweise beide verwenden, oder die zweite ist für Entwickler "natürlicher".

Prost.

Für nur zwei Zeichenfolgen möchten Sie StringBuilder definitiv nicht verwenden. Es gibt einen Schwellenwert, oberhalb dessen der StringBuilder-Overhead geringer ist als der Overhead beim Zuweisen mehrerer Strings.

Verwenden Sie für mehr als 2-3 Zeichenfolgen den Code von DannySmurf . Verwenden Sie andernfalls einfach den Operator +.

System.String ist unveränderlich. Wenn wir den Wert einer Zeichenfolgenvariablen ändern, wird dem neuen Wert ein neuer Speicher zugewiesen und die vorherige Speicherzuordnung freigegeben. System.StringBuilder wurde für das Konzept einer veränderlichen Zeichenfolge entwickelt, bei der eine Vielzahl von Operationen ausgeführt werden können, ohne dass der geänderten Zeichenfolge ein separater Speicherort zugewiesen werden muss.

Eine andere Lösung:

Verwenden Sie innerhalb der Schleife List anstelle von String.

List<string> lst= new List<string>();

for(int i=0; i<100000; i++){
    ...........
    lst.Add(...);
}
return String.Join("", lst.ToArray());;

es ist sehr sehr schnell.

Es hängt wirklich von Ihrem Nutzungsmuster ab. Einen detaillierten Benchmark zwischen string.Join, string, Concat und string.Format finden Sie hier: String.Format ist nicht für die intensive Protokollierung geeignet

(Dies ist eigentlich die gleiche Antwort, die ich auf diese Frage gegeben habe)

Es würde vom Code abhängen. StringBuilder ist im Allgemeinen effizienter, aber wenn Sie nur ein paar Zeichenfolgen verketten und alles in einer Zeile erledigen, werden Code-Optimierungen dies wahrscheinlich für Sie erledigen. Es ist wichtig, darüber nachzudenken, wie der Code auch aussieht: Bei größeren Mengen erleichtert StringBuilder das Lesen, bei kleinen fügt StringBuilder nur unnötige Unordnung hinzu.