14.4.3 Function member invocation

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

This section describes the process that takes place at run-time to invoke a

particular function member. It is

assumed that a compile-time process has already determined the particular

member to invoke, possibly by

applying overload resolution to a set of candidate function members.

For purposes of describing the invocation process, function members are

divided into two categories:

?Static function members. These are static methods, instance constructors,

static property accessors, and

user-defined operators. Static function members are always non-virtual.

?Instance function members. These are instance methods, instance property

accessors, and indexer

accessors. Instance function members are either non-virtual or virtual, and

are always invoked on a

particular instance. The instance is computed by an instance expression,

and it becomes accessible

within the function member as this (?4.5.7).

The run-time processing of a function member invocation consists of the

following steps, where M is the

function member and, if M is an instance member, E is the instance

expression:

?If M is a static function member:

The argument list is evaluated as described in ?4.4.1.

M is invoked.

?If M is an instance function member declared in a value-type:

E is evaluated. If this evaluation causes an exception, then no further

steps are executed.

If E is not classified as a variable, then a temporary local variable of

E?s type is created and the value of E is

assigned to that variable. E is then reclassified as a reference to that

temporary local variable. The temporary

variable is accessible as this within M, but not in any other way. Thus,

only when E is a true variable is it

possible for the caller to observe the changes that M makes to this.

The argument list is evaluated as described in ?4.4.1.

M is invoked. The variable referenced by E becomes the variable referenced

by this.

?If M is an instance function member declared in a reference-type:

E is evaluated. If this evaluation causes an exception, then no further

steps are executed.

The argument list is evaluated as described in ?4.4.1.

If the type of E is a value-type, a boxing conversion (?1.3.1) is

performed to convert E to type object, and

E is considered to be of type object in the following steps. [Note: In this

case, M could only be a member of

System.Object. end note]

The value of E is checked to be valid. If the value of E is null, a

System.NullReferenceException is

thrown and no further steps are executed.

The function member implementation to invoke is determined:

Chapter 14 Expressions

137

?If the compile-time type of E is an interface, the function member to

invoke is the

implementation of M provided by the run-time type of the instance

referenced by E. This

function member is determined by applying the interface mapping rules (?0.4.

2) to determine

the implementation of M provided by the run-time type of the instance

referenced by E.

?Otherwise, if M is a virtual function member, the function member to

invoke is the

implementation of M provided by the run-time type of the instance

referenced by E. This

function member is determined by applying the rules for determining the

most derived

implementation (?7.5.3) of M with respect to the run-time type of the

instance referenced by E.

?Otherwise, M is a non-virtual function member, and the function member to

invoke is M itself.

The function member implementation determined in the step above is invoked.

The object referenced by E

becomes the object referenced by this.

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