Since my last post on the functional nature of the web, I’ve given two presentations describing this idea in more detail. Unfortunately, circumstances have conspired against me such that I have been unable to build any good sample apps. That’s about to change, as I’ve started working on screencasts on Web API that I’ll be posting here and on fpish.net as I complete them.
As a preview, In this post I’ll describe the inherent functional nature of Web API. You have looked into Web API at all, you’ve probably seen the Contact Manager sample application, originally created by the infamous “2C”. (Kudos to Dan Roth on the Web API team for keeping it alive!) The controller-based goodness baked into Web API hides a lot of the functional nature, so I will understand if you think I’m a little crazy for my statement above.
See? Not so much? Okay, how about in F#?
1 2 3 4
Eh, let’s try again.
1 2 3 4 5 6 7
Here I use several unique features of F# to emphasize the point. The type signature should be familiar from my last post.
I then create a handler using F#’s object initialization syntax, which creates an instance from a base class using the
app from above.
I think I’ve made my point that, at its heart, the
HttpMessageHandler is functional in its core.
Okay, let’s translate back to C#-land. We don’t have object initialization syntax, but we can create pure,
functional approaches for C#. Also, we’ll use
DelegatingHandler, as that’s the actual type you’ll need to inherit
in order to use it in Web API. (I apologize now for making your eyes bleed with the type signatures.)
Why is this core?
I’ve mentioned this is core, but if you’ve only used Web API with controllers, you may never have interacted with
HttpMessageHandlers are at the root of everything.
HttpServer, and everything else that uses these types all inherit
If you look deep into Web API, you find this consistency of
HttpMessageHandler at the core. What does that mean? It means “it’s [functions] all the way down.”
A quick example
Okay, so now we have our “function.” How would you hook this up? That’s also quite simple.
HttpApplication now has a
This provides you access to an instance of
HttpConfiguration, which provides you all the extensibility points for managing your Web API.
The Self Host option let’s you create your own. Attaching a handler is dead simple:
By no means am I trying to convince you to give up all the ease of built-in model binding and conneg. I only want to drive home the point that the core of Web API is really just functions. As I mentioned previously, HTTP exhibits a very strong functional side. Web API really addresses this head on and provides a very solid core for building web applicaitons, whether using a more MVC-style or functions directly.
Try it out. For really simple applications, you are likely to find that these are all you need. You may also appreciate that you can implement your own routing and other mechanisms directly within a composed set of functions. We’ll explore this more as we continue in this series, so stay tuned.