8.3 Variables and parameters

8.3 Variables and parameters                                           
                                               
Variables represent storage locations. Every variable has a type that  
                                               
determines what values can be stored in                                
                                               
the variable. Local variables are variables that are declared in
methods,                                              
properties, or indexers. A local                                       
                                               
variable is defined by specifying a type name and a declarator that    
                                               
specifies the variable name and an                                     
                                               
optional initial value, as in:                                         
                                               
int a;                                                                 
                                               
int b = 1;                                                             
                                               
but it is also possible for a local variable declaration to include    
                                               
multiple declarators. The declarations of a                            
                                               
and b can be rewritten as:                                             
                                               
int a, b = 1;                                                          
                                               
A variable must be assigned before its value can be obtained. The
example                                              
class Test                                                             
                                               
{                                                                      
                                               
static void Main() {                                                   
                                               
int a;                                                                 
                                               
int b = 1;                                                             
                                               
int c = a + b; // error, a not yet assigned                            
                                               
.                                                                      
                                               
}                                                                      
                                               
}                                                                      
                                               
results in a compile-time error because it attempts to use the variable
a                                              
before it is assigned a value. The                                     
                                               
rules governing definite assignment are defined in §12.3.             
                                               
A field (§17.4) is a variable that is associated with a class or
struct,                                              
or an instance of a class or struct. A field                           
                                               
declared with the static modifier defines a static variable, and a
field                                               
declared without this modifier                                         
                                               
defines an instance variable. A static field is associated with a type,
                                               
whereas an instance variable is                                        
                                               
associated with an instance. The example  
using Personnel.Data;
class Employee { private static DataSet ds; public string Name;
public decimal Salary;
.
}
shows an Employee class that has a private static variable and two public
instance variables.
Formal parameter declarations also define variables. There are four kinds
of parameters: value parameters,
reference parameters, output parameters, and parameter arrays.
A value parameter is used for .in. parameter passing, in which the value of
an argument is passed into a
method, and modifications of the parameter do not impact the original
argument. A value parameter refers to
its own variable, one that is distinct from the corresponding argument.
This variable is initialized by copying
the value of the corresponding argument. The example
using System;
class Test
{
static void F(int p) {
Console.WriteLine("p = {0}", p);
p++;
}
static void Main() {
int a = 1;
Console.WriteLine("pre: a = {0}", a);
F(a);
Console.WriteLine("post: a = {0}", a);
}
}
shows a method F that has a value parameter named p. The example produces
the output:
pre: a = 1
p = 1
post: a = 1
even though the value parameter p is modified.
A reference parameter is used for .by reference. parameter passing, in
which the parameter acts as an alias
for a caller-provided argument. A reference parameter does not itself
define a variable, but rather refers to
the variable of the corresponding argument. Modifications of a reference
parameter impact the
corresponding argument. A reference parameter is declared with a ref
modifier. The example
using System;
class Test
{
static void Swap(ref int a, ref int b) {
int t = a;
a = b;
b = t;
}
static void Main() {
int x = 1;
int y = 2;
Console.WriteLine("pre: x = {0}, y = {1}", x, y);
Swap(ref x, ref y);
Console.WriteLine("post: x = {0}, y = {1}", x, y);
}
}
shows a Swap method that has two reference parameters. The output produced
is: