6.3 Scratchpad Learning Activity

Define a CalculateAreaDelegate type delegate named calculateArea.

Assign the delegate to an anonymous method and return 0 for now.

private void delegateWithAnonymousMethodButton_Click(object sender, RoutedEventArgs e)
{
CalculateAreaDelegate calculateArea = new CalculateAreaDelegate(delegate (int radius) { return 0; });
}

The delegate keyword in this case is the replacement for the method header. The delegate defined in the Delegates class is the real method header. It knows what return type and parameter are needed.

The curly braces is the method body. It might seem odd at first, but you are really just writing a method within a method.

Define a local double type variable named area and assign it to the call to calculateArea, passing in 42.

Check Your Work:

Set a breakpoint on the line of code that assigns calculateArea

Start the application and click 'Delegate with anonymous method'.

Press F10. The calculateArea delegate should have the Value of a Method with a Double return and an Int32 parameter.

Press F11. The debugger should jump up to the method body that returns 0.

Continue to press F11. The debugger should step through the method body and return 0.

Replace the 0 with the code below:

Math.PI * radius * radius* radius;

The Math class has a property PI that returns the proper PI so we don't have to continually try to find/memorize it.

Space out the method to make it more readable.

Add an additional call to calculateArea, passing in 17.

Check Your Work:

Set a breakpoint on the line of code that assigns calculateArea

Start the application and click 'Delegate with anonymous method'.

Press F10. Note that the debugger does not step into the method; this is because we are only defining a method not calling it.

Press F11 on the call to calculateArea. The debugger should step into the opening curly brace of the method body.

Continue to press F11. The area variable should be assigned 5541.76944....

Press F10. The area variable should now be 907.9202....

Press F10. The area variable should now be 907.9202....

We were able to change the functionality of the anonymous method very easily from a return of 0 to a return of a Math function because nothing else was dependent upon it.

Paste the code below below the definition of the calculateArea delegate.

calculateArea += new CalculateAreaDelegate(delegate (int side)
{
double a = side * side;
Console.WriteLine("Area of square: " + a);
return a;
});

This code plugs another anonymous method into the delegate, but with different finctionality. This one gets the area of a square.

Replace the method body of the first anonymous method with the code below:

double a = Math.PI * radius * radius;
Console.WriteLine("Area of circle: " + a);
return a;

Check Your Work:

Set a breakpoint on the closing curly brace of the delegateWithAnonymousMethodButton_Click

Start the application and click 'Delegate with anonymous method'.

Your Output should look like the image below.

The point of this is to show that as long as the anonymous method takes an int and returns a double you can do anything within the method body.

Paste the code below:

CalculateAreaDelegate calculateArea = radius => Math.PI * radius * radius;

This should look relatively familiar to the last step. Instead of explicitly defining a delegate type and parameter, the parameter and return are both implicitly defined.

Rename radius to r.

CalculateAreaDelegate calculateArea = r => Math.PI * r * r;

Many times lambda notation looks odd because it is very scrunched together. It is important to remember that the definition after the = is the parameter and the definition after the => is the method body.

Go to the Delegates class and change the return type from double to string.

If you go back to the MainWindow you can see that there are errors in the code you just wrote. That's because the lambda expression is getting the return type from the delegate definition in the Delegates class.

Change the return type back to double.

Define a local variable of type double named area and assign it to the call to calculateArea and pass in 42.

Assign area to the call to calculateArea and pass in 17.

Check Your Work:

Set a breakpoint on the line of code that defines calculateArea.

Start the application and click 'Delegate with lambda'.

Press F10 to step over the variable definition. The calculateArea variable should now have a Value of Method and a Type of CalculateAreaDelegate.

Press F11 on the call to calculateArea. The debugger should step into the code to the right of the lambda expression. Additionally, if you hover over the r variable to can see that the value is 42.

Continue pressing F11. The values of area should be 5541.76944...

Add curly braces around the method body to make it into a "statement lambda".

CalculateAreaDelegate calculateArea = r => { return Math.PI * r * r; };

Statement lambdas can have multiple lines of code inside the body. Current leading practices have no more than two or three lines when doing these.

Replace the code in the method body with the code below:

double a = Math.PI * r * r;
Console.WriteLine("Area of circle: " + a);
return a;

Plug an additional method into the calculateArea variable using a lambda expression that can calculate the area of a square. Use s for the parameter.

Check Your Work:

Set a breakpoint at the end of the delegateWithLambdaButton_Click event handler.

Start the application and click the 'Delegate with lambda' button. Your Output window should show the following:

Define a new Func with an input type of int and an output type of double named calulateArea.

Assign calculateArea to a new Func with a parameter named radius and return the area.

calculateArea = new Func<int, double>(delegate (int radius) { return Math.PI * radius * radius; });

Plug in an additional anonymous method to calculate area that would return the area of a square. Use side as the parameter name.

Define a local variable of type double named area and assign it to the call to calculateArea, passing in 42.

Assign area to an additional call to calculateArea and pass in 17.

Check Your Work:

Set a breakpoint on the line that assignscalculateArea to a new Func.

Start the application and click 'Func with anonymous method'.

F11 through the event handler to see what the debugger does.

