string.format con variabili vs variabili incorporate

Quali sono i pro / contro (se presenti) da utilizzare

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

contro

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

Ho sempre usato l'ultimo esempio, ma sembra che una buona maggioranza dei tutorial online usi l'esempio string.format. Non penso che ci siano differenze reali in termini di efficienza, il mio pensiero iniziale è quindi che un programmatore non debba continuare a spezzare la stringa per inserire variabili.

Se ritieni che la traduzione sia importante nel tuo progetto, la prima sintassi ti aiuterà davvero.

Ad esempio potresti avere:

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

Nota anche che le tue variabili potrebbero non essere sempre nello stesso posto nella frase con quella sintassi:

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

Scopri la prima risposta per /programming/4671610/why-use-string-format . Copre tutto secondo me sul perché sia ​​meglio.

Inoltre, ogni assembly .NET ha un pool interno, contenente una raccolta di stringhe univoche. Quando viene compilato il codice, tutti i valori letterali delle stringhe a cui si fa riferimento nel codice vengono aggiunti a questo pool. Se hai un codice simile al seguente:

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

Questo lo rende 2 stringhe nel pool.

Se hai:

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

Hai solo una stringa nel pool.

È un po 'più complicato sapere quando le stringhe sono internate e quando non lo sono perché il compilatore ha un po' di intelligenza quando rileva stringhe che potrebbero non dover essere internate a volte ... Dai un'occhiata ad esempio a questo articolo che fornisce maggiori informazioni su questo importa.

Modifica: dopo aver scavato un po ', ho trovato una risposta interessante alla domanda Quando è meglio usare la concatenazione String.Format vs string? . In breve, l'autore della risposta con +30 voti fa un argomento convincente a favore della concatenazione di stringhe quando la localizzazione non è coinvolta.

Preferisco il primo modo perché mi permette di vedere esattamente come apparirà la stringa durante l'output. È molto facile dimenticare di aggiungere uno spazio o aggiungere una spaziatura aggiuntiva quando si aggiungono solo stringhe.

Sono sicuro che ci sia anche un vantaggio in termini di prestazioni nel primo modo dovuto al fatto di non dover creare le stringhe extra; ma questa non è la mia preoccupazione principale.

Utilizzando la prima opzione è possibile memorizzare una stringa di formato comunemente usata e ridurre la digitazione necessaria e facilitare l'aggiornamento della stringa ovunque venga utilizzata. Fondamentalmente la prima opzione consente di implementare facilmente DRY. È anche una sintassi molto più bella se è necessario utilizzare più variabili in una stringa, come hai menzionato.

Penso che string.Format()sia più facile vedere quale sarà esattamente il risultato (quindi non hai problemi con spazi dimenticati o qualcosa del genere), ed è anche più facile da digitare e modificare.

Se si desidera eseguire una formattazione molto semplice, l'utilizzo +dell'operatore più potrebbe essere più semplice, ma tendo a utilizzarlo solo quando si concatenano due stringhe, non di più.

Per mostrare come string.Format()è più facile modificarlo, considera che vuoi aggiungere un punto alla fine della frase nel tuo esempio: passare da string.Format("The int is {0}", i)a string.Format("The int is {0}.", i)è solo un carattere. Ma andare da "the int is " + ia "the int is " + i + '.'è molto di più.

Un altro vantaggio string.Format()è che consente di specificare facilmente il formato da utilizzare, ad esempio string.Format("The int is 0x{0:X}.", i). Questo è ancora più importante durante la formattazione della data.

Per quanto riguarda l'efficienza, string.Format()molto probabilmente è più lento di semplici concatenazioni di stringhe. Ma codice come questo probabilmente non è su un percorso caldo, quindi non importa. E se lo fa, probabilmente stai meglio con l'uso StringBuilder.

Usa quello che rende il tuo codice più leggibile. Non preoccuparti delle prestazioni.

Per il tuo esempio di seguito preferisco B perché è solo più leggibile. Ma anche le traduzioni linguistiche sopra riportate hanno senso. Non lasciare che nessuno ti costringa a usare string.Format, invece leggi e indica l'eccellente blog di Jeff Atwoods su The Sad Tragedy of Micro Optimizations Theater

UN:

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

contro

B:

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

Rif: Output stringa: formato o concat in C #?

Considera questo codice.

È una versione leggermente modificata del tuo codice.

1. Ho rimosso Console.WriteLine in quanto probabilmente alcuni ordini di grandezza sono più lenti di quello che sto cercando di misurare.
2. Sto fissando il cronometro prima del ciclo e lo interrompo subito dopo, in questo modo non sto perdendo precisione se la funzione impiega ad esempio 26,4 tick per eseguire.
3. Il modo in cui hai diviso il risultato per numero di iterazioni era sbagliato. Guarda cosa succede se hai 1000 millisecondi e 100 millisecondi. In entrambe le situazioni otterrai 0 ms dopo averlo diviso per 1000000.

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

Questi sono i miei risultati:

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