Creating delegate, actually creating an object that can hold a reference to a method.

Transcription

1 Delegates A delegate is an object that can refer to a method. Creating delegate, actually creating an object that can hold a reference to a method. The method can be called through this reference. A delegate can invoke the method to which it refers. Same delegate can be used to call different methods during runtime of a program by simply changing the method to which the delegate refers. thus, the method that will be invoked by a delegate is not determined at compile time but rather run time. This is the principal i advantage of a delegate. 266

2 Syntax of a delegate declaration: delegate ret-type name (parameter-list) ret-type type is the type of the value returned by the methods that the delegate will be calling. The parameters required by the methods called through the delegate are specified in the parameter-list. t Once created, a delegate instance can refer to and call methods whose return type and parameter-list match those specified in the delegate declaration. A delegate can be used to call any method that agrees with its signature and return type. The method can be either an instance method associated with an object or a static method associated with a class. All that matters is that the return type and signature of the method agrees with those of the delegate. 267

3 A Delegate is a special user defined type that is declared globally, ll like a class. Created like an interface, it provides a template for a method. Like interface, a delegate is not defined. Its role is to show what a useful method would look like. Delegates can be specified in their own namespace, or else can be specified within another class. Each delegate is limited to referencing methods of a particular kind only. Function Pointers of C & C++ Delegates in.net Framework Callback functions of Microsoft Win32 Library Programming 268

4 Delegates in action using System; //declaring a delegate type. delegate string StrMod(string str); Class DelegateTest { //replaces space with hyphens. static string ReplaceSpaces(string s) { Console.WriteLine( Replacing spaces with hyphens. ); return s.replace(, - ); //remove spaces. static string RemoveSpaces(string s) { string temp = ; int i; Console.WriteLine( Removing Spaces. ); for ( i=0; i < s.length ; i++) if(s[i]!= ) temp += s[i]; return temp; //reverse a string. static string reverse(string s) { string ti temp = ; int i, j; Console.WriteLine( Reversing the string. ); 269

