The parameters of a method, if any, are declared by the method?s
formal-parameter-list.
formal-parameter-list:
fixed-parameters
fixed-parameters , parameter-array
parameter-array
fixed-parameters:
fixed-parameter
fixed-parameters , fixed-parameter
fixed-parameter:
attributesopt parameter-modifieropt type identifier
parameter-modifier:
ref
out
parameter-array:
attributesopt params array-type identifier
The formal parameter list consists of one or more comma-separated
parameters of which only the last may be a
parameter-array.
A fixed-parameter consists of an optional set of attributes (§24), an
optional ref or out modifier, a type, and an
identifier. Each fixed-parameter declares a parameter of the given type
with the given name.
A parameter-array consists of an optional set of attributes (§24), a
params modifier, an array-type, and an
identifier. A parameter array declares a single parameter of the given
array type with the given name. The arraytype
of a parameter array must be a single-dimensional array type (§19.1). In a
method invocation, a parameter
array permits either a single argument of the given array type to be
specified, or it permits zero or more
arguments of the array element type to be specified. Parameter arrays are
described further in §17.5.1.4.
A method declaration creates a separate declaration space for parameters
and local variables. Names are
introduced into this declaration space by the formal parameter list of the
method and by local variable
declarations in the block of the method. All names in the declaration space
of a method must be unique;
otherwise, a compile-time error results.
Chapter 17 Classes
229
A method invocation (§14.5.5.1) creates a copy, specific to that
invocation, of the formal parameters and local
variables of the method, and the argument list of the invocation assigns
values or variable references to the newly
created formal parameters. Within the block of a method, formal parameters
can be referenced by their identifiers
in simple-name expressions (§14.5.2).
There are four kinds of formal parameters:
? Value parameters, which are declared without any modifiers.
? Reference parameters, which are declared with the ref modifier.
? Output parameters, which are declared with the out modifier.
? Parameter arrays, which are declared with the params modifier.
[Note: As described in §10.6, the ref and out modifiers are part of a
method?s signature, but the params
modifier is not. end note]
17.5.1.1 Value parameters
A parameter declared with no modifiers is a value parameter. A value
parameter corresponds to a local variable
that gets its initial value from the corresponding argument supplied in the
method invocation.
When a formal parameter is a value parameter, the corresponding argument in
a method invocation must be an
expression of a type that is implicitly convertible (§13.1) to the formal
parameter type.
A method is permitted to assign new values to a value parameter. Such
assignments only affect the local storage
location represented by the value parameter?they have no effect on the
actual argument given in the method
invocation.
17.5.1.2 Reference parameters
A parameter declared with a ref modifier is a reference parameter. Unlike a
value parameter, a reference
parameter does not create a new storage location. Instead, a reference
parameter represents the same storage
location as the variable given as the argument in the method invocation.
When a formal parameter is a reference parameter, the corresponding
argument in a method invocation must
consist of the keyword ref followed by a variable-reference (§12.3.3) of
the same type as the formal parameter.
A variable must be definitely assigned before it can be passed as a
reference parameter.
Within a method, a reference parameter is always considered definitely
assigned.
[Example: The example
using System;
class Test
{
static void Swap(ref int x, ref int y) {
int temp = x;
x = y;
y = temp;
}
static void Main() {
int i = 1, j = 2;
Swap(ref i, ref j);
Console.WriteLine("i = {0}, j = {1}", i, j);
}
}
produces the output
i = 2, j = 1
For the invocation of Swap in Main, x represents i and y represents j.
Thus, the invocation has the effect of
swapping the values of i and j. end example]
C# LANGUAGE SPECIFICATION
230
In a method that takes reference parameters, it is possible for multiple
names to represent the same storage
location. [Example: In the example
class A
{
string s;
void F(ref string a, ref string b) {
s = "One";
a = "Two";
b = "Three";
}
void G() {
F(ref s, ref s);
}
}
the invocation of F in G passes a reference to s for both a and b. Thus,
for that invocation, the names s, a, and b
all refer to the same storage location, and the three assignments all
modify the instance field s. end example]
17.5.1.3 Output parameters
A parameter declared with an out modifier is an output parameter. Similar
to a reference parameter, an output
parameter does not create a new storage location. Instead, an output
parameter represents the same storage
location as the variable given as the argument in the method invocation.
When a formal parameter is an output parameter, the corresponding argument
in a method invocation must
consist of the keyword out followed by a variable-reference (§12.3.3) of
the same type as the formal parameter.
A variable need not be definitely assigned before it can be passed as an
output parameter, but following an
invocation where a variable was passed as an output parameter, the variable
is considered definitely assigned.
Within a method, just like a local variable, an output parameter is
initially considered unassigned and must be
definitely assigned before its value is used.
Every output parameter of a method must be definitely assigned before the
method returns.
Output parameters are typically used in methods that produce multiple
return values. [Example: For example:
using System;
class Test
{
static void SplitPath(string path, out string dir, out string name) {
int i = path.Length;
while (i > 0) {
char ch = path[i ? 1];
if (ch == ’\\’ || ch == ’/’ || ch == ’:’) break;
i--;
}
dir = path.Substring(0, i);
name = path.Substring(i);
}
static void Main() {
string dir, name;
SplitPath("c:\\Windows\\System\\hello.txt", out dir, out name);
Console.WriteLine(dir);
Console.WriteLine(name);
}
}
The example produces the output:
c:\Windows\System\
hello.txt
Note that the dir and name variables can be unassigned before they are
passed to SplitPath, and that they are
considered definitely assigned following the call. end example]
Chapter 17 Classes
231
17.5.1.4 Parameter arrays
A parameter declared with a params modifier is a parameter array. If a
formal parameter list includes a
parameter array, it must be the last parameter in the list and it must be
of a single-dimensional array type.
[Example: For example, the types string[] and string[][] can be used as the
type of a parameter array, but
the type string[,] can not. end example] It is not possible to combine the
params modifier with the modifiers
ref and out.
A parameter array permits arguments to be specified in one of two ways in a
method invocation:
? The argument given for a parameter array can be a single expression of a
type that is implicitly convertible
(§13.1) to the parameter array type. In this case, the parameter array
acts precisely like a value parameter.
? Alternatively, the invocation can specify zero or more arguments for the
parameter array, where each
argument is an expression of a type that is implicitly convertible (§13.1)
to the element type of the parameter
array. In this case, the invocation creates an instance of the parameter
array type with a length corresponding
to the number of arguments, initializes the elements of the array instance
with the given argument values, and
uses the newly created array instance as the actual argument.
Except for allowing a variable number of arguments in an invocation, a
parameter array is precisely equivalent to
a value parameter (§17.5.1.1) of the same type.
[Example: The example
using System;
class Test
{
static void F(params int[] args) {
Console.Write("Array contains {0} elements:", args.Length);
foreach (int i in args)
Console.Write(" {0}", i);
Console.WriteLine();
}
static void Main() {
int[] arr = {1, 2, 3};
F(arr);
F(10, 20, 30, 40);
F();
}
}
produces the output
Array contains 3 elements: 1 2 3
Array contains 4 elements: 10 20 30 40
Array contains 0 elements:
The first invocation of F simply passes the array a as a value parameter.
The second invocation of F
automatically creates a four-element int[] with the given element values
and passes that array instance as a
value parameter. Likewise, the third invocation of F creates a zero-element
int[] and passes that instance as a
value parameter. The second and third invocations are precisely equivalent
to writing:
F(new int[] {10, 20, 30, 40});
F(new int[] {});
end example]
When performing overload resolution, a method with a parameter array may be
applicable either in its normal
form or in its expanded form (§14.4.2.1). The expanded form of a method is
available only if the normal form of
the method is not applicable and only if a method with the same signature
as the expanded form is not already
declared in the same type.
[Example: The example
C# LANGUAGE SPECIFICATION
232
using System;
class Test
{
static void F(params object[] a) {
Console.WriteLine("F(object[])");
}
static void F() {
Console.WriteLine("F()");
}
static void F(object a0, object a1) {
Console.WriteLine("F(object,object)");
}
static void Main() {
F();
F(1);
F(1, 2);
F(1, 2, 3);
F(1, 2, 3, 4);
}
}
produces the output
F();
F(object[]);
F(object,object);
F(object[]);
F(object[]);
In the example, two of the possible expanded forms of the method with a
parameter array are already included in
the class as regular methods. These expanded forms are therefore not
considered when performing overload
resolution, and the first and third method invocations thus select the
regular methods. When a class declares a
method with a parameter array, it is not uncommon to also include some of
the expanded forms as regular
methods. By doing so it is possible to avoid the allocation of an array
instance that occurs when an expanded
form of a method with a parameter array is invoked. end example]
When the type of a parameter array is object[], a potential ambiguity
arises between the normal form of the
method and the expended form for a single object parameter. The reason for
the ambiguity is that an object[]
is itself implicitly convertible to type object. The ambiguity presents no
problem, however, since it can be
resolved by inserting a cast if needed.
[Example: The example
using System;
class Test
{
static void F(params object[] args) {
foreach (object o in args) {
Console.Write(o.GetType().FullName);
Console.Write(" ");
}
Console.WriteLine();
}
static void Main() {
object[] a = {1, "Hello", 123.456};
object o = a;
F(a);
F((object)a);
F(o);
F((object[])o);
}
}
produces the output
Chapter 17 Classes
233
System.Int32 System.String System.Double
System.Object[]
System.Object[]
System.Int32 System.String System.Double
In the first and last invocations of F, the normal form of F is applicable
because an implicit conversion exists
from the argument type to the parameter type (both are of type object[]).
Thus, overload resolution selects the
normal form of F, and the argument is passed as a regular value parameter.
In the second and third invocations,
the normal form of F is not applicable because no implicit conversion
exists from the argument type to the
parameter type (type object cannot be implicitly converted to type
object[]). However, the expanded form of
F is applicable, so it is selected by overload resolution. As a result, a
one-element object[] is created by the
invocation, and the single element of the array is initialized with the
given argument value (which itself is a
reference to an object[]). end example]
分享到:
相关推荐
VMware-workstation-full-17.5.1-23298084
17.5.1(SVM浅析)1
WPS_Office_Premium_17.5.1_Red.apk
python库,解压后可用。 资源全名:galaxy_lib-17.5.1-py2.7.egg
资源来自pypi官网。 资源全名:galaxy_lib-17.5.1-py2.7.egg
1.6.6.2 Method body and local variables 16 1.6.6.3 Static and instance methods 17 1.6.6.4 Virtual, override, and abstract methods 18 1.6.6.5 Method overloading 20 1.6.7 Other function members 21 1.6....
官方离线安装包,亲测可用。使用rpm -ivh [rpm完整包名] 进行安装
官方离线安装包,亲测可用。使用rpm -ivh [rpm完整包名] 进行安装
官方离线安装包,亲测可用。使用rpm -ivh [rpm完整包名] 进行安装
官方离线安装包,亲测可用。使用rpm -ivh [rpm完整包名] 进行安装
官方离线安装包,亲测可用。使用rpm -ivh [rpm完整包名] 进行安装
官方离线安装包,亲测可用。使用rpm -ivh [rpm完整包名] 进行安装
目录: 网盘文件永久连接 ...17.5.1 用户权限控制 18.5.2 审计 19.6.1 jdbc 20.6.2 ODBC 21.6.3 数据库工具 22.7.1 数据库设计上 23.7.2 范式理论 24.7.3 数据库设计下 25.8.1 华为GaussDB数据库
17.5.1 概述 17.5.2 主机操作 17.5.3 从机模式 17.5.4 异常状况 17.6 管脚描述 17.7 寄存器描述 17.7.1 SPI控制寄存器 17.7.2 SPI状态寄存器 17.7.3 SPI数据寄存器 17.7.4 SPI时钟计数器寄存器 17.7.5 SPI测试控制...
Backward Motion Estimation 14.3 Performance Comparison Among Three Major Approaches 14.3.1 Three Representatives 14.3.2 Algorithm Parameters 14.3.3 Experimental Results and Observations ...
Vmware17pro 支持mac 的unlocker425最新版本
重装VMware虚拟机后,在虚拟机上运行ubuntu和Debian可能出现的2种无法打开的解决方法 出现情况:1、Mount of filesystem failed;2、the root filesystem is currently mounted readonly
367 17.4.1 查看SQL Server日志 367 17.4.2 查看Windows系统日志 368 17.5 通过动态管理视图查看服务器信息 369 17.5.1 与数据库有关的动态管理视图 369 17.5.2 与SQL Server操作系统关联的动态管理...
17.1基于损失函数的标准 17.1.1混淆矩阵 17.1.2准确率及误差的度量 17.1.3两个评价模型成本的可视化工具 17.1.4评估分类器的准确率 ...17.5.1交叉验证标准 17.5.2自展标准 17.5.3遗传算法 17.6小结
17.1 ASP.NET 2.0缓存概述 299 17.2 使用页面输出缓存 299 17.2.1 启用页面输出缓存 299 ...17.5.1 文件缓存依赖 310 17.5.2 其他缓存依赖 311 17.6 常见问题 311 17.6.1 页面输出缓存是否可以在Web.config文件中进