A delegate provides a way to encapsulate
a method. It is an object that can refer to a method and can invoke the method
to which it refers.
Delegates provide a built-in,
language-supported mechanism for defining and executing callbacks. It provides
an excellent mechanism to decouple the method being called from the actual
caller. In fact, the caller of the delegate has no idea whether it is calling
an instance method or a static method. To the caller, it is
calling arbitrary code.
The principal advantage of a delegate is that the
method that will be invoked by a delegate is not determined at compile time,
but rather at runtime.
A delegate dynamically wires up a
method caller to its target method. There are two aspects to a delegate: type
and instance.
A delegate type defines a protocol
to which the caller and target will conform, comprising a list of parameter
types and a return type. A delegate instance is an object that refers to
one or more target methods conforming to that protocol.
Delegate declarations look almost
exactly like abstract method declarations, except for
the delegate keyword. Ex:
public delegate double ComputeOutput(
int iValueX, int iValueY );
When you instantiate an instance of
a delegate, you must wire it up to a method to call when it is invoked. The
method that you wire it up to could be either a static or an instance method
that has a signature compatible with that
of the delegate.
Thus, the parameter types and the
return type must either match the delegate declaration or be implicitly
convertible to the types in the delegate declaration.
using System;
public delegate double ComputeOutput(
int iValueX, int iValueY ); // Delegate
declaration
public class Computer
{
public Computer
( double dFactor ) // Constructor
{
this.dFactor = dFactor;
}
public double ComputeInstance( int iValueX, int
iValueY ) // instance method
{
double dResult = (iValueX + iValueY) * dFactor;
Console.WriteLine( "Instance Results:
{0}", dResult );
return dResult;
}
public static double ComputeStatic( int iValueX,
int iValueY ) // static method
{
double dResult = (iValueX + iValueY) * 0.5;
Console.WriteLine( "Static Result:
{0}", dResult );
return dResult;
}
private double dFactor;
}
public class MyComputer
{
static void Main()
{
Computer oComputer1 = new Computer( 0.69 );
Computer oComputer2 = new Computer( 0.76 );
ComputeOutput delegate1 = new ComputeOutput
(oComputer1.ComputeInstance );
ComputeOutput delegate2 = new ComputeOutput
(oComputer2.ComputeInstance );
// points to a
static method - use method group conversion
ComputeOutput delegate3 = Computer.ComputeStatic;
double dTotal = delegate1( 7, 8 ) +
delegate2( 9, 2 ) + delegate3( 4, 3 );
Console.WriteLine( "Output: {0}",
dTotal );
}
}
Method Group Conversion allows you to simply assign the name of a method to a
delegate, without using new or explicitly invoking the delegate’s
constructor.
Computer.StaticCompute is actually
called a method group because the method could be overloaded and this
name could refer to a group of methods. In this case, the method group Computer.StaticCompute
has one method in it.
C#
allows you to directly assign a delegate from a method group. When you create
the delegate instances via new, you pass the method group in the constructor.
Introduction to Delegates
