10.6 Signatures and overloading

王朝other·作者佚名  2006-01-10
窄屏简体版  字體: |||超大  

its formal parameters, considered in the order left to right. The signature

of a method

specifically does not include the return type, nor does it include the

params modifier that may be

specified for the right-most parameter.

?The signature of an instance constructor consists of the type and kind

(value, reference, or output) of

each of its formal parameters, considered in the order left to right. The

signature of an instance

constructor specifically does not include the params modifier that may be

specified for the right-most

parameter.

?The signature of an indexer consists of the type of each of its formal

parameters, considered in the order

left to right. The signature of an indexer specifically does not include

the element type, nor does it

include the params modifier that may be specified for the right-most

parameter.

?The signature of an operator consists of the name of the operator and the

type of each of its formal

parameters, considered in the order left to right. The signature of an

operator specifically does not

include the result type.

Signatures are the enabling mechanism for overloading of members in

classes, structs, and interfaces:

?Overloading of methods permits a class, struct, or interface to declare

multiple methods with the same

name, provided their signatures are unique within that class, struct, or

interface.

?Overloading of instance constructors permits a class or struct to declare

multiple instance constructors,

provided their signatures are unique within that class or struct.

?Overloading of indexers permits a class, struct, or interface to declare

multiple indexers, provided their

signatures are unique within that class, struct, or interface.

?Overloading of operators permits a class or struct to declare multiple

operators with the same name,

provided their signatures are unique within that class or struct.

Although out and ref parameter modifiers are considered part of a

signature, members declared in a single

type cannot differ in signature solely by ref and out. A compile-time error

occurs if two members are

Chapter 10 Basic concepts

79

declared in the same type with signatures that would be the same if all

parameters in both methods with out

modifiers were changed to ref modifiers. For other purposes of signature

matching (e.g., hiding or

overriding), ref and out are considered part of the signature and do not

match each other. [Note: This

restriction is to allow C# programs to be easily translated to run on the

Common Language Infrastructure

(CLI), which does not provide a way to define methods that differ solely in

ref and out. end note]

[Example: The following example shows a set of overloaded method

declarations along with their

signatures.

interface ITest

{

void F(); // F()

void F(int x); // F(int)

void F(ref int x); // F(ref int)

void F(out int x); // F(out int) error

void F(int x, int y); // F(int, int)

int F(string s); // F(string)

int F(int x); // F(int) error

void F(string[] a); // F(string[])

void F(params string[] a); // F(string[]) error

}

Note that any ref and out parameter modifiers (?7.5.1) are part of a

signature. Thus, F(int), F(ref

int), and F(out int) are all unique signatures. However, F(ref int) and

F(out int) cannot be

declared within the same interface because their signatures differ solely

by ref and out. Also, note that the

return type and the params modifier are not part of a signature, so it is

not possible to overload solely based

on return type or on the inclusion or exclusion of the params modifier. As

such, the declarations of the

methods F(int) and F(params string[]) identified above, result in a

compile-time error. end example]

 
 
 
免责声明:本文为网络用户发布,其观点仅代表作者个人观点,与本站无关,本站仅提供信息存储服务。文中陈述内容未经本站证实,其真实性、完整性、及时性本站不作任何保证或承诺,请读者仅作参考,并请自行核实相关内容。
 
 
© 2005- 王朝網路 版權所有  導航