Per un semplice caso in cui si tratta di una semplice concatenazione singola, sento che non vale la complessità di string.Format(e non l'ho testato, ma sospetto che per un caso semplice come questo, string.Format potrebbe essere leggermente più lento, con l'analisi della stringa di formato e tutto). Come Jon Skeet, preferisco non chiamare esplicitamente .ToString(), poiché verrà fatto implicitamente dastring.Concat(string, object) sovraccarico e penso che il codice sia più pulito e più facile da leggere senza di esso.
Ma per più di poche concatenazioni (quante sono soggettive), preferisco decisamente string.Format. Ad un certo punto penso che sia la leggibilità che le prestazioni soffrano inutilmente della concatenazione.
Se ci sono molti parametri nella stringa di formato (di nuovo, "molti" è soggettivo), di solito preferisco includere indici commentati sugli argomenti di sostituzione, per non perdere traccia di quale valore va a quale parametro. Un esempio artificioso:
Console.WriteLine(
"Dear {0} {1},\n\n" +
"Our records indicate that your {2}, \"{3}\", is due for {4} {5} shots.\n" +
"Please call our office at 1-900-382-5633 to make an appointment.\n\n" +
"Thank you,\n" +
"Eastern Veterinary",
/*0*/client.Title,
/*1*/client.LastName,
/*2*/client.Pet.Animal,
/*3*/client.Pet.Name,
/*4*/client.Pet.Gender == Gender.Male ? "his" : "her",
/*5*/client.Pet.Schedule[0]
);
Aggiornare
Mi viene in mente che l'esempio che ho fornito è un po 'confuso, perché sembra che abbia usato sia la concatenazione che string.Formatqui. E sì, logicamente e lessicalmente, è quello che ho fatto. Ma le concatenazioni saranno tutte ottimizzate dal compilatore 1 , poiché sono tutte stringhe letterali. Quindi in fase di esecuzione, ci sarà una singola stringa. Quindi credo di dover dire che preferisco evitare molte concatenazioni in fase di esecuzione .
Ovviamente, la maggior parte di questo argomento è obsoleta ora, a meno che non si sia ancora bloccati a utilizzare C # 5 o versioni precedenti. Ora abbiamo stringhe interpolate , che per leggibilità sono di gran lunga superiori string.Format, in quasi tutti i casi. In questi giorni, a meno che non sto solo concatenando un valore direttamente all'inizio o alla fine di una stringa letterale, utilizzo quasi sempre l'interpolazione di stringhe. Oggi scriverei il mio esempio precedente in questo modo:
Console.WriteLine(
$"Dear {client.Title} {client.LastName},\n\n" +
$"Our records indicate that your {client.Pet.Animal}, \"{client.Pet.Name}\", " +
$"is due for {(client.Pet.Gender == Gender.Male ? "his" : "her")} " +
$"{client.Pet.Schedule[0]} shots.\n" +
"Please call our office at 1-900-382-5633 to make an appointment.\n\n" +
"Thank you,\n" +
"Eastern Veterinary"
);
In questo modo si perde la concatenazione in fase di compilazione. Ogni stringa interpolata viene trasformata in una chiamata a string.Formatdal compilatore ei risultati vengono concatenati in fase di esecuzione. Ciò significa che questo è un sacrificio delle prestazioni in fase di esecuzione per la leggibilità. Il più delle volte, è un sacrificio utile, perché la penalità del tempo di esecuzione è trascurabile. Nel codice critico per le prestazioni, tuttavia, potrebbe essere necessario profilare soluzioni diverse.
1
Puoi vederlo nella specifica C # :
... i seguenti costrutti sono consentiti nelle espressioni costanti:
...
- L'operatore binario predefinito + ...
Puoi anche verificarlo con un piccolo codice:
const string s =
"This compiles successfully, " +
"and you can see that it will " +
"all be one string (named `s`) " +
"at run time";