For everyone that was at my DevTeach presentation thank you for showing up and listening to me. I had my adrenaline flowing and ended up finishing a little to early, if only I could code like that day to day!

If you have svn installed, you can download my presentation from the command line with the following command:

svn checkout http://stevenrockartspresentations.googlecode.com/svn/trunk/ devteachgenericspresentation

I still have to do one more check-in to add my reduce implementation and to clean up the code. I am also going to upload a zipped version of the code to the downloads section located here: http://code.google.com/p/stevenrockartspresentations/downloads/list

Here is a list of resources from the presentation:

- Combining Generics, Specifications and Functional Programming Part 1

- Combining Generics, Specifications and Functional Programming Part 2

- Combining Generics, Specifications and Functional Programming Part 3

- Combining Generics, Specifications and Functional Programming Part 4

- Follow up to Generics Presentation Feedback

- Reduce in C#

I got a couple of emails with great feedback from my last couple of posts. I think I could probably turn this presentation into 2 different presentations but it is curing my blogging writers block so i'll post the responses here for everyone's benefit.

Shane was very quick to point out that the method signature in Customer is kind of misleading:

We could actually pass any specification that implements the ISpecification interface into this function. We can refactor a little to make it a little more clear to someone consuming the Customer class:

Using this approach we supply consumers of our class with a default for an active customer and allow them to specify their own specification for what constitutes an active customer.

One thing that I should have mentioned in my post is that Filter and Map are included in the List class in .NET 2.0. Filter == FindAll and Map==ConvertAll, here is the code from Reflector:

At my DevTeach presentation I showed how you can do Map and Filter from Functional programming right now in C# 2.0. In mathematics Reduce is "the process of manipulating a series of equations or matrices into a desired 'simpler' format". In C# you can think of it as taking a list and reducing it down to one value. 

Here is my implementation of Reduce in C# 2.0:

and the implementation of the tests:

The first test calculates the sum of adding all the integers in the list together using the add function. The second test takes an integer and concatenates it to a string producing a string of all the integers in the list.

The Reduce function introduces the default keyword that you can leverage with generics. This will give you the default value for value types (0 for integers, 0.0 for decimals, null for string).

What would you do if your client asked you to find all suppliers in a list that are located in Alberta? We could create a new Supplier record book but by now you should be seeing the pattern. Whenever the type differs, think about creating a generic class that can extract the essence of the algorithm without worrying about the type. Lets create a generic RecordBook class that can filter by any specification:

Our Filter method is actually a C# implementation of one of the big 3 in functional programming...Filter!

Our client is happy with our work and we as developers are satisfied that we can respond to change quickly and filter by and type and specification our client can dream up. Our client then throws us a curveball, they want to see all the customers in the list formatted with their last name before their first name. Lets drive out what this would look like with a test:

There is a lot going on in this test so let me try and explain it before showing the Map method. The Map method takes an generic input (in our case a Customer object) and an generic output (a string). It then takes the list that it is going to convert (recordBook) and a method that converts a Customer to a string (ReverseFullName). The result is a list of strings with the customer's name reversed. Here is the implementation:

This is the C# implementation of the Map higher order function from functional programming. I will leave it up to you the reader to implement the last of the big three from functional programming (Reduce or Fold). Also try and think about how you would create a function to reverse all customers names who are active. Maybe once the dust settles after DevTeach I will post the solution.

Our Customer comes to us and likes what we have done setting up a way for them to find if a customer is active, but now they want to keep track of all the customers. We come up with the concept of a Customer Record Book and our client seems happy with that:

Our record book does its job of storing customers well but our client wants us to add a way to find all the active customers in it. Our first attempt at creating a way to find all the active customers looks like this:

The Filter method that we just created takes in the ActiveCustomerSpecification, creates a temporary list and then iterates through the customer list adding the active customers to the temporary list, once it is done it returns the temporary list.  Our test passes but there are a couple of improvements we can make to this code. First of all, we don't need to create a temporary list or use an IList<Customer> we can leverage the yield keyword and IEnumerable<Customer> to make our code tighter:

This change will break our test since IEnumerable does not contain a definition for count. If we look at the available constructors for the List class we can see that List has a contructor for creating a list from IEnumerable. So we can easily fix our test:

Now we are able to find all active customers in a list.

Encapsulating Criteria Using Specifications

"Specification provides a concise way of expressing certain kinds of rules, extricating them from conditional logic and making them explicit in the model."

Eric Evans : Domain Driven Design

In our domain model we have a normal Customer object that looks like this:

With this code, we have defined a customer as something with a first name, last name, and a signup date. We have also specified (using the IsAnActiveCustomer method) that an active customer is a customer who has signed up with us within the current year.

This method that determines whether or not a customer is active as it stands isn't very flexible. To make the method more flexible we can extract the criteria that determines whether or not a customer is active or not and add it as a parameter to the IsAnActiveCustomer method so that the criteria can be passed in.

In order to encapsulate the active customer we can leverage the specification pattern. Our first attempt at making an active customer specification might look something like this:

and in the customer class:

By adding the specification as a parameter to the IsAnActiveCustomer method we have inverted the control of the definition of an active customer to consumers of the customer class. There may be different definitions of what an active customer is in different situations.

We can make one more improvement to the specification class before moving on. What happens if another class wants to leverage the specification interface? They have to create a new specification for their new type...or they can use generics to save themselves the time of writing a new specification interface for every new type. Here is the result of our change:

Over the past month I have been preparing for my presentation at DevTeach in Vancouver. I am filling in for JP on the topic "Generics they're not just about collections". I am really nervous and one thing that I have been trying to work on is my ability to better communicate the concepts that I have learned and have trapped in my head.

I feel that my past 2 presentations on Windsor Container could have been a lot better if I were able to explain the underlying concepts behind a product like Windsor instead of just taking for granted the audience's knowledge.

After practicing my presentation multiple times in front of my dogs, I am not satisfied with how I am communicating these topics and I feel that writing out my presentation in front of my blog readership and asking for feedback is the next best thing.

If you have any suggestions or if there is anything that is unclear to you based on my explanation of things, please feel free to comment on this post or to send me a email at stevenrockarts@gmail.com.

Using Generics without Collections

Please not that this part of the presentation is based off of JP's original Generics article. How many times have you written a class like the following to check if something is within a range?