C# 4 and .NET 4

30 ❘ ChaPTer 2 cOre c#
Here’s another example:
public static int Main()
{
int j = 20;
for (int i = 0; i < 10; i++)
{
int j = 30; // Can't do this—j is still in scope
Console.WriteLine(j + i);
}
return 0;
}
code snippet ScopeBad.cs
If you try to compile this, you’ll get an error like the following:
ScopeTest.cs(12,15): error CS0136: A local variable named 'j' cannot be declared in
this scope because it would give a different meaning to 'j', which is already used
in a 'parent or current' scope to denote something else.
This occurs because the variable j, which is defined before the start of the for loop, is still in scope within the
for loop, and won’t go out of scope until the Main() method has finished executing. Although the second j
(the illegal one) is in the loop’s scope, that scope is nested within the Main() method’s scope. The compiler has
no way to distinguish between these two variables, so it won’t allow the second one to be declared.
scope Clashes for fields and local Variables
In certain circumstances, however, you can distinguish between two identifiers with the same name
(although not the same fully qualified name) and the same scope, and in this case the compiler allows you to
declare the second variable. The reason is that C# makes a fundamental distinction between variables that
are declared at the type level (fields) and variables that are declared within methods (local variables).
Consider the following code snippet:
using System;
namespace Wrox
{
class ScopeTest2
{
static int j = 20;
public static void Main()
{
int j = 30;
Console.WriteLine(j);
return;
}
}
}
code snippet ScopeTest2.cs
This code will compile, even though you have two variables named j in scope within the Main() method:
the j that was defined at the class level, and doesn’t go out of scope until the class is destroyed (when the
Main() method terminates, and the program ends); and the j defined in Main(). In this case, the new
variable named j that you declare in the Main() method hides the class-level variable with the same name,
so when you run this code, the number 30 will be displayed.
However, what if you want to refer to the class-level variable You can actually refer to fields of a class
or struct from outside the object, using the syntax object.fieldname. In the previous example, you are
accessing a static field (you look at what this means in the next section) from a static method, so you can’t
use an instance of the class; you just use the name of the class itself:
www.it-ebooks.info