Pourquoi est La Variable d'Itération dans une instruction foreach de C# en lecture seule?

Permet de commencer avec un idiot, mais un exemple illustratif:

Object o = 15;
o = "apples";

À aucun moment, ne nous avons l'impression que l'on vient d'avoir le numéro 15 dans une chaîne de pommes. Nous savons que o est simplement un pointeur. Maintenant permet de faire cela dans itérateur forme.

int[] nums = { 15, 16, 17 };

foreach (Object o in nums) {
     o = "apples";
}

À nouveau, cela ne sert à rien. Ou au moins, il serait accomplir de rien n'était pour compiler. Il n'aurions certainement pas insérer notre chaîne dans le tableau int -- ce n'est pas permis, et nous savons que o est juste un pointeur de toute façon.

Prenons votre exemple:

foreach (Position Location in Map)
{
     //We want to fudge the position to hide the exact coordinates
     Location = Location + Random();     //Compiler Error

     Plot(Location);
}

Étaient présent à la compilation, le Location dans votre exemple etoiles se référant à une valeur de Map, mais ensuite vous changer pour faire référence à un nouveau Position (implicitement créé par l'opérateur d'addition). Fonctionnellement, c'est l'équivalent de ce qui NE la compilation):

foreach (Position Location in Map)
{
     //We want to fudge the position to hide the exact coordinates
     Position Location2 = Location + Random();     //No more Error

     Plot(Location2);
}

Alors, pourquoi est-ce que Microsoft vous interdire de re-affectation de le pointeur utilisé pour l'itération? De la clarté, pour une chose, vous ne voulez pas que les gens de l'affectation à ce qu'elle pense qu'ils ont changé de position à l'intérieur de la boucle. Facilité de mise en œuvre pour l'autre: La variable peut cacher des logiques internes indiquant l'état de la boucle en cours.

Mais plus important encore, il n'y a aucune raison pour que vous voulez lui attribuer. Il représente l'élément courant de la boucle de la séquence. Affectation d'une valeur à elle rompt le "Principe de Responsabilité Unique" ou Frisé du Droit si vous suivez le Codage d'Horreur. Une variable devrait signifier qu'une seule chose.

Je pense que sa limitation artificielle, pas vraiment besoin de le faire. Pour prouver un point, prenons ce code en considiration, et d'une possible solution à votre problème. Le problème, c'est assigner, mais les changements internes d'objets ne présentent pas un problème:

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {

            List<MyObject> colection =new List<MyObject>{ new MyObject{ id=1, Name="obj1" }, 
                                                    new MyObject{ id=2, Name="obj2"} };

            foreach (MyObject b in colection)
            {
             //b += 3;     //Doesn't work
                b.Add(3);   //Works
            }
        }

        class MyObject
        {
            public static MyObject operator +(MyObject b1, int b2)
            {
                return new MyObject { id = b1.id + b2, Name = b1.Name };
            }

          public void Add(int b2)
          {
              this.id += b2;
          }
            public string Name;
            public int id;
        }
    }
}

Je ne savais pas à propos de ce phénomène, car j'ai toujours été de modifier les objets de la façon dont je l'ai décrit.

L'instruction foreach fonctionne avec Énumérable. La chose qui est différent, avec une Énumération, c'est qu'il ne sait pas à propos de l'ensemble de cette collection, il est presque aveugle.

Cela signifie qu'il ne sait pas ce que seront les prochaines, ou si en fait il n'y a rien jusqu'à la prochaine itération du cycle. C'est pourquoi vous voyez là .ToList() beaucoup de sorte que les gens peuvent prendre un nombre de Énumérable.

Pour une raison que je ne suis pas sûr à ce sujet, cela signifie que vous devez vous assurer que votre collection n'est pas le changement que vous essayez de les déplacer le long de l'agent recenseur.