1. Delegates are objects that contain information about the function rather than data.
2. We can encapsulate a reference to the method inside the delegate object.
3. Delegates are type safe.
4. The return type and signature of delegates should be the same as the function
5.It is not necessary to use delegates with parameters; we can use delegates with parameters and without parameters.
6.We can use static or nonstatic functions; in the
case of static functions we encapsulate the function with the class name
and in the case of a nonstatic function we first make the object of the
class and then we use a function with the
object.
Example:
namespace Delegates
{
public delegate int mydelegate(int a,int b);
class Program
{
static void Main(string[] args)
{
mydelegate delObj = new mydelegate(abc.Sub);
abc delObj = new abc();
mydelegate delObj1= new mydelegate(obj.Add);
int a = delObj(4, 2);
int b = delObj1(4, 2);
Console.WriteLine("the result of ss is {0} and the result of ss1 is {1}", a, b);
}
}
class abc
{
public static int Sub(int i, int j)
{
return i * j;
}
public int Add(int x, int y)
{
return x + y;
}
}
}
Multicasting with Delegates
1. We can call more than one function using the delegate.
2. For this we use the operators "+=" and "-=".
3. We use "+=" to add a method in the invocation list and the "-=" operator to remove a method from the invocation list.
public delegate void my_multi_delegate(int x,int y);
//declaring a multi cast delegate with return type void
Multicasting Example:
mymultidelegate del = new mymultidelegate(abc.Add); //encapsulate the fun Add with the delegate
del += new mymultidelegate (abc.Sub); //adding fun Sub in the invocation list with the help of += operator
del += new mymultidelegate (abc.Mul); //adding fun Mul in the invocation list
del(4, 2);
//now we remove the function Add from the invocation lit with the help of -= operator
del -= new mymultidelegate (abc.ss); // Now in the invocation list 2 method namely Sub and Mul remains
Multicast Delegate Support Void Return:
Because they are multicast, calling more than one
method. Which return value would you use? How would you combine them
(that is, how would the framework combine them)?
You can't use ref or out arguments either, for the same reason.
still its achiveable through GetInvocationList();
but manually call each handler from the invocation list of the delegate invocation list. Here is the example on how to do it:
var list = delegateInstance.
foreach (var handler in list) {
DelegateName method = (DelegateName )handler;
int retValue = method("some parameter");
//do something with retValue...
}
Delegates system functions: Introduced in 3.5 Framework
Action is a delegate (pointer) to a method, that takes zero, one or more input parameters, but does not return anything.
list.Select(x => x.SomeProperty)
Func is a delegate (pointer) to a method, that takes zero, one or more input parameters, and returns a value (or refence).
Predicate is a special kind of Func often used for comparisons.
Though widely used with Linq, Action and Func are concepts logically independent of Linq.
