string.format mit Variablen vs Inline-Variablen

Was sind die Vor- / Nachteile (falls vorhanden) bei der Verwendung?

string output; 
int i = 10;
output = string.Format("the int is {0}", i);

gegen

string output; 
int i = 10;
output = "the int is " + i;

Ich habe immer das letztere Beispiel verwendet, aber es scheint, als ob eine gute Mehrheit der Online-Tutorials das Beispiel string.format verwendet. Ich glaube nicht, dass es echte Unterschiede in Bezug auf die Effizienz gibt. Mein erster Gedanke ist, dass ein Codierer die Zeichenfolge nicht ständig brechen muss, um Variablen einzufügen.

Wenn Sie die Übersetzung in Ihrem Projekt für wichtig halten, hilft Ihnen die erste Syntax dabei.

Zum Beispiel können Sie haben:

static final string output_en = "{0} is {1} years old.";
static final string output_fr = "{0} a {1} ans.";

int age = 10;
string name = "Henri";
System.out.println(string.Format(output_en, name, age));
System.out.println(string.Format(output_fr, name, age));

Beachten Sie auch, dass sich Ihre Variablen mit dieser Syntax möglicherweise nicht immer an derselben Stelle im Satz befinden:

static final string output_yoda = "{1} years {0} has.";

Überprüfen Sie die erste Antwort auf /programming/4671610/why-use-string-format . Es deckt meiner Meinung nach alles ab, warum es besser ist.

Außerdem verfügt jede .NET-Assembly über einen internen Pool, der eine Sammlung eindeutiger Zeichenfolgen enthält. Wenn Ihr Code kompiliert wird, werden alle Zeichenfolgenliterale, auf die Sie in Ihrem Code verweisen, diesem Pool hinzugefügt. Wenn Sie einen Code haben, der so aussieht:

"the int is " + i + " and the double is " + d

Das macht es 2 Saiten im Pool.

Wenn Sie haben:

"the int is {0} and the double is {1}"

Sie haben nur einen String im Pool.

Es ist etwas komplizierter zu wissen, wann Strings interniert sind und wann nicht, weil der Compiler über einige Informationen verfügt, wenn er Strings erkennt, die manchmal nicht interniert werden müssen ... Lesen Sie zum Beispiel diesen Artikel, der mehr Einblick in diese gibt Angelegenheit.

Bearbeiten: Nach einigem Ausgraben habe ich eine interessante Antwort auf die Frage gefunden. Wann ist es besser, String.Format gegen String-Verkettung zu verwenden? . Kurz gesagt, der Autor der Antwort mit +30 Stimmen spricht sich überzeugend für die Verkettung von Zeichenfolgen aus, wenn die Lokalisierung nicht beteiligt ist.

Ich bevorzuge den ersten Weg, weil ich so genau sehen kann, wie der String bei der Ausgabe aussehen wird. Es ist sehr leicht zu vergessen, ein Leerzeichen hinzuzufügen oder zusätzlichen Abstand hinzuzufügen, wenn nur Zeichenfolgen angehängt werden.

Ich bin mir sicher, dass der erste Weg auch einen Leistungsvorteil bietet, da keine zusätzlichen Zeichenfolgen erstellt werden müssen. aber das ist nicht mein Hauptanliegen.

Mit der ersten Option können Sie eine häufig verwendete Formatzeichenfolge speichern, die erforderliche Eingabe reduzieren und die Aktualisierung der Zeichenfolge überall dort vereinfachen, wo sie verwendet wird. Grundsätzlich ermöglicht die erste Option die einfache Implementierung von DRY. Es ist auch eine viel schönere Syntax, wenn mehrere Variablen in einer Zeichenfolge verwendet werden müssen, wie Sie bereits erwähnt haben.

Ich denke, string.Format()es ist einfacher zu sehen, was genau das Ergebnis sein wird (damit Sie keine Probleme mit vergessenen Leerzeichen oder Ähnlichem haben), und es ist auch einfacher zu tippen und zu ändern.

Wenn Sie eine sehr einfache Formatierung durchführen möchten, ist die Verwendung des +Plus-Operators möglicherweise einfacher, aber ich verwende ihn eher nur, wenn zwei Zeichenfolgen verkettet werden, nicht mehr.

