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 (14.1) or a value of a delegate-type. 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 (22.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 simple-name 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 (22.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 (11.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. 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]