pre: x = 1, y = 2
post: x = 2, y = 1
The ref keyword must be used in both the declaration of the formal parameter
and in uses of it. The use of
ref at the call site calls special attention to the parameter, so that a
developer reading the code will
understand that the value of the argument could change as a result of the
call.
An output parameter is similar to a reference parameter, except that the
initial value of the caller-provided
argument is unimportant. An output parameter is declared with an out
modifier. The example
using System;
class Test
{
static void Divide(int a, int b, out int result, out int remainder) {
result = a / b;
remainder = a % b;
}
static void Main() {
for (int i = 1; i < 10; i++)
for (int j = 1; j < 10; j++) {
int ans, r;
Divide(i, j, out ans, out r);
Console.WriteLine("{0} / {1} = {2}r{3}", i, j, ans, r);
}
}
}
shows a Divide method that includes two output parameters.one for the
result of the division and another
for the remainder.
For value, reference, and output parameters, there is a one-to-one
correspondence between caller-provided
arguments and the parameters used to represent them. A parameter array
enables a many-to-one
relationship: many arguments can be represented by a single parameter
array. In other words, parameter
arrays enable variable length argument lists.
A parameter array is declared with a params modifier. There can be only one
parameter array for a given
method, and it must always be the last parameter specified. The type of a
parameter array is always a single
dimensional array type. A caller can either pass a single argument of this
array type, or any number of
arguments of the element type of this array type. For instance, the example
using System;
class Test
{
static void F(params int[] args) {
Console.WriteLine("# of arguments: {0}", args.Length);
for (int i = 0; i < args.Length; i++)
Console.WriteLine("\targs[{0}] = {1}", i, args[i]);
}
static void Main() {
F();
F(1);
F(1, 2);
F(1, 2, 3);
F(new int[] {1, 2, 3, 4});
}
}
shows a method F that takes a variable number of int arguments, and several
invocations of this method.
The output is:
# of arguments:
0
# of arguments:
1
args[0] =
1
# of arguments:
2
args[0] =
1
args[1] =
2
# of arguments:
3
args[0] =
1
args[1] =
2
args[2] =
3
# of arguments:
4
args[0] =
1
args[1] =
2
args[2] =
3
args[3] =
4
Most of the examples presented in this introduction use the WriteLine
method
of the Console class.
The
argument substitution behavior of this method, as exhibited in the
example
int a = 1, b =
2;
Console.WriteLine("a = {0}, b = {1}", a,
b);
is accomplished using a parameter array. The WriteLine method
provides
several overloaded methods
for
the common cases in which a small number of arguments are passed, and
one
method that uses a
parameter
array.
namespace
System
{
public class
Console
{
public static void WriteLine(string s)
{.}
public static void WriteLine(string s, object a)
{.}
public static void WriteLine(string s, object a, object b)
{.}
.
public static void WriteLine(string s, params object[] args)
{.}
}
}
