Introduction

Here we will see the BP of Delegates in C#.Net,

1. Basics of delegates

2. Power of delegates

Basics of delegates covers:

1. what is a delegate?

2. how to create a delegate?

3. what are the types of delegates?

Power of delegates covers

1. delegates as event handlers

2. delegates as function pointers

Background

we set up a simple console application before we start with delegates, so please create a console application and write the code as shown below

  1. class Program
  2. {
  3. static void Add()
  4. {
  5. int num1=90;
  6. int num2=10;
  7. Console.WriteLine("Sum:"+(num1+num2));
  8. }
  9. static void Main()
  10. {
  11. Add();
  12. Console.ReadLine();
  13. }
  14. }

Basics of delegates

1.what is a delegate?

meaning: delegate is a person who is authorized to represent others

1. delegate is a representative of method(according to the meaning)

2. delegates are like function pointers in C/C++ but are type safe(from msdn).

2.how to create a delegate?

we use "delegate" keyword to create delegate

we have to follow 3 steps to create a delegate

1. 1.declare a delegate

2. instantiate a delegate

3. invoke a delegate

1.declare a delegate: delegate can be declared inside the namespace or inside the class

do you know declaring abstract method, then it's easy to declare delegate as well

  1. syntax: [access modifier] delegate return_type delegate_name([parameters])
  2. example: public delegate void AddMethodHandler();

2.instantiate a delegate: it is the process of creating an object to delegate, which is similar to creating an object to a class with a single parameterized constructor.

  1. AddMethodHandler objAddDel=new AddMethodHandler(Add);

as we have instance class and static class,delegates also can be instance delegate and static delegate, so we have to instantiate a non static delegate.

3.invoke a delegate: it is the process of calling a delegate which is similar to method calling

  1. objAddDel();

3.What are the types of delegates?

delegates are 2 types

1. singlecast delegate

2. multicast delegate

1.siglecast delegate: if a delegate represents a single method then its called singlecast delegate, here we create a delegate that represents a single method

  1. //step1: declare a delegate
  2. public delegate void AddMethodHandler();
  4. class Program
  5. {
  6. static void Add()
  7. {
  8. int num1=90;
  9. int num2=10;
  10. Console.WriteLine("Sum:"+(num1+num2));
  11. }
  13. static void Main()
  14. {
  15. //step2:instantiate a delegate
  16. AddMethodHandler objAddDel=new AddMethodHandler(Add);
  17. //step3:invoke a delegate
  18. objAddDel();
  19. Console.ReadLine();
  20. }
  21. }

if we execute and test the application, we can observe that the Add method gets executed,hence we can say that delegate is representing method.

Note: return type and parameters of both(method and delegate) must be same.

2.multicast delegate: if a delegate represents two or more methods then it is called multicast delegate, we see how a single delegate represents two methods

  1. //step1: declaring a delegate inside namespace
  2. public delegate void AddMethodHandler();
  3. class Program
  4. {
  5. static void Add1()
  6. {
  7. double num1=90;
  8. double num2=10;
  9. Console.WriteLine("Sum:"+(num1+num2));
  10. }
  11. static void Add()
  12. {
  13. int num1=90;
  14. int num2=10;
  15. Console.WriteLine("Sum:"+(num1+num2));
  16. }
  18. static void Main()
  19. {
  20. //step2:instantiate a delegate
  21. AddMethodHandler objAddDel=new AddMethodHandler(Add);
  22. //make a delegate as multicast
  23. objAddDel+=Add1;
  24. //step3:invoke a delegate
  25. objAddDel();
  26. Console.ReadLine();
  27. }
  28. }

execute the above code and we can observe the execution of two methods. now we done with basics of delegates

Power of delegates

power of any feature lies in it's irreplacable situation(a situation where we can not proceed without the feature), so we see the following 2 situations are really very important to understand the power of delegates.

1.delegates as event handlers

Let’s understand with practical example, hope you create at least a single button in asp.net web application/ windows forms applications as shown below

We know that when we/user clicks on Submit button then btnSubmit_Click method gets executed, that’s correct but still there are 2 more things involved in between button and method. Those 2 things are

1. Event

2. Delegate

Now will see code flow and try to understand this relationship

Now we can understand that button control cannot react to the user interaction by invoking appropriate method without the help of Event(Click) and Delegate(EventHandler).

Note: EventHandler is a delegate created by Microsoft, now we have seen that delegate as an event handler.

2.delegates as function pointers

all of us know that usually we pass values as parameters to a method, assume in case if we have to pass method as parameter !

This is possible with function pointers in C/C++, we use delegate to achieve the same functionality in C#.Net

1.create a callback method: method with parameter(parameter is method)

2.pass method as parameter: pass a method as parameter to callback method

  1. class Program
  2. {
  3. //declaring a delegate inside a class
  4. public delegate void AddMethodHandler();
  6. static void Add()
  7. {
  8. int num1=90;
  9. int num2=10;
  10. Console.WriteLine("Sum:"+(num1+num2));
  11. }
  13. static void Main()
  14. {
  16. //calling callback method
  17. Calculate(Add);
  18. Console.ReadLine();
  19. }
  21. //callback method:a method that receives method as a parameter
  22. static void Calculate(AddMethodHandler objAddDel)
  23. {
  24. objAddDel();
  25. }
  26. }

Execute and test the output, we have learnt here delegate as a function pointer.

Well, we have learnt passing one type of method as parameter,what about rest of the types of methods?

Types of methods:

  1. without return type-without parameters
  2. without return type-with parameters
  3. with return type-without parameters
  4. with return type-with parameters

To represent these all types of methods Microsoft provided us delegates,it means that we need not to declare any delegate, directly use them for your work!

1. without return type-without parameters: to represent this type of methods we have a delegate with name “Action” with the following declaration.

  1. public delegate void Action();

Example using Action:

  1. class Program
  2. {
  3. static void Add()
  4. {
  5. int num1=90;
  6. int num2=10;
  7. Console.WriteLine("Sum:"+(num1+num2));
  8. }
  10. static void Main()
  11. {
  12. Calculate(Add);
  13. Console.ReadLine();
  14. }
  16. static void Calculate(Action objAddDel)
  17. {
  18. objAddDel();
  19. }
  20. }

2. without return type-with parameters: to handle this type of methods, we have 16 overloaded generic Action delegates.

Example using Action<in T1,int T2>:

  1. class Program
  2. {
  3. //without return type-with parameters
  4. static void Sub(int num1,int num2)
  5. {
  6. Console.WriteLine("Diff:"+(num1-num2));
  7. }
  9. static void Main()
  10. {
  11. Calculate(Sub);
  12. Console.ReadLine();
  13. }
  15. static void Calculate(Action<int,int> objSubDel)
  16. {
  17. objSubDel(90,10);
  18. }
  19. }

Note: Action<> delegate allows maximum of 16 parameters( all are input parameters only).

3.with return type-without parameters: Func delegate is used to handle these type of delegates.

  1. public delegate TResult Func<out TResult>();

Example using Func<out TResult>:

  1. class Program
  2. {
  3. //without return type-without parameters
  4. static int Div()
  5. {
  6. int num1=90;
  7. int num2=10;
  8. return num1/num2;
  9. }
  11. static void Main()
  12. {
  13. Calculate(Div);
  14. Console.ReadLine();
  15. }
  17. static void Calculate(Func<int> objDivDel)
  18. {
  19. int divResut=objDivDel();
  20. Console.WriteLine("Div:"+divResult);
  21. }
  22. }

4.with return type-with parameters: Func overloaded delegates with input and output parameters are used to represent these type of methods.

Example:

  1. class Program
  2. {
  3. //without return type-with parameters
  4. static int Mul(int num1,int num2)
  5. {
  6. return num1/num2;
  7. }
  9. static void Main()
  10. {
  11. Calculate(Mul);
  12. Console.ReadLine();
  13. }
  15. static void Calculate(Func<int,int,int> objMulDel)
  16. {
  17. int mulResut=objMulDel();
  18. Console.WriteLine("Mul:"+mulResult);
  19. }
  20. }

Note: Func<> delegate allows maximum of 16 input parameters out of 17 parameters, always the last parameter is out parameter.in case if it has only one parameter, then it is out parameter only.

Well done, we have seen all types of methods and available delegates, but still I want to introduce one more delegate which handle the following type of method.

boolean return type-single parameter:

  1. public delegate bool Predicate<in T>(T obj);

some times we have to return true/false from the method based on provided input,this delegate is useful in those scenarios.

Example:

  1. class Program
  2. {
  3. //with bool return type-with parameter
  4. static bool IsUpperCase(string value)
  5. {
  6. return value.Equals(value.ToUpper());
  7. }
  9. static void Main()
  10. {
  11. Test(IsUpperCase);
  12. Console.ReadLine();
  13. }
  15. static void Test(Predicate<string> obj)
  16. {
  17. bool result = obj("Hi");
  18. Console.WriteLine(result);
  19. }
  20. }

Here is the conclusion diagram for you

That's it for the article,please provide your valuable comments and feedback.