A
delegate is a type-safe object that can point to another method (or
possibly multiple methods) in the application, which can be invoked at
later time.
Delegates
also can invoke methods Asynchronously
.
A delegate
type maintains three important pices of information :
- The
name of the method on which it make calls.
- Any argument
(if any) of this method.
- The return value (if any) of this method.
Defining a Delegate in C#
when you
want to create a delegate in C# you make use of delegate keyword.
The
name of your delegate can be whatever you desire. However, you must
define the delegate to match the signature of the method it will point
to. fo example the following delegate can point to any method taking two
integers and returning an integer.
public delegate int
DelegateName(int x, int y);
A Delegate Usage Example
namespace MyFirstDelegate
{
//This delegate can point to any method,
//taking two integers and returning an
//integer.
public delegate int MyDelegate (int x, int y);
//This class contains methods that MyDelegate will point to.
public class MyClass
{
public static int Add(int x, int y)
{
return x + y;
}
public static int Multiply(int x, int y)
{
return x * y;
}
}
class Program
{
static void Main(string [] args)
{
//Create an Instance of MyDelegate
//that points to MyClass.Add().
MyDelegate del1 = new MyDelegate (MyClass .Add);
//Invoke Add() method using the delegate.
int addResult = del1(5, 5);
Console .WriteLine("5 + 5 = {0}/n" , addResult);
//Create an Instance of MyDelegate
//that points to MyClass.Multiply().
MyDelegate del2 = new MyDelegate (MyClass .Multiply);
//Invoke Multiply() method using the delegate.
int multiplyResult = del2(5, 5);
Console .WriteLine("5 X 5 = {0}" , multiplyResult);
Console .ReadLine();
}
}
}
Delegate ability
to Multicast
Delegate's ability to multicast means that a
delegate object can maintain a list of methods to call, rather than a
single method
if you want to add a method to the invocation list of a
delegate object , you simply make use of the overloaded += operator,
and if you want to remove a method from the invocation list you make use
of the overloaded operator -= .
Note:
The
Multicast delegate here contain methods that return void, if
you want to create a multicast delegate with return type you will get
the return type of the last method in the invocation list.
A Multicast
Delegate Example
namespace MyMulticastDelegate
{
//this delegate will be used to call more than one
//method at once
public delegate void MulticastDelegate (int x, int y);
//This class contains methods that MyDelegate will point to.
public class MyClass
{
public static void Add(int x, int y)
{
Console .WriteLine("You are in Add() Method" );
Console .WriteLine("{0} + {1} = {2}/n" , x, y, x + y);
}
public static void Multiply(int x, int y)
{
Console .WriteLine("You are in Multiply() Method" );
Console .WriteLine("{0} X {1} = {2}" , x, y, x * y);
}
}
class Program
{
static void Main(string [] args)
{
//Create an Instance of MulticastDelegate
//that points to MyClass.Add().
MulticastDelegate del = new MulticastDelegate (MyClass .Add);
//using the same instance of MulticastDelegate
//to call MyClass.Multibly() by adding it to it's
//invocation list.
del += new MulticastDelegate (MyClass .Multiply);
//Invoke Add() and Multiply() methods using the delegate.
//Note that these methods must have a void return vlue
Console .WriteLine("****calling Add() and Multibly() Methods.****/n/n" );
del(5, 5);
//removing the Add() method from the invocation list
del -= new MulticastDelegate (MyClass .Add);
Console .WriteLine("/n/n****Add() Method removed.****/n/n" );
//this will invoke the Multibly() method only.
del(5, 5);
}
}
}
Delegate
Covariance
Assume you are designing a delegate that can
point to methods returning a custom class type:
//Define
a delegate pointing to methods returning Employee types.
public
delegate
Employee EmployeeDelegate
();
if you were
to derive a new class from Employee Type named SalesEmployee and wish
to create a delegate type that can point to methods returning this class
type you would be required to define an entirely new delegate to do so
//a new delegate pointing to methods returning SalesEmployee types.
public
delegate
SalesEmployee SalesEmployeeDelegate
();
Example
namespace MyEmployeesDelegate
{
//Define a delegate pointing to methods returning Employee types.
public delegate Employee EmployeeDelegate ();
//a new delegate pointing to methods returning SalesEmployee types.
public delegate SalesEmployee SalesEmployeeDelegate ();
class Program
{
public static Employee GetEmployee()
{
return new Employee ();
}
public static SalesEmployee GetSalesEmployee()
{
return new SalesEmployee ();
}
static void Main(string [] args)
{
EmployeeDelegate empDel = new EmployeeDelegate (GetEmployee);
Employee emp = empDel();
SalesEmployeeDelegate salesEmpDel = new SalesEmployeeDelegate (GetSalesEmployee);
SalesEmployee emp2 = salesEmpDel();
}
}
public class Employee
{
protected string firstName;
protected string lastName;
protected int Age;
public Employee()
{ }
public Employee(string fName, string lName, int age)
{
this .firstName = fName;
this .lastName = lName;
this .Age = age;
}
}
public class SalesEmployee : Employee
{
protected int salesNumber;
public SalesEmployee()
{ }
public SalesEmployee(string fName, string lName, int age, int sNumber) : base (fName, lName, age)
{
this .salesNumber = sNumber;
}
}
}
It would be
ideal to build a single delegate type that can point to methods
returning either Employee or SelesEmployee types.
Covariance allows
you to build a single delegate that can point to methods returning class
types related by classical inheritance.
Delegate
Covariance Example
namespace DelegateCovariance
{
//Define a single delegate that may return an Employee
// or SalesEmployee
public delegate Employee EmployeeDelegate ();
class Program
{
public static Employee GetEmployee()
{
return new Employee ();
}
public static SalesEmployee GetSalesEmployee()
{
return new SalesEmployee ();
}
static void Main(string [] args)
{
EmployeeDelegate emp = new EmployeeDelegate (GetEmployee);
Employee emp1 = emp();
EmployeeDelegate empB = new EmployeeDelegate (GetSalesEmployee);
//to obtain a derived type you must perform an explicit cast.
SalesEmployee emp2 = (SalesEmployee )empB();
}
}
public class Employee
{
protected string firstName;
protected string lastName;
protected int Age;
public Employee()
{ }
public Employee(string fName, string lName, int age)
{
this .firstName = fName;
this .lastName = lName;
this .Age = age;
}
}
public class SalesEmployee : Employee
{
protected int salesNumber;
public SalesEmployee()
{ }
public SalesEmployee(string fName, string lName, int age, int sNumber) : base (fName, lName, age)
{
this .salesNumber = sNumber;
}
}
}
I hope you are now have a
good idea with the creation and usage of delegates types.
Now you
are ready to know about events
in C#