Comment int + chaîne devient une chaîne?

Question

je suis tombé sur une étrange manière de mettre en œuvre ToString() et je me demande comment cela fonctionne:

public string tostr(int n) 
{ 
    string s = ""; 
    foreach (char c in n-- + "") { //<------HOW IS THIS POSSIBLE ? 
     s = s + c; 
    } 
    return s; 
} 

Est-ce le iterator en supposant que la taille d'un char?

Answer 1

Il appelle la méthode String.Concat(object, object) implicitement, ce qui concaténer les représentations de chaînes de deux objets spécifiés :

string result = String.Concat("", n--); 

La méthode String.Concat(object, object) appelle ensuite String.Concat(string, string). Pour lire la source Concat et vérifier en profondeur, d'abord allez ici: puis dans cette page dans la recherche TextBox tapez String puis cliquez sur le lien String.cs dans les résultats pour aller au code source String.cs dans C# .NET page et vérifiez la méthode Concat.

Telle est la définition de la méthode:

public static String Concat(Object arg0, Object arg1) 
{ 
    Contract.Ensures(Contract.Result<string>() != null); 
    Contract.EndContractBlock(); 

    if (arg0 == null) 
    { 
     arg0 = String.Empty; 
    } 

    if (arg1==null) 
    { 
     arg1 = String.Empty; 
    } 
    return Concat(arg0.ToString(), arg1.ToString()); 
} 

Comme vous le voyez ce appelle la méthode public static String Concat(String str0, String str1) enfin:

public static String Concat(String str0, String str1) 
{ 
    Contract.Ensures(Contract.Result<string>() != null); 
    Contract.Ensures(Contract.Result<string>().Length == 
     (str0 == null ? 0 : str0.Length) + 
     (str1 == null ? 0 : str1.Length)); 
    Contract.EndContractBlock(); 

    if (IsNullOrEmpty(str0)) { 
     if (IsNullOrEmpty(str1)) { 
      return String.Empty; 
     } 
     return str1; 
    } 

    if (IsNullOrEmpty(str1)) { 
     return str0; 
    } 

    int str0Length = str0.Length; 

    String result = FastAllocateString(str0Length + str1.Length); 

    FillStringChecked(result, 0,  str0); 
    FillStringChecked(result, str0Length, str1); 

    return result; 
} 

, ce qui est sous-jacent IL, par Ildasm:

.method public hidebysig instance string 
     tostr(int32 n) cil managed 
{ 
    // Code size  74 (0x4a) 
    .maxstack 3 
    .locals init ([0] string s, 
      [1] string V_1, 
      [2] int32 V_2, 
      [3] char c, 
      [4] string V_4) 
    IL_0000: nop 
    IL_0001: ldstr  "" 
    IL_0006: stloc.0 
    IL_0007: nop 
    IL_0008: ldarg.1 
    IL_0009: dup 
    IL_000a: ldc.i4.1 
    IL_000b: sub 
    IL_000c: starg.s n 
    IL_000e: box  [mscorlib]System.Int32 
    IL_0013: call  string [mscorlib]System.String::Concat(object) 
    IL_0018: stloc.1 
    IL_0019: ldc.i4.0 
    IL_001a: stloc.2 
    IL_001b: br.s  IL_0039 
    IL_001d: ldloc.1 
    IL_001e: ldloc.2 
    IL_001f: callvirt instance char [mscorlib]System.String::get_Chars(int32) 
    IL_0024: stloc.3 
    IL_0025: nop 
    IL_0026: ldloc.0 
    IL_0027: ldloca.s c 
    IL_0029: call  instance string [mscorlib]System.Char::ToString() 
    IL_002e: call  string [mscorlib]System.String::Concat(string, 
                   string) 
    IL_0033: stloc.0 
    IL_0034: nop 
    IL_0035: ldloc.2 
    IL_0036: ldc.i4.1 
    IL_0037: add 
    IL_0038: stloc.2 
    IL_0039: ldloc.2 
    IL_003a: ldloc.1 
    IL_003b: callvirt instance int32 [mscorlib]System.String::get_Length() 
    IL_0040: blt.s  IL_001d 
    IL_0042: ldloc.0 
    IL_0043: stloc.s V_4 
    IL_0045: br.s  IL_0047 
    IL_0047: ldloc.s V_4 
    IL_0049: ret 
}// end of method tostr 

