Continuations in C# - Make Code More Clear
Problem to solve:
If you look at a lot of code in C#, the code must be read from top to bottom, following all the If, Else, Try and other branches to really understand what is happening. Furthermore a lot of this code is basically technically, such as checking on null-values. I wondered if you could write code that reads from left to right, and is in principle not-technical. It reads like a series of operations that makes sense as such. A ‘similar’ concept is known in F# as pipelining. In F# it looks like
Let squared =
|> List.filter isOdd
|> List map square;;
The object Numbers are pipelined through the functions that follows. In C# I wanted to do something like this:
. AndThenIfElse(Do_this_If_ThisIsTrue, Do_this_IfOtherwise)
Etc. In this case the
SomeObject is passed to function
IsValid and then to Save and then to the
Do_this_If_ThisIsTrue, which function can return 'false', in which case
SomeObject is passed to
Do_this_ifOtherWise. The beauty of this chaining, is that we can add any number of
AndThenIfElse as we want.
You could do this years ago using delegates. Delegates are eventually not generic. Now we can use these, but we also want to handle Error handling and null-alike code. Tomas Petricek and John Skeet Real-World Functional Programming comes with the solution. The secret is in essential two things: the Option type and the using of essentially only one fixed interface: (func of Option of T, Option of T), meaning you pass in a function that receives an Option and returns one. This interface can be chained or pipelined as much as you want.
The Option Type is a well-known Type in F#. An Option can be None or Some. Some
wraps an actual business object. Continuations is the concept in which you pass
the result of a function to another function.
What if you combine those two concepts? There is a lot theory involved, but I won't bother you with it. If you wrap an object in an Option and then use Continuation, you can keep on chaining as shown in the above
AndThen code. The Option object hides the actual type of the object inside it.
Inside the Option can be anything. Using the Option-concept we can let behave a
strict typed language in a generic way.
For continuation you can use Lambda's, but then the typing won't let you implement these in a generic way.
This article is about implementing Continuation in a generic way.
The Option type is an abstract class with two concrete implementations: None and Some. None ends the chaining, Some encapsulates the
[SomeObject]. A function must first get the encapsulated object, do some processing on it and return either a None or a Some with the encapsulated object. The Option Some and None classes are generic!
To this Option type I added some functions, such as the above
AndThenIfElse. If you look at the parameters you see that you pass the following two parameters: Func of Option of T, Option of T tryFirst, Func of Option of T, Option of T tryNext, meaning you pass in two functions.
AndThen (continuation). If the previous function returns a Some then continue with the following function
AndThenCheck. You pass in as the first parameter a function that takes an Option and returns a Boolean. If this Boolean is true, the second parameter is executed, which is a continuation. If not true return None.
AndThenCaseCheck. You pass in a list of
AndThenCheck. If a check returns true, the accompanying continuation is executed. If none of the checks returns true a None is returned.
In the accompanying example I use lambda’s to compose this list. Func’s can be replaced by lambda’s and in this case I thought it was a good idea.
AndThenIfElse. You pass in two functions. If the first return None, the second continuation is executed.
The other interesting thing to note, is that the above pipeline of continuations is not executed until a call to
Exec(). The reason to do this, is because Exceptions are handled in the
Exec() call only, and the continuations stop with the first None returns. The pipeline is in fact an arraylist of
MultiCastDelgates that can be serialized. The option/Continuation concept can be used in other scenario’s as well such as postponing execution by saving until it’s triggered in time.
I added a concrete example how to use this in the real world. The code is not doing much, but gives you a good idea how you can use it. Looking at the code below (
ClientController), you see the real benefit:
Does the code read from left to right and does it read as a series of chained operations? Does it 'hide' technical handlings in favor for business handlings? What do you think. Let me know.