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?

If we look at the test for this code we can see that it works great for checking to see if an integer is within a certain range:

The range class works great checking integer ranges but what if we want to check DateTime ranges or our own custom Ranges? Creating a Range class that utilizes generics can help us save typing out a new Range class for every different type that we want to check. Before we jump in and create a Range class that uses generics lets create a couple tests that express our intent:

The first test shows that we want to check if the integer 12 is in between 10 and 20. The second test shows that we want to check if tomorrow is in between today and two days from now. Now that we have 2 tests that show what we want to accomplish, lets write a generic range class that can handle both of these types. Our first attempt might look something like this:

 As it stands, this code will not compile because the compiler does not know if it can apply the >= and <= signs to any type that may be supplied to our generic range class. For example this may make sense with integers but what does the compiler do with this code:

When we try and use the above code we get the following feedback from the compiler:

Error 3 The type 'Generics.Customer' must be convertible to 'System.IComparable<Generics.Customer>' in order to use it as parameter 'T' in the generic type or method 'Generics.Range<T>' C:\presentations\generics\src\test\Generics.Test\RangeTest.cs 24 50 Generics.Test

The IComparable interface contains one method on it called CompareTo() which compares the current instance of an object with another object of the same type and returns an integer based on the result. If the integer is less than 0 the instance is less than the object it is being compared to, if the integer returned is zero the instance is equal to the object it is being compared to and if the integer returned is greater that 0 the instance is greater than the object it is being compared to. Luckily for us most of the value types in the .NET Framework implement IComparable so we can utilize it to compare many different types using our generic Range class.

How can we ensure that any consumer of our generic range class implements the IComparable interface? Generic constraints to the rescue! We simply add the following to our class which specifies that any class that uses our generic Range class must implement the IComparable interface.

We also need to change the contains method to compare the value to check to the start and end of the range like so:

Now we can run our tests and discover that both tests pass and our range class now works with integers and date time values.