Answer 2

Le type de n-- est int, qui est converti en string en utilisant + pour le concaténer avec "", qui est de type string. En outre, string implémente IEnumerable<char>, sur laquelle l'itération réelle avec foreach a lieu.

Answer 3

Expliquer cette « étape par étape »:

// assume the input is 1337 
public string tostr(int n) { 
    //line below is creating a placeholder for the result string 
    string s = ""; 
    // below line we can split into 2 lines to explain in more detail: 
    // foreach (char c in n-- + "") { 
    // then value of n is concatenated with an empty string : 
    // string numberString = n-- + ""; // numberString is "1337"; 
    // and after this line value of n will be 1336 
    // which then is iterated though : 
    // foreach(char c in numberString) { // meaning foreach(char c in "1337") 
    foreach (char c in n-- + "") { //<------HOW IS THIS POSSIBLE ? 
     s = s + c; // here each sign of the numberString is added into the placeholder 
    } 
    return s; // return filled placeholder 
} 

Donc, fondamentalement, si vous concaténer string avec int il sera automatiquement appeler la méthode int.ToString et se joindre à la chaîne ensemble.

Answer 4

Ce code semble incompréhensible parce que c'est le résultat de ce que je considère comme un choix de conception horrible dans la langue. L'opérateur + n'existe pas réellement dans string. Si vous regardez la source de référence, ou MSDN page, les seuls opérateurs déclarés pour string sont == et !=.

Ce qui se passe réellement, c'est que le compilateur tire l'un de ses tours de magie, et convertit l'opérateur + en un appel à la méthode statique string.Concat.

Maintenant, si vous est arrivé de rencontrer foreach (char c in string.Concat(n--, "")) vous auriez probablement comprendre le code beaucoup mieux, parce que l'intention est claire : Je veux concaténer deux objets sous forme de chaînes, puis énumérer les char s qui composent la chaîne résultante.

Quand vous lisez n-- + "" cette intention est loin d'être clair, et son pire si vous arrive d'avoir n-- + s (s étant un string).

Le compilateur dans les deux cas décide que vous souhaitez concaténer les arguments en tant que chaînes et mappe automatiquement cet appel à string.Concat(object, object). Un des locataires de C# est que, à moins que l'intention du codeur ne soit claire, agitez un drapeau rouge et demandez au codeur de clarifier son intention. Dans ce cas particulier, ce locataire est complètement violé.

À mon humble avis, tout ce qui n'est pas un string + string aurait dû être une erreur de compilation, mais ce train a été transmis il y a de nombreuses années.

Answer 5

J'ai utilisé ReSharper pour convertir la fonction en instructions Linq, ce qui peut aider certaines personnes à comprendre ce qui se passe (ou simplement confondre les gens).

public string tostrLinq(int n) 
{ 
    return string.Concat(n--, "").Aggregate("", (string current, char c) => current + c); 
} 

Comme d'autres ont déjà dit, au fond de la int est entrée concated avec un vide string qui vous donne essentiellement une représentation de chaîne de la int. Comme string implémente IEnumberable, la boucle foreach décompose la chaîne en char[], en donnant chaque caractère de la chaîne à chaque itération. Le corps de la boucle réunit ensuite les caractères ensemble en tant que chaîne en concaténant chaque char.

Ainsi, par exemple, entrée donné 5423, il est converti en "5423", puis divisé en "5", "4", "2", "3" et enfin piquées retour à "5423".

Maintenant la partie qui m'a vraiment fait mal pendant un moment était le n--. Si cela décrémente le int, alors pourquoi ne recevons-nous pas "5422" à la place? Cela me n'a pas été clair qu'après avoir lu les MSDN Article: Increment (++) and Decrement (--) Operators

L'incrément et les opérateurs décrémentation sont utilisés comme raccourci pour modifier la valeur stockée dans une variable et accéder à cette valeur. L'opérateur peut être utilisé dans une syntaxe de préfixe ou de suffixe.

