System.Delegate Class

Represents a delegate, which is a data structure that refers to a static method or to a class instance and an instance method of that class.

See Also: Delegate

Syntax

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Delegate : ICloneable, ISerializable

Remarks

The Delegate class is the base class for delegate types. However, only the system and compilers can derive explicitly from the Delegate class or from the MulticastDelegate class. It is also not permissible to derive a new type from a delegate type. The Delegate class is not considered a delegate type; it is a class used to derive delegate types.

Most languages implement a delegate keyword, and compilers for those languages are able to derive from the MulticastDelegate class; therefore, users should use the delegate keyword provided by the language.

Note:

The common language runtime provides an Invoke method for each delegate type, with the same signature as the delegate. You do not have to call this method explicitly from C#, Visual Basic, or Visual C++, because the compilers call it automatically. The Invoke method is useful in reflection when you want to find the signature of the delegate type.

The common language runtime provides each delegate type with BeginInvoke and EndInvoke methods, to enable asynchronous invocation of the delegate. For more information about these methods, see Calling Synchronous Methods Asynchronously.

The declaration of a delegate type establishes a contract that specifies the signature of one or more methods. A delegate is an instance of a delegate type that has references to:

  • An instance method of a type and a target object assignable to that type.

  • An instance method of a type, with the hidden this parameter exposed in the formal parameter list. The delegate is said to be an open instance delegate.

  • A static method.

  • A static method and a target object assignable to the first parameter of the method. The delegate is said to be closed over its first argument.

For more information on delegate binding, see the Delegate.CreateDelegate(Type,Object,MethodInfo,Boolean) method overload.

Note:

In the .NET Framework versions 1.0 and 1.1, a delegate can represent a method only if the signature of the method exactly matches the signature specified by the delegate type. Thus, only the first and third bullets in the preceding list are supported, and the first bullet requires an exact type match.

When a delegate represents an instance method closed over its first argument (the most common case), the delegate stores a reference to the method's entry point and a reference to an object, called the target, which is of a type assignable to the type that defined the method. When a delegate represents an open instance method, it stores a reference to the method's entry point. The delegate signature must include the hidden this parameter in its formal parameter list; in this case, the delegate does not have a reference to a target object, and a target object must be supplied when the delegate is invoked.

When a delegate represents a static method, the delegate stores a reference to the method's entry point. When a delegate represents a static method closed over its first argument, the delegate stores a reference to the method's entry point and a reference to a target object assignable to the type of the method's first argument. When the delegate is invoked, the first argument of the static method receives the target object.

The invocation list of a delegate is an ordered set of delegates in which each element of the list invokes exactly one of the methods represented by the delegate. An invocation list can contain duplicate methods. During an invocation, methods are invoked in the order in which they appear in the invocation list. A delegate attempts to invoke every method in its invocation list; duplicates are invoked once for each time they appear in the invocation list. Delegates are immutable; once created, the invocation list of a delegate does not change.

Delegates are referred to as multicast, or combinable, because a delegate can invoke one or more methods and can be used in combining operations.

Combining operations, such as Delegate.Combine(Delegate,Delegate) and Delegate.Remove(Delegate,Delegate), do not alter existing delegates. Instead, such an operation returns a new delegate that contains the results of the operation, an unchanged delegate, or null. A combining operation returns null when the result of the operation is a delegate that does not reference at least one method. A combining operation returns an unchanged delegate when the requested operation has no effect.

Note:

Managed languages use the Delegate.Combine(Delegate,Delegate) and Delegate.Remove(Delegate,Delegate) methods to implement delegate operations. Examples include the AddHandler and RemoveHandler statements in Visual Basic and the += and -= operators on delegate types in C#.

Starting with the net_v40_long, generic delegate types can have variant type parameters. Contravariant type parameters can be used as parameter types of the delegate, and a covariant type parameter can be used as the return type. This feature allows generic delegate types that are constructed from the same generic type definition to be assignment-compatible if their type arguments are reference types with an inheritance relationship, as explained in Covariance and Contravariance in Generics.

Note:

Generic delegates that are assignment-compatible because of variance are not necessarily combinable. To be combinable, the types must match exactly. For example, suppose that a class named Derived is derived from a class named Base. A delegate of type Action<Base> (Action(Of Base) in Visual Basic) can be assigned to a variable of type Action<Derived>, but the two delegates cannot be combined because the types do not match exactly.

If an invoked method throws an exception, the method stops executing, the exception is passed back to the caller of the delegate, and remaining methods in the invocation list are not invoked. Catching the exception in the caller does not alter this behavior.

When the signature of the methods invoked by a delegate includes a return value, the delegate returns the return value of the last element in the invocation list. When the signature includes a parameter that is passed by reference, the final value of the parameter is the result of every method in the invocation list executing sequentially and updating the parameter's value.

The closest equivalent of a delegate in C or C++ is a function pointer. A delegate can represent a static method or an instance method. When the delegate represents an instance method, the delegate stores not only a reference to the method's entry point, but also a reference to the class instance. Unlike function pointers, delegates are object oriented and type safe.

Example

Example1:

The following example creates two delegates. The first delegate invokes a static method, and the second invokes an instance method on a target object.

C# Example

