Download source - 3.97 Kb
Features
- Delegate invoke instance method with parameter.
- Delegate invoke static method with parameter.
- Delegate multi-casting: delegate invoking more than one methods at once.
Instructions
Just compile and run the sample. The code is documented and is self-explanatory.
Concept/background
Delegate are just simple mechanism to re-route calls to functions/methods that it references. The idea is simple. Invoking delegate invokes the methods/functions that the delegate references. The question is, why delegate? Why not just invoke the function/method directly?
- The association between delegate and methods referenced by delegate is established in runtime - so, you get flexibility here.
- Multi-cast: That's to associate a few methods/functions to ONE delegate. Invoking one delegate fires off ALL methods referenced by that one delegate all at once.
Code fragments
Here's your delegate
Delegate - Note that delegate has the same signature to all functions/methods that it references.
A delegate can reference more than one function/method - that's called multi-casting.
public delegate int SomeDelegate(int nID, string sName);
Methods referenced by SomeDelegate can be found in WorkerClass
public class WorkerClass
{
//(1) First method (instance method) referenced by delegate:
public int InstanceMethod(int nID, string sName) {...}
//(2) Second method (static method) referenced by delegate:
static public int StaticMethod(int nID, string sName) {...}
};
The only difference between these two methods is that "InstanceMethod" is an instance method, that is, it must be invoked by an actual instance of WorkerClass. StaticMethod is a static member function - invoke it by: WorkerClass.StaticMethod(10,"aaa");
What the function does?
It will multiply "nID" by LENGTH of "sName". For example, nID=10, sName="aaa" (Length=3). Therefore return value=10x3=30.
It will write to console:
"InstanceMethod invoked, return value=..." OR"StaticMethod invoked, return value=..."
Association between delegates and methods it references can be found in main(...)
//PART 1: invoking instance method
WorkerClass wr = new WorkerClass();
SomeDelegate d1 = new SomeDelegate(wr.InstanceMethod);
//Associating delegate with wr.InstanceMethod
Console.WriteLine("Invoking delegate InstanceMethod, return={0}",
d1(5, "aaa") ); //Invoking wr.InstanceMethod with input parameters.
//PART 2: invoking static method
SomeDelegate d2 = new SomeDelegate(WorkerClass.StaticMethod);
//Associating delegate with WorkerClass.StaticMethod (NOTE: "wr"
//instance is NOT used. The class itself is used!!)
Console.WriteLine("Invoking delegate StaticMethod, return={0}",
d2(5, "aaa") ); //Invoking InstanceMethod with input parameters.
//PART 3: MultiCAST!
Console.WriteLine();
Console.WriteLine("Testing delegate multi-cast..");
SomeDelegate d3 = (SomeDelegate) Delegate.Combine(d1, d2);
Console.WriteLine("Invoking delegate(s) d1 AND d2 (multi-cast), return={0} ",
d3(5, "aaa") ); //Fire BOTH delegates (d1 AND d2) by firing d3!
Conclusion
That's it. It's simple right?