Jon Jagger
jon@jaggersoft.com
Table of Contents 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 Notes DownloadECMA-334 C# Language Specificationpreviousnextprevious at this levelnext at this level 10 Basic conceptsprevious at this levelnext at this level 10.7 Scopes Paragraph 11 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. 2 Scopes can be nested, and an inner scope may redeclare the meaning of a name from an outer scope. [Note: This does not, however, remove the restriction imposed by §10.3 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. end note] 3 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. Paragraph 21 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. [Example: For example
class A  
{  
   void F() {  
      i = 1;  
   }  
   int i = 0;  
}  
Here, it is valid for F to refer to i before it is declared. end example] Paragraph 31 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. [Example: For example
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  
   }  
}  
In the F method above, the first assignment to i specifically does not refer to the field declared in the outer scope. Rather, it refers to the local variable and it results in a compile-time error because it textually precedes the declaration of the variable. In the G method, the use of j in the initializer for the declaration of j is valid because the 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. end example] [Note: 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 example above, the first assignment would assign to the instance variable and the second assignment would assign to the local variable. In certain situations but not in the exampe above, this could lead to a compile-time error if the statements of the block were later to be rearranged.) The meaning of a name within a block may differ based on the context in which the name is used. In the example
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.ToString());  // writes "Type: A"  
   }  
}  
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. end note]
{ JSL }
Jagger Software Ltd
Company # 4070126
VAT # 762 5213 42
Valid HTML 4.01Valid CSS