Devo usare .ToString () quando concatenando variabili stringa e intero in C #?

ToString di utilizzo

No, non dovresti usare ToString qui.

La concatenazione di stringhe trasforma automaticamente non stringhe in stringhe, il che significa che le tue due varianti sono quasi identiche:

When one or both operands are of type string, the predefined addition operators concatenate the string representation of the operands.

^{Fonte: Specifica lingua C #: operatore addizione, MSDN .}

D'altra parte, il primo (senza ToString ):

• È più breve da scrivere,
• È più breve da leggere,
• È più facile da mantenere e:
• mostra esattamente l'intenzione dell'autore: concatenare stringhe.

Quindi preferisci il primo.

Sotto il cofano

Ciò che è anche interessante è vedere cosa succede sotto il cofano. Uno dei modi per vederlo è guardare il codice IL all'interno di LINQPad. Questo programma:

void Main()
{
    var a = 3;
    var b = " Hello";
    var c = a + b;
    Console.WriteLine(c);
}

è tradotto nel seguente IL:

IL_0001:  ldc.i4.3    
IL_0002:  stloc.0     // a
IL_0003:  ldstr       " Hello"
IL_0008:  stloc.1     // b
IL_0009:  ldloc.0     // a
IL_000A:  box         System.Int32
IL_000F:  ldloc.1     // b
IL_0010:  call        System.String.Concat
IL_0015:  stloc.2     // c
IL_0016:  ldloc.2     // c
IL_0017:  call        System.Console.WriteLine

Vedi che System.String.Concat ? Ciò significa che il codice originale può essere scritto anche in questo modo, che si traduce esattamente nello stesso IL:

void Main()
{
    var a = 3;
    var b = " Hello";
    var c = string.Concat(a, b); // This is the line which was changed.
    Console.WriteLine(c);
}

Quando leggi la documentazione di string.Concat(object[]) , potresti imparare che:

The method concatenates each object in args by calling the parameterless ToString method of that object; it does not add any delimiters.

Ciò significa che ToString è ridondante. Inoltre:

String.Empty is used in place of any null object in the array.

Che gestisce bene il caso in cui alcuni degli operandi sono nulli (vedere la nota 1).

Mentre nell'ultimo esempio, la concatenazione è stata tradotta in string.Concat , si dovrebbe anche evidenziare le ottimizzazioni del compilatore:

var a = "Hello " + "World";

è tradotto in:

ldstr       "Hello World"
stloc.0

D'altra parte:

var a = string.Concat("Hello ", "World");

è tradotto in:

ldstr       "Hello "
ldstr       "World"
call        System.String.Concat
stloc.0

Altre alternative

Esistono naturalmente altri modi per concatenare le rappresentazioni di stringa degli oggetti in C #.

1. StringBuilder viene utilizzato quando è necessario eseguire molte operazioni di concatenazione e aiuta a ridurre il numero di stringhe intermedie create. Decidere se utilizzare un StringBuilder o una concatenazione ordinaria potrebbe non essere facile. Utilizza un profiler o cerca risposte pertinenti su Stack Overflow.

   L'uso di StringBuilder ha un grosso svantaggio nel rendere il codice difficile da leggere e conservare. Per casi semplici come quello nella tua domanda, StringBuilder non è solo dannoso per la leggibilità del codice, ma è anche inutile in termini di prestazioni.

2. string.Join dovrebbe essere usato quando devi aggiungere delimitatori.

   Ovviamente, non utilizzare mai string.Join con un delimitatore vuoto per concatenare le stringhe.

3. string.Format può essere usato quando la stringa di template è preferita alla concatenazione di stringhe. Uno dei casi in cui si preferisce è quando il messaggio può essere localizzato, come suggerito nella risposta di kunthet.

   L'uso di string.Format ha diversi inconvenienti che lo rendono inadatto per casi semplici come il tuo:

   • Con semplici segnaposti "{0}", spesso non è chiaro quale parametro vada dove. È frequente invertire erroneamente i parametri o dimenticarne uno. Fortunatamente, C # 6 finalmente introduce interpolazione delle stringhe che risolve questo problema.

   • Le prestazioni del runtime potrebbero peggiorare. Ovviamente, non dare per scontato che string.Format sia sempre più lento. Se le prestazioni sono importanti, misura due approcci e determina quale è più veloce in base ai risultati effettivi anziché alle ipotesi.

   • Il codice è leggermente più lungo da scrivere, più lungo da leggere e più difficile da mantenere, sebbene questo sia estremamente secondario e non dovrebbe infastidire troppo.

^{¹ La differenza appare quando uno degli oggetti è null . Senza ToString , a null viene sostituita da una stringa vuota. Con ToString , viene lanciata una NullReferenceException .}

Invece, dovresti usare il formattatore di stringhe. È più semplice formattare il tuo numero in una rappresentazione o localizzazione di stringhe. per esempio:.

string expression = string.Format("Expression: {0} + {1} = {2}", a, b, sum);

Maggiori informazioni su MSDN .

Tuttavia, il formattatore di stringhe è meno leggibile (e forse anche le prestazioni) della concatenazione di stringhe.

Se si utilizza la concatenazione + , essa stessa utilizza il metodo String.Concat . La stringa stessa non espone un operatore +.

ad esempio:

int i = 10;
string str = "hello" + i;

è compilato in:

int i = 10;
object o1 = "hello";
object o2 = i; // Note boxing
string str = string.Concat(o1, o2);

Se chiami direttamente ToString , eviterà la boxe e chiamerà il sovraccarico Concat(string, string) . Quindi la chiamata di ToString sarà leggermente più efficiente anche se non abbastanza significativa. Faresti meglio a seguire l'esempio che ritieni più leggibile.