La différence entre le + et & pour l'assemblage de chaînes dans VB.NET

Quelle est la différence entre + et & pour rejoindre les chaînes de VB.NET?

OriginalL'auteur Rob P. | 2009-04-09

  1. 82

    Il n'y a pas de différence si les deux opérandes sont des chaînes de caractères. Cependant, si un opérande est une chaîne de caractères, et l'un est un nombre, alors vous avez un problème, consultez le code ci-dessous.

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

    Donc je vous conseille de toujours utiliser & quand tu veux concaténer, parce que vous pourriez être essayer de concaténer un integer, float, décimal à une chaîne, ce qui provoquera une exception, ou, au mieux, de ne pas faire ce que vous voulez probablement faire.

    Ou toujours forcer l'Option Strict on, dans ce cas, vous n'aurez jamais à vous inquiéter à ce sujet. Option Strict on a de nombreux autres avantages: stackoverflow.com/questions/222370/...
    Il y a un problème avec & pour la concaténation de chaîne. À partir de la documentation Le & opérateur de toujours s'élargit ses opérandes à la Chaîne, quel que soit le réglage de l'Option Strict". Ainsi, par exemple "Hello " & 2.5 silencieusement convertir les 2,5 à une chaîne en utilisant les paramètres régionaux (vous pourriez obtenir "2.5" ou "2,5"). Bien si c'était ce que tu voulais. J'aimerais beaucoup, beaucoup plutôt être obligé de spécifier explicitement.
    Oh, oui, c'régional des choses peut vraiment vous si vous ne les regardez pas. Surtout sur des serveurs web. Si vous avez un tas de serveurs web, vous devez assurez-vous qu'ils sont tous configurés pour les mêmes paramètres régionaux, vous permet d'obtenir bizarre problèmes de mise en forme avec des nombres et des dates.
    Pour être complet, il convient également de noter, ce qui est retourné lorsque vous effectuez "abc" & 222 ("abc222").
    Permettez-moi de mentionner que 333 dans l'avant-dernière ligne est en fait de type System.Double.

    OriginalL'auteur Kibbee

  2. 13

    Le & opérateur fait toujours en sorte que les deux opérandes sont des chaînes de caractères, tandis que l'opérateur + trouve la surcharge qui correspond à la opérandes.

    L'expression 1 & 2 donne la valeur "12", alors que l'expression 1 + 2 donne la valeur 3.

    Si les deux opérandes sont des chaînes de caractères, il n'y a pas de différence dans le résultat.

    + opérateur réalise uniquement la conversion implicite si Option Strict est Off. Mais & opérateur effectuera la conversion implicite de la chaîne quel que soit le Option Strict réglage. Documentation Le & opérateur de toujours s'élargit ses opérandes à la Chaîne, quel que soit le réglage de l'Option Strict". Ainsi, par exemple "Hello " & 2.5 silencieusement convertir les 2,5 à une chaîne en utilisant les paramètres régionaux (vous pourriez obtenir "2.5" ou "2,5"). Bien si c'était ce que tu voulais.

    OriginalL'auteur Guffa

  3. 7

    Aucun.

    Comme vous pouvez le voir ci-dessous. Ces deux lignes de code compile exactement le même code IL:

    Module Module1

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

End Module

    Compile (note 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
    Grâce Aliostad, qui résume parfaitement. J'ai été très curieux (et devrait probablement avoir décrit un peu mieux dans ma question) de la façon dont il a été traité. Chaîne + chaîne (tant qu'ils sont à la fois des chaînes de caractères) est le même que String & String (sans tenir compte d'un ensemble complexe de règles avec l'opérateur+).
    Pas de probs. Il est toujours bon d'avoir un coup d'oeil à la IL code à l'aide de ILDASM. D'abord, il n'est pas familier, mais peu à peu vous vous habituez à elle.

    OriginalL'auteur Aliostad

  4. 3

    L'opérateur + peut être soit l'addition ou la concaténation. Le & est seulement la concaténation. Si les expressions sont à la fois des chaînes les résultats seraient les mêmes.

    - Je utiliser & lorsqu'on travaille avec des cordes, et + lorsque l'on travaille avec des nombres, donc il n'y a jamais de confusion à propos de mon intention. Si par erreur vous utilisez + et une expression est une chaîne de caractères et on est un certain nombre, vous courez le risque de non-obtention des résultats désirés.

    OriginalL'auteur dbasnett

  5. 2

    Il n'y a pas de différence dans la plupart des cas. Cependant, la meilleure pratique est:

    "+" doit être réservé aux entier ajouts, parce que si vous n'utilisez pas Option Strict on alors vous avez vraiment foiré des situations telles que:

    Input + 12 pourrait vous donner 20 au lieu de 812. Cela peut être particulièrement mauvais dans un ASP.NET application où l'entrée vient de POST/GET.

    Il suffit de mettre: Pour rejoindre les cordes, toujours utiliser "&" au lieu de "+".

    Évidemment, l'utilisation StringBuilder où il convient 🙂

    OriginalL'auteur dr. evil

  6. 1

    Si les deux types sont statiquement typés pour Système.Chaîne, il n'y a aucune différence entre le code. Les deux seront à résoudre jusqu'à la Chaîne de caractères.Concat membre (c'est ce que + ne pour les chaînes).

    Cependant, si les objets ne sont pas fortement typé à la chaîne, Visual Basic liaison tardive donnera un coup de pied dans et aller deux très différents itinéraires. Le + version va tenter de faire un ajouter opération qui, littéralement, essaie d'ajouter les objets. Cela va faire toutes sortes de tentatives de convertir les valeurs d'un certain nombre, puis les ajouter.

    La & opérateur va tenter de les concaténer. Le runtime de Visual Basic va passer par toutes sortes de conversions de convertir les valeurs de chaînes de caractères. Il sera alors String.Concat les résultats.

    Noter également que la & opérateur ignore Option Strict. À partir de la documentation Le & opérateur de toujours s'élargit ses opérandes à la Chaîne, quel que soit le réglage de l'Option Strict". Ainsi, par exemple "Hello " & 2.5 silencieusement convertir les 2,5 à une chaîne en utilisant les paramètres régionaux (vous pourriez obtenir "2.5" ou "2,5"). Bien si c'était ce que tu voulais. Le contraste avec + qui est stricte quand Option Strict On

    OriginalL'auteur JaredPar

  7. 1

    Directement à partir de la Documentation MSDN: Les Opérateurs de concaténation dans Visual Basic

    Différences Entre les Deux Opérateurs de Concaténation

    L'Opérateur + (Visual Basic) a pour but principal de l'ajout de deux
    les numéros. Cependant, il peut également concaténer numérique opérandes avec de la ficelle
    opérandes. L'opérateur + est un ensemble complexe de règles qui déterminent l'
    la possibilité d'ajouter, de concaténer, un signal d'erreur du compilateur, ou de jeter un
    au moment de l'exécution InvalidCastException exception.

    Le & Opérateur (Visual Basic) est définie uniquement pour la Chaîne opérandes, et
    toujours, il élargit ses opérandes à la Chaîne, quel que soit le réglage de
    Option Strict. Le & opérateur est recommandé pour la concaténation de chaîne
    parce qu'il est défini exclusivement pour les chaînes et réduit vos chances
    de générer involontaire de conversion.

    Faire confiance MSDN! 🙂

    OriginalL'auteur FranciscoBouza

  8. 0

    Aucune lors de l'assemblage des chaînes:

        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

    OriginalL'auteur Gavin Miller