Scoping Rules

The scope of a name is the region of program text within which it is possible to refer to the entity declared by the name without qualification of the name. Scopes can be nested, and an inner scope may redeclare the meaning of a name from an outer scope (this does not, however, remove the restriction that within a nested block it is not possible to declare a local variable with the same name as a local variable in an enclosing block). The name from the outer scope is then said to be hidden in the region of program text covered by the inner scope, and access to the outer name is only possible by qualifying the name.

• The scope of a namespace member declared by a namespace-member-declaration with no enclosing namespace-declaration is the entire program text.

• The scope of a namespace member declared by a namespace-member-declaration within a namespace-declaration whose fully qualified name is N is the namespace-body of every namespace-declaration whose fully qualified name is N or starts with N, followed by a period.

• The scope of a name defined or imported by a using-directive extends over the namespace-member-declarations of the compilation-unit ornamespace-body in which the using-directive occurs. A using-directive may make zero or more namespace or type names available within a particular compilation-unit or namespace-body, but it does not contribute any new members to the underlying declaration space. In other words, ausing-directive is not transitive but rather affects only the compilation-unit or namespace-body in which it occurs.

• The scope of a member declared by a class-member-declaration is the class-body in which the declaration occurs. In addition, the scope of a class member extends to the class-body of those derived classes that are included in the accessibility domain of the member.

• The scope of a member declared by a struct-member-declaration is the struct-body in which the declaration occurs.

• The scope of a member declared by an enum-member-declaration is the enum-body in which the declaration occurs.

• The scope of a parameter declared in a method-declaration is the method-body of that method-declaration.

• The scope of a parameter declared in an indexer-declaration is the accessor-declarations of thatindexer-declaration.

• The scope of a parameter declared in an operator-declaration is the block of that operator-declaration.

• The scope of a parameter declared in a constructor-declaration is the constructor-initializer and block of that constructor-declaration.

• The scope of a label declared in a labeled-statement is the block in which the declaration occurs.

• The scope of a local variable declared in a local-variable-declaration is the block in which the declaration occurs.

• The scope of a local variable declared in a switch-block of a switch statement is the switch-block.

• The scope of a local variable declared in a for-initializer of a for statement is the for-initializer, the for-condition, the for-iterator, and the contained statement of the for statement.

• The scope of a local constant declared in a local-constant-declaration is the block in which the declaration occurs. It is a compile-time error to refer to a local constant in a textual position that precedes its constant-declarator.

Within the scope of a namespace, class, struct, or enumeration member, it is possible to refer to the member in a textual position that precedes the declaration of the member. In the following example, it is valid for F to refer to ibefore it is declared.

class A
{
   void F()
   {
      i = 1;
   }
   int i = 0;
}

Within the scope of a local variable, it is a compile-time error to refer to the local variable in a textual position that precedes the local-variable-declarator of the local variable. For example, in the F method, the first assignment to ispecifically does not refer to the field declared in the outer scope.

class A
{
   int i = 0;
 
   void F()
   { 
      i = 1;   // Error, use precedes declaration
      int i;
      i = 2;
   }
 
   void G()
   {
      int j = (j = 1);   // Valid
   }
 
   void H()
   {
    int a = 1, b = ++a;   // Valid 
   }
}

Rather, it refers to the local variable and results in a compile-time error because it textually precedes the declaration of the variable. In the G method, using j in the initializer for the declaration of j is valid because its use does not precede the local-variable-declarator. In the H method, a subsequent local-variable-declarator correctly refers to a local variable declared in an earlier local-variable-declarator within the same local-variable-declaration.

The scoping rules for local variables are designed to guarantee that the meaning of a name used in an expression context is always the same within a block. If the scope of a local variable were to extend only from its declaration to the end of the block, then in the previous example the first assignment would assign to the instance variable and the second assignment would assign to the local variable, possibly leading to compile-time errors if the statements of the block were later rearranged.

The meaning of a name within a block may differ based on the context in which the name is used. In the following example, the name A is used in an expression context to refer to the local variable A and in a type context to refer to the class A.

using System;
 
class A {}
 
class Test
{
   static void Main()
   {
      string A = "hello, world";
      string s = A;           // expression context
      Type t = typeof(A);     // type context
      Console.WriteLine(s);   // writes "hello, world"
      Console.WriteLine(t);   // writes "A"
   }
}