Мне кажется, что компилятор имеет в виду сказать, что i был объявлен на уровне метода и ограничен рамками цикла for .

Итак, в случае 1 - вы получаете сообщение об ошибке, что переменная уже существует, что она и делает

, а в случае 2 - поскольку переменная ограничена только в пределах цикла for , она не может быть доступ вне этого цикла

Чтобы избежать этого, вы могли бы:

var i = 0;

for(i = 0, i < 10, i++){
}

i = 10;

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

HTH

вам необходимо выполнить

            int i ;
            for ( i = 0; i < 10; i++)
            {

            }
            i = 10;

Из спецификации C # по объявлениям локальных переменных :

Объем объявленной локальной переменной {{1} } в объявлении-локальной-переменной - это блок , в котором происходит объявление.

Теперь, конечно, вы не можете использовать i до того, как он объявлен, но область действия объявления i - это весь блок , который содержит его:

{
    // scope starts here
    for (int i = 0; i < 10; i++)
    {
        Foo();
    }
    int i = 10;
}

Переменная for i находится в дочерней области, отсюда конфликт имен переменных.

Если мы изменим положение объявления, коллизия станет более ясной:

{
    int i = 10;

    // collision with i
    for (int i = 0; i < 10; i++)
    {
        Foo();
    }
}

Да, я второй за комментарий "компилятор няни-государства". Что интересно, это нормально.

for (int i = 0; i < 10; i++)
{

}

for (int i = 0; i < 10; i++)
{

}

и это нормально

for (int i = 0; i < 10; i++)
{

}

for (int j = 0; j < 10; j++)
{
    var i = 12;                
}

, но это не

for (int i = 0; i < 10; i++)
{
    var x = 2;
}

var x = 5;

, хотя вы можете это сделать

for (int i = 0; i < 10; i++)
{
    var k = 12;
}

for (int i = 0; i < 10; i++)
{
    var k = 13;
}

Все это немного непоследовательно.

РЕДАКТИРОВАТЬ

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

ДО

/*
 * doing two different things with the same name is unclear
 */
for (var index = 0; index < people.Count; index++)
{
    people[index].Email = null;
}
var index = GetIndexForSomethingElse(); 

ПОСЛЕ

/*
 * Now there is only one meaning for index in this scope
 */
ClearEmailAddressesFor(people); // the method name works like a comment now
var index = GetIndexForSomethingElse();

/*
 * Now index has a single meaning in the scope of this method.
 */
private void ClearEmailAddressesFor(IList<Person> people)
{
    for (var index = 0; index < people.Count; index++)
    {
        people[index].Email = null;
    }
}

class Test
{
    int i;
    static int si=9; 

    public Test()
    {
        i = 199;
    }

    static void main()
    {
        for (int i = 0; i < 10; i++)
        {
            var x = 2;
        }

        { var x = 3; }

        {    // remove outer "{ }" will generate compile error
            int si = 3; int i = 0;

             Console.WriteLine(si);
             Console.WriteLine(Test.si);
             Console.WriteLine(i);
             Console.WriteLine((new Test()).i);
        }
    }
}

В первом примере объявление i вне цикла делает i локальной переменной функции. В результате будет ошибкой объявить другое имя переменной i в любом блоке этой функции.

Второй, i находится в области видимости только во время цикла. Вне цикла я больше не доступен.

Итак, вы видели ошибки, но в этом нет ничего плохого

for (int i = 0; i < 10; i++)
{
  // do something
}

foreach (Foo foo in foos)
{
   int i = 42;
   // do something 
}

Поскольку объем i ограничен в каждом блоке.

Или это просто случай компилятора состояния няни?

Именно так. Нет смысла «повторно использовать» имена переменных в одном методе. Это просто источник ошибок и не более того.

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

Область действия против пространства декларации:

http://csharpfeeds.com/post/11730/Whats_The_Difference_Part_Two_Scope_vs_Declaration_Space_vs_Lifetime.aspx

Вы захотите взглянуть на ответ Эрика Липперта (который по умолчанию всегда прав в вопросах как это).

http://blogs.msdn.com/ericlippert/archive/2009/08/03/what-s-the-difference-part-two-scope-vs-declaration-space-vs-lifetime.aspx

Вот комментарий Эрика к вышеупомянутому посту, который, я думаю, говорит о том, почему они сделали то, что они сделали:

Посмотрите на это с другой стороны. Всегда должно быть разрешено перемещать объявление переменной UP в исходном коде до тех пор, пока вы держите его в том же блоке, верно? Если бы мы сделали это так, как вы предложили, то это иногда было бы законным, а иногда и незаконным! Но чего мы действительно хотим избежать, так это того, что происходит в C ++ - в C ++ иногда перемещение объявления переменной вверх фактически изменяет {{1} }} привязки других простых имен!