Delegates, Events, and Lambda Expressions in Visual C#

Paint QR in Visual C# Delegates, Events, and Lambda Expressions

// Reverse a string static void Reverse(ref string s) { string temp = ""; int i, j; ConsoleWriteLine("Reversing string"); for(j=0, i=sLength-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); ConsoleWriteLine("Resulting string: " + str); ConsoleWriteLine(); // Remove replace and add remove strOp -= replaceSp; strOp += removeSp; str = "This is a test"; // reset string // Call multicast strOp(ref str); ConsoleWriteLine("Resulting string: " + str); ConsoleWriteLine(); } }

Here is the output:

Replacing spaces with hyphens Reversing string Resulting string: tset-a-si-sihT Reversing string Removing spaces Resulting string: tsetasisihT

Part I:

In Main( ), four delegate instances are created One, strOp, is null The other three refer to specific string modification methods Next, a multicast is created that calls RemoveSpaces( ) and Reverse( ) This is accomplished via the following lines:

strOp = replaceSp; strOp += reverseStr;

First, strOp is assigned replaceSp Next, using +=, reverseStr is added When strOp is invoked, both methods are invoked, replacing spaces with hyphens and reversing the string, as the output illustrates Next, replaceSp is removed from the chain, using this line:

strOp -= replaceSp;

and removeSP is added using this line:

strOp += removeSp;

Then, strOp is again invoked This time, spaces are removed and the string is reversed Delegate chains are a powerful mechanism because they allow you to define a set of methods that can be executed as a unit This can increase the structure of some types of code Also, as you will soon see, delegate chains have a special value to events

There are two features that add flexibility to delegates: covariance and contravariance Normally, the method that you pass to a delegate must have the same return type and signature as the delegate However, covariance and contravariance relax this rule slightly, as it pertains to derived types Covariance enables a method to be assigned to a delegate when the method s return type is a class derived from the class specified by the return type of the delegate Contravariance enables a method to be assigned to a delegate when a method s parameter type is a base class of the class specified by the delegate s declaration Here is an example that illustrates both covariance and contravariance:

// Demonstrate covariance and contravariance using System; class X { public int Val; } // Y is derived from X class Y : X { } // This delegate returns X and takes a Y argument delegate X ChangeIt(Y obj); class CoContraVariance { // This method returns X and has an X parameter

15:

static X IncrA(X obj) { X temp = new X(); tempVal = objVal + 1; return temp; } // This method returns Y and has a Y parameter static Y IncrB(Y obj) { Y temp = new Y(); tempVal = objVal + 1; return temp; } static void Main() { Y Yob = new Y(); // In this case, the parameter to IncrA // is X and the parameter to ChangeIt is Y // Because of contravariance, the following // line is OK ChangeIt change = IncrA; X Xob = change(Yob); ConsoleWriteLine("Xob: " + XobVal); // In the next case, the return type of // IncrB is Y and the return type of // ChangeIt is X Because of covariance, // the following line is OK change = IncrB; Yob = (Y) change(Yob); ConsoleWriteLine("Yob: " + YobVal); } }