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:
