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.
