Почему при перечислении коллекции возникает исключение, а при циклическом просмотре ее элементов нет?

Вы не можете изменить коллекцию во время ее перечисления. Это правило существует даже без учета вопросов потоковой передачи. Из MSDN:

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

Целочисленный цикл for на самом деле не является перечислителем. В большинстве сценариев это выполняет одно и то же. Однако интерфейс для IEnumerator гарантирует, что вы сможете выполнить итерацию по всей коллекции. Платформа обеспечивает это внутренним образом, создавая исключение, если вызов MoveNext происходит после изменения коллекции. Это исключение вызывается объектом перечислителя.

Целочисленный цикл for проходит только по списку чисел. Когда вы индексируете коллекцию целым числом, вы просто получаете элемент в этой позиции. Если что-то было вставлено или удалено из списка, вы можете пропустить элемент или запустить один и тот же элемент дважды. Это может быть полезно в определенных ситуациях, когда вам нужно изменить коллекцию во время ее обхода. Цикл for не имеет объекта перечислителя, который бы гарантировал выполнение контракта IEnumerator, поэтому исключение не выдается.

Чтобы ответить на ваш актуальный вопрос...

При перечислении вы получите IEnumerator, который привязан к состоянию списка, как это было, когда вы просили об этом. Дальнейшие операции выполняются с перечислителем (MoveNext, Current).

При использовании цикла for вы создаете последовательность вызовов if для получения определенного элемента по индексу. Нет внешнего контекста, такого как счетчик, который знает, что вы попали в цикл. Насколько известно коллекции, вы просите только один предмет. Поскольку коллекция никогда не выдавала счетчик, она не может знать, что причина, по которой вы запрашиваете элемент 0, затем элемент 1, затем элемент 2 и т. д., заключается в том, что вы ходите по списку.

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

Но я думаю, вы все это понимаете, ваш вопрос был просто о том, почему два способа итерации ведут себя по-разному. Ответ на этот вопрос заключается в том, что состояние коллекции известно (для коллекции), когда вы вызываете GetEnumerator в одном случае и когда вы вызываете get_Item в другом случае.

Разница в том, что когда вы говорите, что «перебираете коллекцию», вы на самом деле не перебираете коллекцию, вы перебираете целые числа от 1 до 50 и добавляете в коллекцию эти индексы. Это не влияет на тот факт, что числа от 1 до 50 все еще существуют.

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

Если вы хотите это сделать, ищите «поточно-безопасный» список, но будьте готовы одновременно иметь дело с неточностями чтения и записи :)

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

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

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

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

Если вы измените список во время его зацикливания, вы можете получить нежелательные эффекты, от которых вас защищает перечислитель. Если вы, например, удаляете элемент из списка, не изменяя индекс цикла, чтобы он по-прежнему указывал на тот же элемент, вы можете пропустить элементы в цикле. Точно так же, если вы вставляете элементы без исправления индекса, вы можете повторять один и тот же элемент более одного раза.

Вы не можете изменить коллекцию, ВО ВРЕМЯ ПЕРЕЧИСЛЕНИЯ через нее.

проблема в том, что вы начинаете перечислять, когда ваша коллекция НЕ ПОЛНА, и пытаетесь ПРОДОЛЖАТЬ ДОБАВЛЯТЬ элементы, ВО ВРЕМЯ ПЕРЕЧИСЛЕНИЯ

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

Удаление Thread.Sleep из кода добавления подчеркивает это:

public static void AddItems(object state_)
{     
   for (int i = 1; i <= 50; i++)      
   {        
       _collection.Add(i.ToString());      
       Console.WriteLine("Adding " + i);  
   }   
} 

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