7.10 Scope of Declarations

You’ve seen declarations of C# entities, such as classes, methods, properties, variables and parameters. Declarations introduce names that can be used to refer to such C# entities. The scope of a declaration is the portion of the app that can refer to the declared entity by its unqualified name. Such an entity is said to be “in scope” for that portion of the app. This section introduces several important scope issues. The basic scope rules are as follows:

  1. The scope of a parameter declaration is the body of the method in which the declaration appears.

  2. The scope of a local-variable declaration is from the point at which the declaration appears to the end of the block containing the declaration.

  3. The scope of a local-variable declaration that appears in the initialization section of a for statement’s header is the body of the for statement and the other expressions in the header.

  4. The scope of a method, property or field of a class is the entire body of the class. This enables non-static methods and properties of a class to use any of the class’s fields, methods and properties, regardless of the order in which they’re declared. Similarly, static methods and properties can use any of the static members of the class.

Any block may contain variable declarations. If a local variable or parameter in a method has the same name as a field, the field is hidden until the block terminates—in Chapter 10, we discuss how to access hidden fields. A compilation error occurs if a nested block in a method contains a variable with the same name as a local variable in an outer block of the method. The app in Fig. 7.9 demonstrates scoping issues with fields and local variables.

Error-Prevention Tip 7.1

Use different names for fields and local variables to help prevent subtle logic errors that occur when a method is called and a local variable of the method hides a field of the same name in the class.

 

Fig. 7.9 Scope class demonstrates static- and local-variable scopes.

Alternate View 

  1   // Fig. 7.9: Scope.cs
  2   // Scope class demonstrates static and local variable scopes.
  3   using System;
  4
  5   class Scope
  6   {
  7      // static variable that’s accessible to all methods of this class
  8      private static int x = 1;                                             
  9
 10      // Main creates and initializes local variable x
 11      // and calls methods UseLocalVariable and UseStaticVariable
 12      static void Main()
 13      {
 14         int x = 5; // method's local variable x hides static variable x
 15
 16         Console.WriteLine($"local x in method Main is {x}");
 17
 18         // UseLocalVariable has its own local x
 19         UseLocalVariable();
 20
 21         // UseStaticVariable uses class Scope's static variable x
 22         UseStaticVariable();
 23
 24         // UseLocalVariable reinitializes its own local x
 25         UseLocalVariable();
 26
 27         // class Scope's static variable x retains its value
 28         UseStaticVariable();
 29
 30         Console.WriteLine($"
local x in method Main is {x}");
 31      }
 32
 33      // create and initialize local variable x during each call
 34      static void UseLocalVariable()
 35      {
 36         int x = 25; // initialized each time UseLocalVariable is called
 37
 38         Console.WriteLine(
 39            $"
local x on entering method UseLocalVariable is {x}");
 40         ++x; // modifies this method's local variable x
 41         Console.WriteLine(
 42            $"local x before exiting method UseLocalVariable is {x}");
 43      }
 44
 45      // modify class Scope's static variable x during each call
 46      static void UseStaticVariable()
 47      {
 48         Console.WriteLine("
static variable x on entering method " +
 49            $"UseStaticVariable is {x}");
 50         x *=10; // modifies class Scope's static variable x
 51         Console.WriteLine("static variable x before exiting " +
 52            $"method UseStaticVariable is {x}");
 53      }
 54   }


local x in method Main is 5

local x on entering method UseLocalVariable is 25
local x before exiting method UseLocalVariable is 26

static variable x on entering method UseStaticVariable is 1
static variable x before exiting method UseStaticVariable is 10

local x on entering method UseLocalVariable is 25
local x before exiting method UseLocalVariable is 26

static variable x on entering method UseStaticVariable is 10
static variable x before exiting method UseStaticVariable is 100

local x in method Main is 5

Line 8 declares and initializes the static variable x to 1. This static variable is hidden in any block (or method) that declares a local variable named x. Method Main (lines 12–31) declares local variable x (line 14) and initializes it to 5. This local variable’s value is output to show that static variable x (whose value is 1) is hidden in method Main. The app declares two other methods—UseLocalVariable (lines 34–43) and UseStaticVariable (lines 46–53)—that each take no arguments and do not return results. Method Main calls each method twice (lines 19–28). Method UseLocalVariable declares local variable x (line 36). When UseLocalVariable is first called (line 19), it creates local variable x and initializes it to 25 (line 36), outputs the value of x (lines 38–39), increments x (line 40) and outputs the value of x again (lines 41–42). When UseLocalVariable is called a second time (line 25), it re-creates local variable x and reinitializes it to 25, so the output of each call to UseLocalVariable is identical.

Method UseStaticVariable does not declare any local variables. Therefore, when it refers to x, static variable x (line 8) of the class is used. When method UseStaticVariable is first called (line 22), it outputs the value (1) of static variable x (lines 48–49), multiplies the static variable x by 10 (line 50) and outputs the value (10) of static variable x again (lines 51–52) before returning. The next time method UseStaticVariable is called (line 28), the static variable has its modified value, 10, so the method outputs 10, then 100. Finally, in method Main, the app outputs the value of local variable x again (line 30) to show that none of the method calls modified Main’s local variable x, because the methods all referred to variables named x in other scopes.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset