Delegates are a mechanism of indirectly calling methods at runtime. The primary use of delegates in C# programming is for implementing events and the call-back methods.

Important Points About Delegate

Types of Delegate

There are two types of delegate.

Note

Generics are a kind of parameterized data structure that can work with value type as well as reference type. Using generics we can define the data type at runtime using System.Collections.Generic namespace.

Syntax

< public delegate return Type(void/string) delegate_Name (); >

Or

< public delegate return Type(void/string) delegate_Name <T> (); >

Example

Single Cast Non-Generic/Generic Delegate,

  1. namespace Demo_Delegate
  2. {
  4. class Single_Cast
  5. {
  7. //Declare Non-Generic Single cast delegate
  8. public delegate void Single_Cast_delegate();
  10. //Private Method to be called
  11. private static void message()
  12. {
  13. Console.WriteLine("This Example of Single Cast Non-generic Delegate");
  14. }
  15. static void Main(string[] args)
  16. {
  17. //Instance created for Single Cast Delagate
  18. Single_Cast_delegate SCD = new Single_Cast_delegate(message);
  20. //Instance created for Single Cast Generic Delagate
  21. Single_Cast_Generic SCG = new Single_Cast_Generic();
  22. Mydel<int> my1 = new Mydel<int>(SCG.add);
  23. Mydel<string> my2 = new Mydel<string>(SCG.Myname);
  25. //Calling of Delegate
  26. SCD();
  27. my1(10, 20);
  28. my2("My", "Name");
  29. }
  31. }
  33. //Declare Generic Single cast delegate
  34. public delegate void Mydel<T>(T a, T b);
  35. class Single_Cast_Generic
  36. {
  37. public void add(int a, int b)
  38. {
  39. int Sum = a + b;
  40. Console.WriteLine(Sum);
  42. }
  44. public void Myname(string firstname, string lastname)
  45. {
  46. string fn = firstname + " " + lastname;
  47. Console.WriteLine(fn);
  49. }
  50. }
  51. }
Multicast Non-Generic/Generic Delegate,
  1. namespace Demo_Delegate
  2. {
  3. class MyClass
  4. {
  5. static void Main(string[] args)
  6. {
  7. //Instance created for Muticaste Cast Delagate
  8. MultiCast_delegate md = new MultiCast_delegate();
  9. NonGenericMulticaste NGM = new NonGenericMulticaste(md.FirstMessage);
  11. // Add another method to the invocation list
  12. NGM += new NonGenericMulticaste(md.SecondMessage);
  13. NGM("Call Mutliple methods using single Object");
  16. //Instance created for MultiCast Generic Delagate
  17. MultiCast_Genericdelegate MG = new MultiCast_Genericdelegate();
  19. //We can call both method having diffrent type with single delegate
  20. GenericMulticaste<int> obj1 = new GenericMulticaste<int>(MG.FirstMessage);
  21. obj1 += new GenericMulticaste<int>(MG.Message);
  23. GenericMulticaste<string> obj2 = new GenericMulticaste<string>(MG.SecondMessage);
  24. obj2 += new GenericMulticaste<string>(MG.SecondMessage);
  26. obj1(100);
  28. obj2("Call Mutliple Generic methods using single Object");
  32. }
  33. }
  34. //Create a multicate Delegate
  35. public delegate void NonGenericMulticaste(string Message);
  36. class MultiCast_delegate
  37. {
  38. public void FirstMessage(string Message1)
  39. {
  40. Console.WriteLine(Message1);
  41. }
  42. public void SecondMessage(string Message2)
  43. {
  44. Console.WriteLine(Message2);
  45. }
  46. }
  47. //Create a multicate Generic Delegate
  48. public delegate void GenericMulticaste<T>(T Message);
  49. class MultiCast_Genericdelegate
  50. {
  51. public void FirstMessage(int Number)
  52. {
  53. Console.WriteLine("Your Number is:"+Number);
  54. }
  55. public void Message(int Number)
  56. {
  57. Console.WriteLine("Your Number is:" + Number);
  58. }
  59. public void SecondMessage(string Generic_Message)
  60. {
  61. Console.WriteLine(Generic_Message);
  62. }
  63. public void Second(string Generic_Message)
  64. {
  65. Console.WriteLine(Generic_Message);
  66. }
  67. }
  68. }
Following are the predefined generic delegates,
  1. public delegate TResult Func<in T, out TResult>(T arg);
  2. public delegate void Action()
  3. public delegate bool Predicate<in T>(T obj);
Example
  1. namespace PreDefinedGenericDelegates
  2. {
  3. class Program
  4. {
  5. static void Main(string[] args)
  6. {
  7. //Action Delegate
  8. Action<int,int> a = new Action<int,int>(MyClass.sum);
  9. a(5, 6);
  10. Action<string, string> b = new Action<string, string>(MyClass.add);
  11. b("Kundan", "Jha");
  13. //Func Delegate
  15. Func<int, int, int> ds = new Func<int, int, int>(MyClass.Multi);
  16. Console.WriteLine(ds(45, 65));
  18. //Predicate Delegate
  19. Predicate<string> p = new Predicate<string>(MyClass.IsDate);
  20. if (p("01-01-2015"))
  21. {
  22. Console.WriteLine("Valid");
  23. }
  24. else
  25. {
  26. Console.WriteLine("Invalid");
  27. }
  29. Console.ReadKey();
  31. }
  32. }
  34. class MyClass
  35. {
  36. public static bool IsDate(string date)
  37. {
  38. DateTime dt;
  39. return DateTime.TryParse(date, out dt);
  40. }
  42. public static int Multi(int a, int b)
  43. {
  44. return a + b;
  45. }
  46. public static void sum(int num1, int num2)
  47. {
  48. int sum = num1 + num2;
  49. Console.WriteLine(sum);
  51. }
  52. public static void add(string fname, string lname)
  53. {
  54. string fullname = fname + " " + lname;
  55. Console.WriteLine(fullname);
  56. }
  57. }
  58. }
I hope you liked this article. Thank You.