2009-04-09 11 views

risposta

67

Non c'è alcuna differenza se entrambi gli operandi sono stringhe. Tuttavia, se un operando è una stringa e uno è un numero, si incontrano problemi, vedere il codice seguente.

"abc" + "def" = "abcdef" 
"abc" & "def" = "abcdef" 
"111" + "222" = "111222" 
"111" & "222" = "111222" 
"111" & 222 = "111222" 
"111" + 222 = 333 
"abc" + 222 = conversion error 

Pertanto vi consiglio di usare sempre & quando si intende per concatenare, perché si potrebbe tentare di concatenare un integer, float, decimale in una stringa, che causerà un'eccezione, o nella migliore delle ipotesi, non fare ciò che probabilmente lo vuoi fare.

+11

O applica sempre Option Strict On, nel qual caso non dovrai mai preoccuparti di ciò. Option Strict On ha anche numerosi altri vantaggi: http://stackoverflow.com/questions/222370/option-strict-on-and-net-for-vb6-programmers – mattmc3

+3

C'è un problema con '&' per la concatenazione di stringhe. Dalla [documentazione] (http://msdn.microsoft.com/en-us/library/te2585xw.aspx) "L'operatore & estende sempre i suoi operandi a String, indipendentemente dall'impostazione di Option Strict". Ad esempio, "Hello" & 2.5' convertirà silenziosamente il 2.5 in una stringa usando le impostazioni regionali (potresti avere "" 2.5 "' o '" 2,5 "'). Bene, se era quello che volevi. Vorrei molto, molto piuttosto essere costretto a specificare esplicitamente. – MarkJ

+0

@MarkJ Oh sì, quella roba regionale può davvero farti se non la guardi. Soprattutto sui server web. Se si dispone di un gruppo di server Web, è necessario assicurarsi che siano tutti configurati con le stesse impostazioni internazionali, consentendo di ottenere problemi di formattazione con numeri e date. – Kibbee

0

Nessuno quando si entra in stringhe:

Dim string1 As String = "A" + "B" 
    Dim string2 As String = "A" & "B" 

    If string1.Equals(string2) And string2.Equals(string1) Then 
     Debugger.Break() 
    End If 
12

L'operatore & fa sempre in modo che entrambi gli operandi sono stringhe, mentre l'operatore + trova il sovraccarico che corrisponde gli operandi.

L'espressione 1 & 2 dà il valore "12", mentre l'espressione 1 + 2 fornisce il valore 3.

Se entrambi gli operandi sono stringhe, non v'è alcuna differenza nel risultato.

+0

+ l'operatore esegue solo la conversione implicita se 'Opzione Strict' è' Off'. Ma l'operatore eseguirà la conversione implicita alla stringa indipendentemente dall'impostazione 'Option Strict'. [Documentazione] (http://msdn.microsoft.com/en-us/library/te2585xw.aspx) "L'operatore & estende sempre i suoi operandi a String, indipendentemente dall'impostazione di Option Strict". Ad esempio, "Hello" & 2.5' convertirà silenziosamente il 2.5 in una stringa usando le impostazioni regionali (potresti avere "" 2.5 "' o '" 2,5 "'). Bene, se era quello che volevi. – MarkJ

2

Non c'è differenza nella maggior parte dei casi. Tuttavia, la pratica migliore è:

"+" dovrebbe essere riservato a aggiunte interi, perché se non si utilizza Option Strict On situazioni allora si potrebbe avere davvero incasinato come ad esempio:

Input + 12 potrebbe darti 20 invece di 812. Questo può essere particolarmente negativo in un'applicazione ASP.NET in cui l'input proviene da POST/GET.

In poche parole: Per unire le stringhe, utilizzare sempre "&" anziché "+".

Ovviamente, utilizzare StringBuilder dove è adatto :)

3

L'operatore + può essere un'aggiunta o una concatenazione. Lo & è solo una concatenazione. Se le espressioni sono entrambe stringhe, i risultati sarebbero gli stessi.

Io uso & quando lavoro con le stringhe e + quando lavoro con i numeri, quindi non c'è mai confusione sul mio intento. Se usi erroneamente + e un'espressione è una stringa e una è un numero, corri il rischio di risultati non desiderati.

1

Se entrambi i tipi sono tipizzati staticamente su System.String, la differenza tra il codice è zero. Entrambi verranno risolti fino al membro String.Concat (questo è ciò che fa + per le stringhe).

Tuttavia, se gli oggetti non vengono digitati con forza nella stringa, l'associazione tardiva di Visual Basic eseguirà due percorsi molto diversi. La versione + tenterà di eseguire un'operazione aggiungendo che tenta letteralmente di aggiungere gli oggetti. Questo farà tutti i tipi di tentativi per convertire entrambi i valori in un numero e quindi aggiungerli.

L'operatore & tenterà di concatenare. Il runtime di Visual Basic passerà attraverso tutti i tipi di conversioni per convertire entrambi i valori in stringhe. Sarà quindi String.Concat i risultati.

+0

Vale anche la pena ricordare che l'operatore "&" ** ignora Option Strict **. Dalla [documentazione] (http://msdn.microsoft.com/en-us/library/te2585xw.aspx) "L'operatore & estende sempre i suoi operandi a String, indipendentemente dall'impostazione di Option Strict". Ad esempio, "Hello" & 2.5' convertirà silenziosamente il 2.5 in una stringa usando le impostazioni regionali (potresti avere "" 2.5 "' o '" 2,5 "'). Bene, se era quello che volevi. Contrasto con '+' che è severo quando 'Option Strict On' – MarkJ

7

Nessuno.

Come potete vedere qui sotto. Queste due linee di codice compila esattamente allo stesso codice IL:

Module Module1 

Sub Main() 
    Dim s1 As String = "s1" 
    Dim s2 As String = "s2" 
    s2 += s1 
    s1 &= s2 
End Sub 

End Module 

compila a (nota System.String::Concat):

.method public static void Main() cil managed 
{ 
.entrypoint 
.custom instance void [mscorlib]System.STAThreadAttribute::.ctor() = (01 00 00 00) 
// Code size  31 (0x1f) 
.maxstack 2 
.locals init ([0] string s1, 
     [1] string s2) 
IL_0000: nop 
IL_0001: ldstr  "s1" 
IL_0006: stloc.0 
IL_0007: ldstr  "s2" 
IL_000c: stloc.1 
IL_000d: ldloc.1 
IL_000e: ldloc.0 
IL_000f: call  string [mscorlib]System.String::Concat(string, 
                  string) 
IL_0014: stloc.1 
IL_0015: ldloc.0 
IL_0016: ldloc.1 
IL_0017: call  string [mscorlib]System.String::Concat(string, 
                  string) 
IL_001c: stloc.0 
IL_001d: nop 
IL_001e: ret 
} // end of method Module1::Main 
+0

Grazie Aliostad, che lo riassume perfettamente. Ero molto curioso (e probabilmente avrei dovuto definirlo un po 'meglio nella mia domanda) su come è stato gestito. String + String (purché siano entrambe stringhe) è uguale a String & String (indipendentemente da un insieme complesso di regole con l'operatore +). – rickp

+0

Nessun problema. È sempre bene dare un'occhiata al codice IL usando ILDASM. Inizialmente non è familiare ma gradualmente ci si abitua. – Aliostad

1

Direttamente da MSDN documentazione: Concatenation Operators in Visual Basic

differenze tra i due Operatori di concatenazione

L'operatore + (Visual Basic) ha il pri scopo di aggiungere due numeri . Tuttavia, può anche concatenare operandi numerici con gli operandi stringa . L'operatore + ha un insieme complesso di regole che determinano se aggiungere, concatenare, segnalare un errore del compilatore o lanciare un'eccezione InvalidCastException in fase di esecuzione .

Il & Operator (Visual Basic) è definita solo per operandi stringa, e si allarga sempre i suoi operandi stringa, indipendentemente dall'impostazione di Option Strict. L'operatore & è consigliato per la concatenazione di stringhe perché è definito esclusivamente per le stringhe e riduce le probabilità di generare una conversione non intenzionale.

Fidarsi di MSDN! :-)

Problemi correlati