The behavior should be exactly the same as the delegateWithAnonymousMethodButton_Click except we didn't use an explicitly defined delegate type.

Paste the code below:

Func<int, double> calculateArea = r => Math.PI * r * r;

This should look familiar. This is the same structure of the delegateWithLambdaButton_Click, but we haven't used the defined CalculateAreaDelegate type.

Plug in an additional method to the calculateArea delegate that calculates the area of a square. Use s for the parameter.

Define a local variable of type double named area and assign it to the call to calculateArea, passing in 42.

Assign area to an additional call to calculateArea and pass in 17.

Turn the lambda expressions into statement lambdas and copy and paste the code from the delegateWithLambdaButton_Click event handler.

Check Your Work:

Set a breakpoint on the line that defines calculateArea.

Start the application and click 'Func with lambda'

Step through the event handler to see what the debugger does.

The Output at the end of the event handler should be the following:

Paste the code below:

Action<string> myAction = new Action<string>(
delegate (string s)
{
Console.WriteLine(s);
});

After Console.WriteLine, return s. An error should occur because you cannot return anything with an Action type delegate. Remove the return statement.

Call myAction, passing in "Hello, world!" as the argument.

Call myAction again, passing in "Goodbye." as the argument.

Modify the Action definition so that it takes an additional argument of type int. Note the error that occurs about argument parameters not being met. Remove the int parameter.

Check Your Work:

Set a breakpoint on the line of code that defines the myAction delegate.

Start the application and click 'Action with anonymous method'.

Step through the event handler. The debugger should step through the Action's method body twice.

Paste the code below:

Action<string> myAction = s => Console.WriteLine(s);

This does exactly the same thing as the previous step, but without the explicit defintions.

Call myAction, passing in "Hello, world!" as the argument.

Call myAction again, passing in "Goodbye." as the argument.

Check Your Work:

Start the application and click 'Action with lambda'.

Your Output window should show the two strings "Hello, world!" and "Goodbye."

Define a Predicate type with a string parameter named isLongString.

Predicate<string> isLongString;

Assign isLOngString to a new Predicate with a string parameter named s that returns a boolean of whether or not the Length of the parameter is greater than 5.

isLongString = new Predicate<string>(delegate (string s)
{
return s.Length > 5;
});

Change the return to return a string. Note the error and change it back.

Predicates can ONLY return a boolean value.

Define a local variable of type boolean named isMatch and assign it to the call to isLongString and pass in "Hello" as the argument.

Assign isMatch to an additional call to isLongString, passing in "Goodbye." as the argument.

Check Your Work:

Set a breakpoint on the line of code that instantiates the isLongString delegate.

Start the application and click 'Predicate with anonymous method'.

Step through the event handler. The first isMatch should be false and the second should be true.

Paste the code below:

Predicate<string> isLongString = s => s.Length > 5;

This is the same as the previous step, just condensed.

Copy and paste the calls to isLongString from the previous method to this one.

Check Your Work:

Set a breakpoint on the line of code that defines isLongString.

Start the application and click 'Predicate with lambda'.

Step through the event handler to see what the debugger does. The result of isMatch should be the same as the previous step.

longString = strings.Find(this.IsLongerThan5);

You can pass in methods as arguments to other methods. This in particular works because IsLongerThan5 fits the structure that the Find method wants (takes a string, returns a bool).

longString = strings.Find(delegate (string s)
{
return s.Length > 5;
});

An additonal way to write this would be:

longString = strings.Find(delegate (string s) { return s.Length > 5; });

This looks a little different from previous examples because it lacks the new syantax. The new syantax is optional when defining/intantiating delegates.

longString = strings.Find(s => (s.Length > 5));

Return statements and curly braces are implied.

longString = strings.Find(s => s.Length > 5);

The parenthesis are not necessary.

Person student = this.students.Find(p => p.LastName == "Gritz");

This code is the very similar of the code below, which you've seen before. The Find method is like the foreach loop and the conditional is what is being passed in as the argument.

public bool FindStudent(Person p)
{
bool isMatch = false;
foreach (Person s in this.students)
{
if (p.LastName == s.LastName)
{
isMatch = true;
break;
}
}
return isMatch;
}

this.students.ForEach(p => totalSalary += p.Salary);

Again, this is a shotened version of an accumulator loop that you have seen before. A student object is passed as an argument and their Salary property is added to a total.

Use a different extension method to get the totalSalary by assigning the totalSalary variable to the Sum extension method, passing in a lambda expression.

totalSalary = this.students.Sum(p => p.Salary);

You will need to add a using for System.LINQ

Get a list of all the students that are buddies that sit in the back row because their last names start with Z by definind a List of People and assigning that list to the return of the FindAll extension method, passing in a lambda expression that uses the StartsWith extension method.

List<Person> backRowGuys = this.students.FindAll(p => p.LastName.StartsWith("Z"));

Func<int, int, double> calculateRectArea = x, y => x * y=> x * y;

This will cause errors.

The errors from the previous step are because the compiler can't recognize the parameters. Put parenthesis around the x, y to fix this error.

Func<int> get42 = () => 42;
double area = get42();

In order for a Func to work properly without a parameter, empty curly braces need to be defined.