14.5.10.3 Delegate creation expressions

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

A delegate-creation-expression is used to create a new instance of a

delegate-type.

delegate-creation-expression:

new delegate-type ( expression )

The argument of a delegate creation expression must be a method group (?4.1)

or a value of a delegatetype.

If the argument is a method group, it identifies the method and, for an

instance method, the object for

which to create a delegate. If the argument is a value of a delegate-type,

it identifies a delegate instance of

which to create a copy.

The compile-time processing of a delegate-creation-expression of the form

new D(E), where D is a

delegate-type and E is an expression, consists of the following steps:

?If E is a method group:

The set of methods identified by E must include exactly one method that is

compatible (?2.1) with D, and

this method becomes the one to which the newly created delegate refers. If

no matching method exists, or if

more than one matching method exists, a compile-time error occurs. If the

selected method is an instance

method, the instance expression associated with E determines the target

object of the delegate.

As in a method invocation, the selected method must be compatible with the

context of the method group: If

the method is a static method, the method group must have resulted from a

simple-name or a member-access

through a type. If the method is an instance method, the method group must

have resulted from a simplename

or a member-access through a variable or value. If the selected method does

not match the context of

the method group, a compile-time error occurs.

The result is a value of type D, namely a newly created delegate that

refers to the selected method and target

object.

?Otherwise, if E is a value of a delegate-type:

D and E must be compatible (?2.1); otherwise, a compile-time error occurs.

The result is a value of type D, namely a newly created delegate that

refers to the same invocation list as E.

?Otherwise, the delegate creation expression is invalid, and a

compile-time error occurs.

The run-time processing of a delegate-creation-expression of the form new

D(E), where D is a delegate-type

and E is an expression, consists of the following steps:

?If E is a method group:

If the method selected at compile-time is a static method, the target

object of the delegate is null.

Otherwise, the selected method is an instance method, and the target object

of the delegate is determined

from the instance expression associated with E:

?The instance expression is evaluated. If this evaluation causes an

exception, no further steps are

executed.

?If the instance expression is of a reference-type, the value computed by

the instance expression

becomes the target object. If the target object is null, a

System.NullReferenceException

is thrown and no further steps are executed.

?If the instance expression is of a value-type, a boxing operation (?1.3.1)

is performed to

convert the value to an object, and this object becomes the target object.

A new instance of the delegate type D is allocated. If there is not enough

memory available to allocate the

new instance, a System.OutOfMemoryException is thrown and no further steps

are executed.

C# LANGUAGE SPECIFICATION

150

The new delegate instance is initialized with a reference to the method

that was determined at compile-time

and a reference to the target object computed above.

?If E is a value of a delegate-type:

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

are executed.

If the value of E is null, a System.NullReferenceException is thrown and no

further steps are

executed.

A new instance of the delegate type D is allocated. If there is not enough

memory available to allocate the

new instance, a System.OutOfMemoryException is thrown and no further steps

are executed.

The new delegate instance is initialized with references to the same

invocation list as the delegate instance

given by E.

The method and object to which a delegate refers are determined when the

delegate is instantiated and then

remain constant for the entire lifetime of the delegate. In other words, it

is not possible to change the target

method or object of a delegate once it has been created. [Note: Remember,

when two delegates are

combined or one is removed from another, a new delegate results; no

existing delegate has its content

changed. end note]

It is not possible to create a delegate that refers to a property, indexer,

user-defined operator, instance

constructor, destructor, or static constructor.

[Example: As described above, when a delegate is created from a method

group, the formal parameter list

and return type of the delegate determine which of the overloaded methods

to select. In the example

delegate double DoubleFunc(double x);

class A

{

DoubleFunc f = new DoubleFunc(Square);

static float Square(float x) {

return x * x;

}

static double Square(double x) {

return x * x;

}

}

the A.f field is initialized with a delegate that refers to the second

Square method because that method

exactly matches the formal parameter list and return type of DoubleFunc.

Had the second Square method

not been present, a compile-time error would have occurred. end example]

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