Почему переменная итерации в операторе C# foreach доступна только для чтения?

Давайте начнем с глупого, но показательного примера:

Object o = 15;
o = "apples";

Ни в коем случае у нас не создается впечатление, что мы только что превратили число 15 в цепочку яблок. Мы знаем, что o — это просто указатель. Теперь давайте сделаем это в форме итератора.

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

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

Опять же, это действительно ничего не дает. Или, по крайней мере, он ничего не выполнил бы при компиляции. Он определенно не вставит нашу строку в массив int — это не разрешено, и мы знаем, что o в любом случае — это просто указатель.

Возьмем ваш пример:

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

     Plot(Location);
}

При компиляции Location в вашем примере указывает на значение в Map, но затем вы меняете его, чтобы ссылаться на новый Position (неявно созданный оператором сложения). Функционально это эквивалентно этому (который компилируется):

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);
}

Итак, почему Microsoft запрещает вам повторно назначать указатель, используемый для итерации? Во-первых, ясность — вы не хотите, чтобы люди, назначающие это, думали, что они изменили вашу позицию в цикле. Простота реализации для другого: переменная может скрывать некоторую внутреннюю логику, указывающую на состояние выполняемого цикла.

Но что еще более важно, у вас нет причин хотеть назначать его. Он представляет текущий элемент циклической последовательности. Присвоение ему значения нарушает «принцип единственной ответственности» или закон Керли, если вы Следите за Кодированием ужасов. Переменная должна означать только одно.

Если бы переменная была изменяемой, это могло бы создать неверное впечатление. Например:

string[] names = { "Jon", "Holly", "Tom", "Robin", "William" };

foreach (string name in names)
{
    name = name + " Skeet";
}

Некоторые люди могут подумать, что это изменит содержимое массива. Немного доходит, но это может быть причиной. Я посмотрю это в моей аннотированной спецификации сегодня вечером ...

Я думаю, что это искусственное ограничение, в этом нет необходимости. Чтобы доказать это, примите во внимание этот код и возможное решение вашей проблемы. Проблема в том, чтобы присвоить, но внутренние изменения объектов не представляют проблемы:

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;
        }
    }
}

Я не знал об этом феномене, потому что всегда модифицировал объекты так, как я описал.

Когда вы изменяете коллекцию, это изменение может иметь непредсказуемые побочные эффекты. Перечислитель не знает, как правильно справляться с этими побочными эффектами, поэтому он сделал коллекции неизменяемыми.

См. также этот вопрос: Как лучше всего изменить список в foreach

Оператор foreach работает с Enumerable. Отличие Enumerable в том, что он не знает о коллекции в целом, он почти слеп.

Это означает, что он не знает, что будет дальше, и вообще есть ли что-нибудь до следующего цикла итерации. Вот почему вы часто видите .ToList(), чтобы люди могли получить количество Enumerable.

По какой-то причине, в которой я не уверен, это означает, что вам нужно убедиться, что ваша коллекция не меняется, когда вы пытаетесь переместить перечислитель.

Условием работы с объектами IEnumerable является то, что базовая коллекция не должна изменяться, пока вы обращаетесь к ней с помощью Enumerable. Вы можете предположить, что объект Enumerable является моментальным снимком исходной коллекции. Поэтому, если вы попытаетесь изменить коллекцию во время перечисления, она вызовет исключение. Однако извлеченные объекты в Enumeration вовсе не являются неизменными.

Поскольку переменная, используемая в цикле foreach, является локальной для блока цикла, эта переменная недоступна вне блока.