string.format con variabili vs variabili in linea

Se consideri importante la traduzione 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 nella stessa posizione nella frase con quella sintassi:

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

Dai un'occhiata alla prima risposta per link . Copre tutto a mio avviso sul motivo per cui è meglio.

Inoltre, ogni assembly .NET ha un pool interno, contenente una raccolta di stringhe univoche. Quando il tuo codice è compilato, tutte le stringhe letterali di riferimento nel tuo codice vengono aggiunte a questo pool. Se hai un codice simile a questo:

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

Questo rende 2 stringhe nel pool.

Se hai:

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

Hai una sola 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 aver bisogno di essere internate qualche volta ... Controlla ad esempio questo articolo che offre maggiori informazioni in merito.

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

Preferisco la prima, perché mi permette di vedere con precisione come sarà la stringa in uscita. È molto facile dimenticare di aggiungere uno spazio o aggiungere spazi supplementari quando si aggiungono stringhe.

Sono sicuro che c'è anche un vantaggio in termini di prestazioni per il primo modo dovuto al fatto di non dover creare le stringhe extra; ma non è la mia preoccupazione principale.

Usando la prima opzione è possibile memorizzare una stringa di formato comunemente usata e ridurre la digitazione necessaria e rendere più semplice l'aggiornamento della stringa ovunque sia utilizzata. Fondamentalmente la prima opzione consente a DRY di essere implementato facilmente. È anche una sintassi molto più gradevole se è necessario utilizzare più variabili in una stringa, come citato.

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

Se vuoi fare una formattazione molto semplice, usare l'operatore + plus potrebbe essere più semplice, ma io tendo ad usarlo solo quando concatenando due stringhe, non di più.

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

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

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

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

Per il tuo esempio qui sotto, preferisco B perché è solo più leggibile. Ma anche le traduzioni linguistiche di cui sopra hanno senso. Non permettere a nessuno di forzarti a usare string.Format, invece leggi e indica il blog di Jeff Atwoods sul Tragedia Tristezza del Micro Optimization Theater

A:

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

vs

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 perché probabilmente ha un ordine di grandezza inferiore a quello che sto cercando di misurare.
2. Sto fissando il cronometro prima del ciclo e fermandolo subito dopo, in questo modo non sto perdendo precisione se la funzione richiede ad esempio 26.4 tick da 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