using System;
public delegate string DelegatedMethod(string s);
class MyClass {
 public static string StaticMethod(string s) {
 return ("Static method Arg=" + s);
 }
 public string InstanceMethod(string s) {
 return ("Instance method Arg=" + s);
 }
}
class TestClass {
 public static void Main() {
 MyClass myInstance = new MyClass();
 //Create delegates from delegate type DelegatedMethod.
 DelegatedMethod delStatic = new DelegatedMethod(MyClass.StaticMethod); 
 DelegatedMethod delInstance = new DelegatedMethod(myInstance.InstanceMethod);
 //Invoke the methods referenced by the delegates.
 Console.WriteLine (delStatic("Call 1"));
 Console.WriteLine (delInstance ("Call 2"));
 }
}

The output is

Static method Arg=Call 1
Instance method Arg=Call 2

Example2:

The following example shows the return value and the final value of a parameter that is passed by reference to a delegate that invokes multiple methods.

C# Example

using System;
class MyClass {
 public int Increment(ref int i) {
   Console.WriteLine("Incrementing {0}",i);
   return (i++);
 }
 public int Negate(ref int i) {
   Console.WriteLine("Negating {0}",i);
   i = i * -1;
   return i;
 }
}

public delegate int DelegatedMethod(ref int i);
class TestClass {
 public static void Main() {
   MyClass myInstance = new MyClass();
   DelegatedMethod delIncrementer = new DelegatedMethod(myInstance.Increment);
   DelegatedMethod delNegater = new DelegatedMethod(myInstance.Negate);
   DelegatedMethod d = (DelegatedMethod) Delegate.Combine(delIncrementer, delNegater);
   int i = 1;
   Console.WriteLine("Invoking delegate using ref value {0}",i);
   int retvalue = d(ref i); 
   Console.WriteLine("After Invoking delegate i = {0} return value is {1}",i, retvalue);
  }
}

The output is

Invoking delegate using ref value 1
Incrementing 1
Negating 2
After Invoking delegate i = -2 return value is -2

Requirements

Namespace: System
Assembly: mscorlib (in mscorlib.dll)
Assembly Versions: 1.0.5000.0, 2.0.0.0, 4.0.0.0

The members of System.Delegate are listed below.

See Also: Object

Protected Constructors

Initializes a delegate that invokes the specified instance method on the specified class instance.

Initializes a delegate that invokes the specified static method from the specified class.

Public Properties

[read-only]
MethodMethodInfo.

Gets the method represented by the delegate.

[read-only]
TargetObject.

Gets the class instance on which the current delegate invokes the instance method.

Public Methods

Clone() : Object

Creates a shallow copy of the delegate.

static
Combine(params Delegate[]) : Delegate

Concatenates the invocation lists of an array of delegates.

static
Combine(Delegate, Delegate) : Delegate

Concatenates the invocation lists of two delegates.

static
CreateDelegate(Type, MethodInfo) : Delegate

Creates a delegate of the specified type to represent the specified static method.

static
CreateDelegate(Type, Object, MethodInfo) : Delegate

Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument.

static
CreateDelegate(Type, Object, String) : Delegate

Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

static
CreateDelegate(Type, MethodInfo, Boolean) : Delegate

Creates a delegate of the specified type to represent the specified static method, with the specified behavior on failure to bind.

static
CreateDelegate(Type, Type, String) : Delegate

Creates a delegate of the specified type that represents the specified static method of the specified class.

static
CreateDelegate(Type, Object, MethodInfo, Boolean) : Delegate

Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument and the specified behavior on failure to bind.

static
CreateDelegate(Type, Object, String, Boolean) : Delegate

Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance with the specified case-sensitivity.

static
CreateDelegate(Type, Type, String, Boolean) : Delegate

Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity.

static
CreateDelegate(Type, Object, String, Boolean, Boolean) : Delegate

Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance, with the specified case-sensitivity and the specified behavior on failure to bind.

static
CreateDelegate(Type, Type, String, Boolean, Boolean) : Delegate

Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity and the specified behavior on failure to bind.

DynamicInvoke(params Object[]) : Object

Dynamically invokes (late-bound) the method represented by the current delegate.

override
Equals(Object) : Boolean

Determines whether the specified object and the current delegate are of the same type and share the same targets, methods, and invocation list.

override
GetHashCode() : Int32

Returns a hash code for the delegate.

GetInvocationList() : Delegate[]

Returns the invocation list of the delegate.

GetObjectData(SerializationInfo, StreamingContext)

Not supported.

static
Remove(Delegate, Delegate) : Delegate

Removes the last occurrence of the invocation list of a delegate from the invocation list of another delegate.

static
RemoveAll(Delegate, Delegate) : Delegate

Removes all occurrences of the invocation list of a delegate from the invocation list of another delegate.

Protected Methods

CombineImpl(Delegate) : Delegate

Concatenates the invocation lists of the specified multicast (combinable) delegate and the current multicast (combinable) delegate.

DynamicInvokeImpl(Object[]) : Object

Dynamically invokes (late-bound) the method represented by the current delegate.

GetMethodImpl() : MethodInfo

Gets the static method represented by the current delegate.

RemoveImpl(Delegate) : Delegate

Removes the invocation list of a delegate from the invocation list of another delegate.

Public Operators

static
Equality(Delegate, Delegate)

Determines whether the specified delegates are equal.

static
Inequality(Delegate, Delegate)

Determines whether the specified delegates are not equal.