Um zu zeigen, wie string.Format()sich das Ändern einfacher gestalten lässt, sollten Sie in Ihrem Beispiel am Ende des Satzes einen Punkt hinzufügen: Von string.Format("The int is {0}", i)zu gehen string.Format("The int is {0}.", i)ist nur ein Zeichen. Aber von "the int is " + izu gehen "the int is " + i + '.'ist viel mehr.

Ein weiterer Vorteil von string.Format()ist, dass Sie das zu verwendende Format wie z string.Format("The int is 0x{0:X}.", i). Dies ist umso wichtiger, wenn Sie das Datum formatieren.

Was die Effizienz betrifft, string.Format()ist es höchstwahrscheinlich langsamer als einfache Zeichenfolgenverkettungen. Aber Code wie dieser befindet sich höchstwahrscheinlich nicht auf einem heißen Pfad, daher spielt es keine Rolle. Und wenn ja, sind Sie wahrscheinlich besser dran StringBuilder.

Verwenden Sie den Code, der Ihren Code am besten lesbar macht. Mach dir keine Sorgen über die Leistung.

Für Ihr Beispiel unten bevorzuge ich B, weil es nur besser lesbar ist. Aber auch die obigen Sprachübersetzungen sind sinnvoll. Lassen Sie sich nicht von jemandem zwingen, string.Format zu verwenden. Lesen Sie stattdessen Jeff Atwoods hervorragenden Blog über das Theater The Sad Tragedy of Micro Optimizations und verweisen Sie darauf

EIN:

string output; 
int i = 10;
output = string.Format("the int is {0}", i);

gegen

B:

string output; 
int i = 10;
output = "the int is " + i;

Ref: String-Ausgabe: Format oder Concat in C #?

Betrachten Sie diesen Code.

Es ist eine leicht modifizierte Version Ihres Codes.

1. Ich habe Console.WriteLine entfernt, da es wahrscheinlich einige Größenordnungen langsamer ist als das, was ich zu messen versuche.
2. Ich starre die Stoppuhr vor der Schleife und stoppe sie direkt danach. Auf diese Weise verliere ich nicht die Präzision, wenn die Ausführung der Funktion beispielsweise 26,4 Ticks benötigt.
3. Die Art und Weise, wie Sie das Ergebnis durch die Anzahl der Iterationen geteilt haben, war falsch. Sehen Sie, was passiert, wenn Sie 1000 Millisekunden und 100 Millisekunden haben. In beiden Situationen erhalten Sie 0 ms, nachdem Sie es durch 1000000 geteilt haben.

Stopwatch s = new Stopwatch();

var p = new { FirstName = "Bill", LastName = "Gates" };

int n = 1000000;
long fElapsedMilliseconds = 0, fElapsedTicks = 0, cElapsedMilliseconds = 0, cElapsedTicks = 0;

string result;
s.Start();
for (var i = 0; i < n; i++)
    result = (p.FirstName + " " + p.LastName);
s.Stop();
cElapsedMilliseconds = s.ElapsedMilliseconds;
cElapsedTicks = s.ElapsedTicks;
s.Reset();
s.Start();
for (var i = 0; i < n; i++)
    result = string.Format("{0} {1}", p.FirstName, p.LastName);
s.Stop();
fElapsedMilliseconds = s.ElapsedMilliseconds;
fElapsedTicks = s.ElapsedTicks;
s.Reset();


Console.Clear();
Console.WriteLine(n.ToString()+" x result = string.Format(\"{0} {1}\", p.FirstName, p.LastName); took: " + (fElapsedMilliseconds) + "ms - " + (fElapsedTicks) + " ticks");
Console.WriteLine(n.ToString() + " x result = (p.FirstName + \" \" + p.LastName); took: " + (cElapsedMilliseconds) + "ms - " + (cElapsedTicks) + " ticks");
Thread.Sleep(4000);

Das sind meine Ergebnisse:

1000000 x result = string.Format("{0} {1}", p.FirstName, p.LastName); took: 618ms - 2213706 ticks
1000000 x result = (p.FirstName + " " + p.LastName); took: 166ms - 595610 ticks