static void Main(string[] args)
{
SomeTimeLaterEvent += new SomeTimeLaterDelegate(AnswerAnotherDay);
SayHelloLaterEvent += new SayHelloDelegate(SayHello);
var eventsToRaise = new Queue <Action>();
eventsToRaise.Enqueue(() => SomeTimeLaterEvent.Invoke(100));
eventsToRaise.Enqueue(() => SayHelloLaterEvent.Invoke("Bob"));
eventsToRaise.Enqueue(() => SomeTimeLaterEvent.Invoke(200));
eventsToRaise.Enqueue(() => SayHelloLaterEvent.Invoke("John"));
while (eventsToRaise.Any())
{
var eventToRaise = eventsToRaise.Dequeue();
eventToRaise();
//or eventToRaise.Invoke();
}
Console.ReadLine();
}
public void KDelegateMain()
{
Console.WriteLine("Hello World :: KDelegateMain() !");
//06. lets create an instance of the class (LearnDelegates)
LearnDelegates objLearnDelegates = new LearnDelegates();
//07. Call the first method (addNumber)
objLearnDelegates.AddNumber(2, 4);
//08. now call the second method which is a static method
string name = LearnDelegates.SayHello("Rama");
Console.WriteLine(name);
//15. creating an instance of AddNumberDelegate
// when instanciating the delegate we need to pass the method name as parameter to the delegate
// check the intellisence it will tell as,
// a. a method name need to be passed
// b. the return type of the method is: void
// c. the method should take two integers as parameters
// intellisence: AddNumberDelegate(void (int, int) target)
// it is not mandatory that only AddNumber() method should be passed as parameter to this delegate
// any method can be passed to this delegate that has this return (void) and parameter type (taking two integers)
// can be passed to this delegate
// In the code when we type AddNumber as parameter to this delegate, there is no intellisence
// when there is no intellisence which means some thing is incorrect
// AddNumberDelegate objAddNumberDelegate = new AddNumberDelegate(AddNumber .. no intellisence
// reason: the method is non static method and we are creating it in static block of the delegate
// rule: a non static member of a class can never be accessed from a static block directly
// this can be accessed only by using instance of the class
// where is the non static method AddNumber(), it is inside/can be accessed from object of class LearnDelegate
// Object Name: objLearnDelegates
// AddNumberDelegate(objLearnDelegates.AddNumber) => this represents: delegate holds the address of the method
AddNumberDelegate objAddNumberDelegate = new AddNumberDelegate(objLearnDelegates.AddNumber);
// SayHello, is a static method hence we are able to call it directly using class name
SayHelloDelegate objSayHelloDelegate = new SayHelloDelegate(LearnDelegates.SayHello);
// this is the second step called as instanciating the delegate
//instanciating is the process of creating instance of the delegate, here we need to pass method name as
// parameter to the delegate constructor
//09. now lets run the program and we get the following output
/*
* Hello World!
* 6
* Hello Rama
*/
//10. till now we have been calling methods like this, now lets see how we can call
// methods by delegates
//11. to call a method by Delegate, we have three steps:
// (01) define a delegate
// <modifier> delegate void|type <name> ( <parameter List> )
// the above statement looks exactly similar to method signature, the extra word we are
// using is delegate (method signature and delegate will look exactly same)
// if we want to call the method (addNumber) using delegate
//
// => public void AddNumber(int a, int b)
//
// to the method name add the keyword delegate before return type
//
// => public delegate void AddNumber(int a, int b)
//
// method name and delegate name will not be the same hence give an appropriate
// name to the delegate, which is followed by semicolon
//
// => public delegate void AddNumberDelegate(int a, int b);
//
// Summary:
// --------
// => (method) public void AddNumber(int a, int b)
// => (delegate) public delegate void AddNumberDelegate(int a, int b);
//
// (a) when calling a delegate two important points to note, the return type of the delegate should
// exactly match the return type of the method (here its void)
//
// (b) the second is the parameters types of the delegate should exactly be the same type as parameters types of the
// delegate (here method is taking two integers and delegate is also taking two integers)
//
// => (method) public void AddNumber(int a, int b)
// => (delegate) public delegate void AddNumberDelegate(int x, int y);
//
// the parameter name can be any thing, it does not matter. it can be a and b in method where as
// x and y delegates, what matters is the type which is <int>, <int>
//
// Now lets try to define delegate for the second method SayHello
//
// => (method) public static string SayHello(string name)
// => (delegate) public static string SayHello(string name);
//
// In delegate no need to use they keyword static (we never use static on a delegate)
//
// => (method) public static string SayHello(string name)
// => (delegate) public delegate string SayHelloDelegate(string name);
// => (delegate) public delegate string SayHelloDelegate(string userName);
//
// Here the return type of the delegate is string because the method return type is string
// the parameter type of the delegate is string because method parameter is also string
//
// (imp) the delegate type (return and parameter types) should exactly match with method type
// that is the reason we say, a delegate is type safe function pointer
// because delegate signature is going to match with method signature
//
// delegate is a type:
// a class is a type (user defined type)
// a structure is a type (user defined type)
// an interface is a type (user defined type)
// all these are user defined types
//
// similar to (class, struct and interface) delegate is also a user defined type
//
// the main difference between class and structure is:
// (a) class is reference type
// (b) struct is value type
// the same way
// (c) delegate is also a reference type
//
// In c# types are defined under namespace, for eg. every class we define/create is under namespace
// this class (LearnDelegates) is under the namespace (namespace PP.BR.DP1)
// not only class, everything structure, interface etc will be under a namespace
//
// (imp) this is because namespace is a logical container of types, that is the reason we define all the
// types under a namespace
// Now the question is where should we define, the delegate the answer is it should be under a namespace
//
// Now lets define the delegate below the namespace
//14. the second step in delegate is
// (01) instanciating the delegate
//
// it is like creating an instance of delegate, because delegate is a reference type
// (imp) when instanciating the delegate we need to pass the method name as parameter to the delegate
//
// now lets create an instance (line #57) of the AddNumberDelegate which is defined in line #7
//
//16. finally the third step is: call the delegate by passing required parameter values, so that
// internally the method which is bound with the delegate gets executed
//
// we need to call the method AddNumber which we will not call it directly, we will call using delegate
// when we call the delegate objAddNumberDelegate(.. it ask for two integer parameters
// objAddNumberDelegate(int dataA, int dataB)
objAddNumberDelegate(100, 50);
// now call the other delegate
string returnInformation = objSayHelloDelegate("raju");
Console.WriteLine(returnInformation);
// what happens internally, when we call the delegate the method will get executed, (it is not delegate,
// delegate is just pointer to a method)
// when ever we call the delegate the pointer comes to method and method gets execuite
//
// Calling via delegate and calling direclty will get the same output
// Op:
// ---
// Hello World!
// 6
// Hello Rama
// 150
// Hello raju
//17. the other way to call a delegate is .invoke
// so delegate has a method call invoke, this invoke accepts two parameters for us: (int dataA, int dataB)
objAddNumberDelegate.Invoke(100, 50);
objSayHelloDelegate.Invoke("bangaru");
//we can use any of the two ways, it is the same output
//
/* happy learning: part2 Multicast Delegates */
Console.ReadLine();
}
public void activateSayHelloDelegate(String name)
{
sayHelloDelegate?.Invoke(name);
}