14.5.10.3 Delegate creation expressions

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]