Переменный беспорядок объема в C#

Question

Переменный беспорядок объема в C#

Я использую Watin, но не использовал Селена. Я могу сказать, что встал и работающий быстро на Watin и имел немногих ни к каким проблемам. Я не могу думать ни о чем, что я хотел сделать это, я не мог выяснить с ним. HTH

16

c# scope

задан 12 revs, 7 users 45% 26 September 2015 в 02:33

4 ответа

Из спецификации языка C # ...

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

В примере кода 1 и i, и objX объявлены в области видимости функции, поэтому никакая другая переменная в любом блоке внутри этой функции не может иметь с ними общего имени. В примере кода 2 оба объекта objX объявлены внутри циклов for, что означает, что они не нарушают правило не повторно объявлять локальные переменные во внутренних областях из другого объявления.

12

ответ дан 30 November 2019 в 15:18

Вы можете использовать одно и то же имя переменной в неперекрывающихся областях. Однако, если одна область видимости перекрывает другую, вы не можете объявить одну и ту же переменную в обеих. Причина в том, чтобы вы не могли случайно использовать уже используемое имя переменной во внутренней области видимости, как вы сделали с i в первом примере. На самом деле это не для предотвращения ошибки objX , поскольку это, по общему признанию, не сильно сбивает с толку, но ошибка является следствием того, как применяется правило. Компилятор рассматривает objX как имеющий происхождение во всей области видимости, в которой он объявлен как до, так и после объявления, а не сразу после.

Во втором примере два цикла for имеют независимые, неперекрывающиеся области применения, так что вы можете повторно использовать i и objX во втором цикле. Это также причина, по которой вы можете повторно использовать x в качестве счетчика циклов. Очевидно, было бы глупым ограничением, если бы вам пришлось придумывать разные имена для каждого цикла стилей for (i = 1; i <10; ++ i) в функции.

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

6

ответ дан 30 November 2019 в 15:18

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

-1

ответ дан 30 November 2019 в 15:18

Другие вопросы по тегам:

c# scope

Похожие вопросы:

score 44 · Accepted Answer

Здесь есть два важных правила.

Первое соответствующее правило:

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

(И другой ответ на этой странице вызывает другое место в спецификации, где мы вызываем это снова.)

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

Второе соответствующее правило в C #:

Для каждого вхождения данного идентификатор как простое имя в выражение или декларатор в пределах пространство объявления локальной переменной, немедленно включающий блок, или переключатель этого события, каждый второй случай того же идентификатор как простое имя в выражение или декларатор внутри немедленно включающий блок или блок переключателей должен относиться к тому же организация. Это правило гарантирует, что значение имени всегда одно и то же в данном блоке, блок переключателя, for-, foreach- или using-statement, или анонимная функция.

Вам также необходимо знать, что цикл for обрабатывается так, как будто вокруг всего этого есть «невидимые скобки».

Теперь, когда мы это знаем, давайте аннотируем ваш код:

public void MyMethod()
{ // 1
    int i=10; // i1
    { // 2 -- invisible brace
      for(int x=10; x<10; x++) // x2
      { // 3
        int i=10;  // i3
        var objX = new MyOtherClass(); // objX3
      } // 3
    } // 2
    var objX = new OtherClasOfMine(); // objX1
} // 1

У вас есть три «простых имени»: i, x и objX. У вас есть пять переменных, которые я обозначил i1, x2, i3, objX3 и objX1.

Самый внешний блок, который содержит случаи использования i и objX, - это блок 1. Следовательно, внутри блока 1 i и objX всегда должны ссылаться к тому же. Но они этого не делают. Иногда i ссылается на i1, а иногда на i3. То же самое с objX.

x, однако, всегда означает только x2 в каждом блоке.

Кроме того, обе переменные «i» находятся в одном и том же пространстве объявления локальной переменной, как и обе переменные «objX».

Следовательно, эта программа является ошибкой по нескольким причинам.

Во второй программе:

public void MyMethod()
{ // 1
    { // 2 -- invisible 
      for(int x=10; x<10; x++)   // x2
      { // 3
        int i=10;  // i3
        var objX = new MyOtherClass(); // objX3
      } //3 
    } // 2
    { // 4 -- invisible
      for(int x=10; x<10; x++)  // x4
      { // 5
        int i=10;  // i5
        var objX = new MyOtherClass();  // objX5
      } //5
   } // 4
} // 1

Теперь у вас снова есть три простых имени и шесть переменных.

Самые внешние блоки, которые сначала содержат использование простого имени x, - это блоки 2 и 4. На протяжении всего блока 2 x относится к x2. В блоке 4 x относится к x4. Следовательно, это законно. То же самое с i и objX - они используются в блоках 3 и 5 и означают разные вещи в каждом. Но нигде не используется одно и то же простое имя для обозначения двух разных вещей в одном и том же блоке.

Теперь вы можете заметить, что , учитывая весь блок 1 , x используется для обозначения как x2, так и x4. Но нет упоминания о x, который находится внутри блока 1, но НЕ также внутри другого блока. Поэтому мы не считаем актуальным несогласованное использование в блоке 1.