„Verwenden String oder foreach nicht in diesem heißen Codepfad“

Question

ich den Quellcode des Open-Source-Projektes SignalR bin gerade, und ich sehe this diff code die „nicht String oder foreach in diesem heißen Code berechtigt ist, Verwenden Pfad“:

-   public static string MakeCursor(IEnumerable<Cursor> cursors) 
+   public static string MakeCursor(IList<Cursor> cursors) 
      { 
-    var sb = new StringBuilder(); 
-    bool first = true; 
-    foreach (var c in cursors) 
+    var result = ""; 
+    for (int i = 0; i < cursors.Count; i++) 
       { 
-     if (!first) 
+     if (i > 0) 
        { 
-      sb.Append('|'); 
+      result += '|'; 
        } 
-     sb.Append(Escape(c.Key)); 
-     sb.Append(','); 
-     sb.Append(c.Id); 
-     first = false; 
+     result += Escape(cursors[i].Key); 
+     result += ','; 
+     result += cursors[i].Id; 
       } 
-    return sb.ToString(); 
+    return result; 
      } 

ich verstehe, warum foreach manchmal weniger effizient sein könnte, und warum ist es durch für ersetzt.

Allerdings habe ich gelernt und erlebt, dass der StringBuilder der effizienteste Weg zum Verketten von Strings ist. Ich frage mich also, warum der Autor sich dafür entschieden hat, es durch eine Standardverkettung zu ersetzen.

Was ist hier und im Allgemeinen falsch bei der Verwendung von StringBuilder?

Answer 1

Ich machte den Code ändern und ja es machte einen großen Unterschied in der Anzahl der Zuordnungen (GetEnumerator()) Anrufe vs nicht. Stellen Sie sich vor, dieser Code ist Millionen Mal pro Sekunde. Die Anzahl der zugeordneten Enumeratoren ist lächerlich und kann vermieden werden.

edit: Wir haben jetzt Kontrolle, um invertieren alle Zuweisungen zu vermeiden (zum Schriftsteller zu schreiben direkt): https://github.com/SignalR/SignalR/blob/2.0.2/src/Microsoft.AspNet.SignalR.Core/Messaging/Cursor.cs#L36

Answer 2

Wie viele Verkettungen machst du? Wenn mehrere, verwenden Sie StringBuilder. Wenn nur ein paar, dann wird der Overhead des Erstellens des StringBuilders jeden Vorteil überwiegen.

Answer 3

Ich hoffe nur, dass der Typ, der das geändert hat, tatsächlich den Unterschied gemessen hat.

• Es gibt Overhead bei der Instanziierung eines neuen Stringbuilders jedes Mal. Dies setzt auch die Speicher-/Speicherbereinigung unter Druck.
• Der Compiler kann langsamer
• Die FOR sein könnte in der Tat ‚stringbuilderlike‘ Code für einfache Verkettungen erzeugen, weil es könnte die Überprüfung der Grenzen erfordern, die mit foreach-Schleifen erfolgt nicht als die Compiler ‚weiß‘, sie sind in Grenzen.

Answer 4

werde ich mein Geld setzen auf

  StringBuilder sb = new StringBuilder(); 
      bool first = true; 
      foreach (Cursor c in cursors) 
      { 
       if (first) 
       { 
        first = false; // only assign it once 
       } 
       else 
       { 
        sb.Append('|'); 
       } 
       sb.Append(Escape(c.Key) + ',' + c.Id); 
      } 
      return sb.ToString(); 

Aber ich würde mein Geld und das Update von dfowler setzen. Schau dir den Link in seiner Antwort an.

Answer 5

Es hängt von der Anzahl der für die Funktion bereitgestellten Cursor s ab.

Die meisten Vergleiche zwischen den beiden Einstellungen scheinen StringBuilder gegenüber der Zeichenkombination zu favorisieren, wenn 4-10 Zeichenketten verwendet werden. Ich würde höchstwahrscheinlich bevorzugen StringBuilder, wenn ich keine expliziten Gründe nicht auch hatte (z. B. Leistungsvergleich der beiden Ansätze für mein Problem/Anwendung). Ich würde in Betracht ziehen, einen Puffer in der StringBuilder vorzubestellen, um (viele) Neuzuweisungen zu vermeiden.

Weitere Informationen zu diesem Thema finden Sie unter String concatenation vs String Builder. Performance und Concatenating with StringBuilders vs. Strings.