If   | Equivalent Action | Return value 
===================================== 
++variable | variable += 1  | value of variable after incrementing 
variable++ | variable += 1  | value of variable before incrementing 
--variable | variable -= 1  | value of variable after decrementing 
variable-- | variable -= 1  | value of variable before decrementing 

donc parce que l'opérateur de décrémentation est appliqué à la fin de n, la valeur de n est lu et utilisé par string.Concat avant n est décrémenté par 1.

à savoir string.Concat(n--,"") va donner la même sortie que string.Contact(n, ""); n = n - 1;.

Donc, pour obtenir "5422" nous changerions à string.Concat(--n, "") de sorte que n est décrément première avant qu'il ne soit transmis à string.Contact.

TL; DR; La fonction est une manière détournée de faire n.ToString()

Fait intéressant, j'ai aussi utilisé ReSharper pour le convertir en une boucle for mais la fonction ne fonctionne plus comme n est décrémenté à chaque itération de la boucle, contrairement à la boucle foreach :

public string tostrFor(int n) 
{ 
    string s = ""; 
    for (int index = 0; index < string.Concat(n--, "").Length; index++) 
    { 
     char c = string.Concat(n--, "")[index]; 
     s = s + c; 
    } 
    return s; 
} 

Answer 6

Décomposer votre code pour montrer pourquoi il arrive ...

foreach(char c in n-- + "") 

utilisant le + opérateur avec une chaîne comme l'un des opérandes convertira le résultat en une chaîne indépendamment de ce que l'autre opérande primitif était, tant qu'il avait une implémentation de +. Ce faisant, n participe à la méthode string.Concat comme vous pouvez le voir sur la capture d'écran ci-dessous de la fenêtre de débogage ... Autos

J'ai appelé la méthode avec « 34 » comme vous pouvez déduire. L'identificateur de boucle est défini comme char c et passe par une chaîne. Cela fonctionne parce que string met en œuvre IEnumerable<char> comme vous pouvez le voir sur la capture d'écran du résultat de « Aller à la définition » du type de chaîne:

De ce point, il fonctionne comme si vous étiez itérez à travers toute autre liste/tableau ... ou plus précisément, IEnumerable avec foreach et obtient chaque individu char. n dans le même temps a été changé en n-- // 33 in my case. À ce stade, la valeur de n est sans conséquence puisque vous parcourez le résultat de l'expression n-- + "". Il aurait aussi bien pu être n++ et vous obtiendrez le même résultat.

La ligne s = s + c; devrait être assez explicite et juste au cas où il n'est pas, chaque carboniser vous tirez du résultat de chaîne temporaire de n-- + "" est ajouté à votre vide (au début) string s = "";. Il en résulte une chaîne car comme mentionné précédemment + avec une chaîne impliquée entraînera une chaîne. Une fois que vous avez fini de parcourir tous les caractères, il retourne la représentation sous forme de chaîne.

Answer 7

concaténation de chaîne:

… 
string operator +(object x, string y); 

Le + binaire opérateur effectue la concaténation de chaîne lorsqu'un ou les deux opérandes sont de type chaîne. Si un opérande de concaténation de chaîne est nul, une chaîne vide est substituée. Sinon, tout opérande non-chaîne est converti en sa représentation sous forme de chaîne en appelant la méthode virtuelle ToString héritée du type object. Si ToString renvoie null, une chaîne vide est substituée. - ECMA-334 page 201.

Ainsi, n.ToString() est appelé.Tout le reste de la méthode est juste en train de décomposer et de recomposer le résultat sans aucun effet.

Il aurait pu être écrit:

public string tostr(int n) => n.ToString(); 

Mais, pourquoi?

Answer 8

n-- + "" 

est le même que

n + "" 

parce que nous ne pas utiliser la valeur de n plus tard

n + "" 

est le même que

n.ToString() 

parce opérateur + Utilisé avec int et string convertit int en string, si

foreach (char c in n-- + "") 

est le même que

foreach (char c in n.ToString()) 

le reste est simple.

Answer 9

Puisque n-- est une post-décrémentation, la valeur de n n'est modifiée qu'après la concaténation. donc essentiellement, il ne fait rien du tout. il aurait pu tout simplement été

foreach (char c in n + "") 

ou

foreach (char c in (n++) + "") 

soit rien change rien. la valeur d'origine est itérée