5 for (j=0, i = s.length-1; i>=0; i--, j++) temp += s[i]; return temp; static void Main() { //Construct a delegate. StrMod strop = new StrMod (ReplaceSpaces ); string str; //call methods through the delegates. str = strop( This is a test. ); Console.WriteLine( Resulting String: + str); strop = new StrMod ( RemoveSpaces ); str = strop( This is a test. ); Console.WriteLine( Resulting String: + str); strop = new StrMod ( reverse ); str = strop( This is a test. ); Console.WriteLine( Resulting String: + str); 270

6 The output of this program is: Replacing spaces with hyphens. Resulting String: This-is-a-test. Removing spaces. Resulting String: Thisisatest. i t Reversing the string. Resulting String:.tset a si siht 271

7 The program declares a delegate type called StrMod as delegate string StrMod(string str); StrMod takes one string parameter and returns a string. In DelegateTest class, three static methods are declared, each with a single parameter of type string and a return type of string. Thus they match the StrMod delegate. In Main(), a StrMod reference called strop is created. {delegate instantiation and assigned a reference to ReplaceSpaces(). StrMod strop = new StrMod (ReplaceSpaces ); Only name is used while passing the function name to the delegate instance, no parameters are specified. While instantiating a delegate, you specify only the name of the method to which you want the delegate to refer. Of course, the method signature must match that of the delegate s declaration. If it doesn t, a compile-time error will result. 272

8 Next, ReplaceSpaces() is called through the delegate instance strop, as str = strop( This is a test. ); Because strop refers to ReplaceSpaces(), ReplaceSpaces() is invoked. Next, strop is assigned reference to RemoveSpaces(), and then strop is called again. strop = new StrMod ( RemoveSpaces ); str = strop( This is a test. ); Finally, strop is assigned a reference to reverse() and strop is called. This results in reverse() being invoked. strop = new StrMod ( reverse ); str = strop( This is a test. ); The key point is invocation of strop results into a call of the method referred to by strop at the time at which the invocation occurs. Thus, the method to call is resolved at runtime, not compile time. 273

9 Use of Delegate static methods. using System; //delegate declaration delegate int Operation(int t x, int y); Class MathOpr { public static int Add (int a, int b) Class Test { {returna+b; public static int Sub (int a, int b) { return a-b; public static int Mul (int a, int b) { return a*b; public static void Main() { //delegate instantiation Operation Opr1 = new Operation (MathOpr.Add); Operation Opr1 = new Operation (MathOpr.Sub); Operation Opr1 = new Operation (MathOpr.Mul); //invoking of delegates int ans1 = Opr1(200,100); 100); int ans2 = Opr2(200,100); int ans3 = Opr3(20,10); Console.WriteLine( Addition : + ans1); Console.WriteLine( Subtraction : + ans2); Console.WriteLine( Multiplication : + ans3); 274

10 Use of Delegate instance methods. //delegates can refer to instance methods too. using System; //declaring a delegate type. delegate string StrMod(string str); Class StringOps { //replaces space with hyphens. public string ReplaceSpaces ( string s ) { Console.WriteLine( Replacing spaces with hyphens. ); return s.replace(, - ); //remove spaces. public string RemoveSpaces ( string s ) { string temp = ; int i; Console.WriteLine( Removing Spaces. ); for ( i=0; i < s.length ; i++) if(s[i]!= ) temp += s[i]; return temp; //reverse a string. public string reverse ( string s ) { string temp = ; int i, j; Console.WriteLine( Reversing the string. ); 275

11 for (j=0, i = s.length-1; i>=0; i--, j++) temp += s[i]; return temp; Class DelegateTest { static void Main() { StringOps so = new StringOps(); // creating an instance of class StringOps //Initialize a delegate StrMod strop = so.replacespaces; string str; //call methods through the delegates. str = strop( This is a test. ); Console.WriteLine( Resulting String: + str); strop = so.removespaces; str = strop( This is a test. ); Console.WriteLine( Resulting String: + str); strop = so.reverse; str = strop( This is a test. ); Console.WriteLine( Resulting String: + str); 276

12 The output of this program is: This program produces the same output as the first one, but in this case, the delegate refers to the methods on an instance of StringOps class. Replacing spaces with hyphens. Resulting String: This-is-a-test. Removing spaces. Resulting String: Thisisatest. Reversing the string. Resulting String:.tset a si siht 277

13 Multicasting / Multicast Delegates One of the most exciting features of a delegate is it support for multicasting. Multicasting is the ability to create and invocation list, or chain, of methods that will be automatically called when a delegate is invoked. Process: Instantiate a delegate Use the + or += operator to add methods to the chain Use the or -= operator to remove a method from the chain. If the delegate returns a value, then the value returned by the last method invoked in the list becomes the return value of the entire delegate invocation. A delegate that makes use of multicasting will often have a void return type. 278

14 Use of Multicast Delegates Example 1 using System; delegate void MultiCDel(); class MD { class Test { static public void Hello() { Console.WriteLine ( Hello ) ; static public void Show() { Console.WriteLine ( Hi ) ; public static void Main() { //delegate instances MultiCDel M1 = new MultiCDel (MD.Hello); MultiCDel M2 = new MultiCDel (MD.Show); //combine the delegates MultiCDel M3 = M1 + M2; MultiCDel M4 = M2 + M1; //extracting the delegates MultiCDel M5 = M3 - M2; MultiCDel M6 = M4 M1; //invoking delegates M3(); M4(); M5(); M6(); Output: Hello Hi Hi Hello Hello Hi 279

15 Use of Multicast Delegates Example 2 using System; delegate void StrMod(ref string str); Class MultiCastDemo td { //replaces space with hyphens. static void ReplaceSpaces (ref string s ) { Console.WriteLine( WriteLine( Replacing spaces with hyphens. ); s = s.replace(, - ); //remove spaces. static void RemoveSpaces (ref string s ) { string temp = ; int i; Console.WriteLine( Removing Spaces. ); for ( i=0; i < s.length ; i++) if(s[i]!= ) temp += s[i]; s= temp; //reverse a string. static void reverse (ref string s ) { string temp = ; int i, j; Console.WriteLine( Reversing the string. ); 280

16 for (j=0, i = s.length-1; i>=0; i--, j++) temp += s[i]; s = temp; static void Main() { //Construct delegates. StrMod strop; StrMod replacesp = ReplaceSpaces; StrMod removesp = RemoveSpaces; StrMod reversestr = reverse; string str = This is a test. ; //set up Multicast. strop = replacesp; strop += reversestr; //Call Multicast. strop(ref str); Console.WriteLine( Resulting String: + str); //remove replace and add remove. strop -= replacesp; strop to += removesp; str = This is a test. ; // reset string //call Multicast. strop (ref str); Console.WriteLine( Resulting String: + str); 281

17 The output of this program is: Replacing spaces with hyphens. Reversing the String. Resulting String:.tset a si siht Reversing the String. Removing spaces. Resulting String:.tsetasisihT 282

18 System.Delegate All delegates are classes that are implicitly derived from System.Delegate. Why Delegates? First, delegates support events. Second, delegates give programs a way to execute methods at runtime without having to know precisely what those methods are at compile time. 283

19 Partial contextual t keyword Started with C# 2.0 A class, structure or interface definition can be broken into two or more pieces, with each piece residing in separate files. When program is compiled, the pieces are united. partial class XY { public XY(int a, int b) { X=a; Y=b; xy1.cs partial class XY { public int X { get; set; xy2.cs partial class XY { public int Y { get; set; xy3.cs using System; // demonstrating the use of partial class definitions class Test { static void Main() { XY xy = new XY(1,2); Console.WriteLine(xy.X +, + xy.y); to compile Test: csc test.cs xy1.cs xy2.cs xy3.cs 284

20 Partial methods Started with C# 3.0, creating Partial Methods. Declaration in one part & implementation in another. Key aspect of a partial method is that the implementation is not required. When a partial method is not implemented by another part of the class or structure, then all calls to the partial method are silently ignored. //Demonstrate a partial method. using system; partial class XY (int a, int b) { X=a; Y=b; //Declare a partial method. 285

21 partial void Show(); partial class XY { public int X{ get; set; //Implement a partial method. partial void Show() { Console.WriteLine( {0,{1, X,Y; partial class XY { public int Y {get; set; //call a partial method. public void ShowXY() { Show(); class Test { static void Main() { XY xy = new XY(1,2); xy.showxy(); 286

22 Notice that the show() is declared in one part of XY and implemented by another part. The implementation displays the values of X & Y. This means that when Show() is called by ShowXY(), the call has effect, and it will, indeed, display X & Y. Comment the implementation of Show(), then calling Show() inside ShowXY() does nothing. Restrictions on Partial Methods: They must return void. They can not have access modifiers. They can not be virtual. They can not use OUT parameters. 287