NancyFX: .NET Web Framework

NancyFXWorking in the .NET ecosystem can feel very insular.  Especially if you work in the enterprise.  At the very beginning of my career in software development (circa late ’90s), I was generally using more open tooling and languages.  The atmosphere in those communities had (past tense) a much different feeling than it does in the .NET community.

Most developers that are in .NET can feel the changes that have been occurring recently.  There has been a bigger wave of alternative and open source software awareness within .NET.  However, I still don’t think that the .NET community at large are even aware of some of the great open source libraries and frameworks.

 ASP.NET MVC / Web Api

If you were starting new web project in .NET, I think it’s safe to say that most would automatically choose ASP.NET MVC or Web Api.  There may be legitimate reasons for doing so, such as you or your team having exiting knowledge of those frameworks.

However, NancyFX is a great alternative that is very mature, simple and has great documentation.


Nancy is a lightweight web framework.  It’s really that simple.

At its heart it provides a really easy way to create HTTP services.  That means you could be generating and returning HTML using the MVC pattern or creating services returning JSON.  You are not forced into either or into any heavy configuration. You are simply creating endpoints using HTTP verbs.

Getting Started

In my code examples, I’m going to be using my Self Host ASP.NET Demo application, which is currently demos how to use Katana (Owin) Self Host, Middleware, File Server and Topshelf.

I’m going to extend this project to include Nancy.

First let’s install Nancy from Nuget

Install-Package Nancy

For my example, I’m also going to need to Install the Nancy.Owin Package because my self host application uses the Katanta Owin Implementation with HttpListener.

Install-Package Nancy.Owin

Now that we have our packages installed, in your Startup class, use the new IAppBuilder.UseNancy() extension method.

Simplest Example

My intent for this blog post is simply to get people looking at Nancy as an alternative.  I can’t show you all all the wonderful features in one easy to digest post.  In posts to come I’m going to cover many different topics related to Nancy.  However, for this post I want to provide the simplest possible example of creating an HTTP endpoint using the GET verb.

Similar to ASP.NET MVC or Web Api, you will create a class that extends another.  For Nancy, we create a class that extends the NancyModule.  It is in this class were we define the routes and the endpoint implementation.   In my example above, I’ve created a HTTP GET route to /nancy/demo.  Since my self host application is running on localhost:8080, this translates to http://localhost:8080/nancy/demo.

Here are the results:


As you might expect, Nancy has automatically converted my .NET string array to JSON without any configuration.


As I mentioned, I plan on going over in detail many features of Nancy and why you may want to use it.  But to get you interested a bit more, here are a few key points.

  • Model Binding
  • Built in IoC Container (Support for almost all others)
  • Easy Testing
  • Content Negotiation
  • View Engines (including Razor Support)
  • Multiple Hosting Options (Katana/Owin, ASP.NET HttpHandler, more)
  • Mono Support

Please take a few moments and check out the great docs over on Github.

Source Code

GithubThe source code for this demo is available on Github.

OWIN/Katana Series

If you want more information about OWIN/Katana, please take a look at my other series of posts.

  1. How to Self Host ASP.NET Web Api

  2. Self Host ASP.NET Web Api as a Windows Service

  3. ASP.NET Self Host Static File Server

  4. How to create Katana Middleware

Read More

How-To Create Katana Middleware

PipelineWhat I love about Katana (OWIN Implementation) is the ability to add functionality through the request pipeline.  In this post I’m going to extend my ASP.NET Self Host Web Api application by demonstrating how you can create your own Katana Middleware.

What’s OWIN Middleware?

OWIN specification defines middleware as:

Middleware – Pass through components that form a pipeline between a server and application to inspect, route, or modify request and response messages for a specific purpose.

Katana IAppBuilder.Use

There are couple different ways you can create your own middleware.  The simplest is to call the IAppBuild.Use method in your Startup class.

For our example, we are going to add a Product to the response header.

context is of type IOwinContextnext is of Func<Task>

IOwinContext contains the Request, Response, Environment and other properties you can access to manipulate the request or response.

Middleware Type

Another way to create middlware is by creating your own class that extends and overrides the OwinMiddleware base class.

For this example, we are going to add a MachieName to the response header.

In order to include our new middleware class into the pipleline, you must call the IAppBuilder.Use in your Startup class, but this time specifying the type of our class.

Notice we aren’t passing an instance of our CustomMiddlware but just the type.

Startup Class

After adding our two new middlware that are adding headers to the response, here is what our Startup class now looks like.

Now when I run the application and make a HTTP call to http://localhost:8080, the headers returned are:


Source Code

GithubThe source code for this demo is available on Github.

OWIN/Katana Series

If you want more information about OWIN/Katana, please take a look at my other series of posts.

  1. How to Self Host ASP.NET Web Api

  2. Self Host ASP.NET Web Api as a Windows Service

  3. ASP.NET Self Host Static File Server

Read More

ASP.NET Self Host Static File Server

Continuing in my Owin and Katana series of blog posts, I’m going to demo an ASP.NET Self Host Static File Server. If you have not seen my previous posts in this series, I’ve covered how to self host a Web Api application and how to use Topshelf to debug and run as a windows service.

The wonderful thing about the shift to Owin and Katana with ASP.NET is middleware.

Katana has a file server implementation that you can plugin to your application startup pipeline in order to serve static files either on a filesystem or from embedded resources.


The first thing we will do with our demo application is install the Owin StaticFiles middlware into our project.

Install-Package Microsoft.Owin.StaticFiles

The simplest possible configuration is to call IAppBuilder.UseFileServer(true).  This will enable directory browsing of files from the current location of the executable.

When running our demo application, this results in showing us the directory listing when we pass thru our Web API routes without a match.


Now this isn’t very useful but it displays the simplicity of different Owin middlewares that are available.

UseFileServer has several different overloads:

Name Description
System_CAPS_pubmethodSystem_CAPS_static UseFileServer(IAppBuilder)

Enable all static file middleware (except directory browsing) for the current request path in the current directory.

System_CAPS_pubmethodSystem_CAPS_static UseFileServer(IAppBuilder, Boolean)

Enable all static file middleware on for the current request path in the current directory.

System_CAPS_pubmethodSystem_CAPS_static UseFileServer(IAppBuilder, FileServerOptions)

Enable all static file middleware with the given options

System_CAPS_pubmethodSystem_CAPS_static UseFileServer(IAppBuilder, String)

Enables all static file middleware (except directory browsing) for the given request path from the directory of the same name

For our demo application, we are going to create our File Server to serve files from an Assets directory that lives in the same location as our executable.

Now when we browse we see the files within the Assets directory.


Content Type Provider

The Katana FileServer only serves known content types.  If you try and browse to a file that is not a known content type, it will return a 404.

In my example above, I’ve added a data.json file.  Odd to me was that a json file is not a known content type.  In order to serve json files, we must create our own content type provider and add our mappings.

Now we need to specify our CustomContentProvider in our FileServerOptions.

Source Code

GithubThe source code for this demo is available on Github.

Read More

Self Host ASP.NET Web Api as a Windows Service

In my previous blog I demonstrated how to Self Host ASP.NET Web API, which was a very basic console application leveraging Owin and Katana.

The next step in this series is how to turn your console application into a Windows service.

Windows Service Template

The typical way to create a Windows Service is by using the Windows Service template when creating a new project within Visual Studio.

The template will create a Program.cs calling ServiceBase.Run() in the Main() method.

SelfHostServiceBase is the code that will extend ServiceBase.   You would have to implement OnStart() and OnStop()

That’s simplest possible implementation.  Now when you start debugging, you are treated with this wonderful message.


What this means is you must build your Windows service, start it, then attach the debugger to the process.

Doesn’t sound like a fun way to debug does it?


TopshelfThere is a great open source project called Topshelf which allows you to create a windows service which is much easier to debug.

Topshelf is a framework for hosting services written using the .NET framework. The creation of services is simplified, allowing developers to create a simple console application that can be installed as a service using Topshelf. The reason for this is simple: It is far easier to debug a console application than a service. And once the application is tested and ready for production, Topshelf makes it easy to install the application as a service.

First thing is to install Topshelf into your project via nuget.

Install-Package Topshelf

Next we need a tiny bit of code to configure our service with topshelf.

We tell topself which class will contain our service (TopselfService) as well as which method to call when the service starts and stops.

Also, you can define which user the service should run as, as well as the name, display name and description.

Now when you debug the application, it will run just like a Console application, in which you can add breakpoints and debug.

Self Host ASP.NET Web API

To verify my web api application is responding, here is the result from my Postman call



Source Code

GithubThe source code for this demo is available on Github.


Next up I’ll continue adding to the demo by serving static assets from your self host application.

Read More

How to Self Host ASP.NET Web Api

OWINOver the past several months, I’ve talked to a few people that were completely unaware that you could self host ASP.NET Web Api application without the need for IIS.

Anyone who has worked with IIS knows that sometimes it can feel a bit heavy.  Especially if you not using any other features other than serving static content or executing your ASP.NET Web Api.

There are a couple important aspects to cover first which are what makes self hosting possible.


OWIN defines a standard interface between .NET web servers and web applications. The goal of the OWIN interface is to decouple server and application, encourage the development of simple modules for .NET web development, and, by being an open standard, stimulate the open source ecosystem of .NET web development tools.

To clarify and reword slightly, OWIN is a open source specification that is not defined by microsoft and is not an actual implementation.


Katana is an open source project by the Microsoft Open Technologies.  It’s a set of components for building and hosting OWIN-based web applications that follows the OWIN  specification.

I’m not entirely sure what the status is of OWIN/Katana within ASP.NET 5 (vNext), however I would like to think the separation between server, host, middleware, and application will continue.


All of the source code for this demo is available on Github.

The first thing we are going to do for this demo is create a Console Application and add the Owin SelfHost and WebAPI Owin Selfhost nuget packages

PM> Install-Package Microsoft.Owin.SelfHost

PM> Install-Package Microsoft.AspNet.WebApi.OwinSelfHost

Next, we will create a Startup class that will contain the HttpConfiguration similar to how you configure Web Api currently.   The startup class is the implementation of the OWIN specification that our OWIN Self Host implementation will use.  The Startup class must provide a public Configuration() method with the signature void.

Next, we will create a simple ApiController.

Last step is to add the web server implementation to out Program.cs Main() method.  This is done by simply calling out Katana implementation of WebApp.Start and passing our Startup class name as a type argument along with the host/port binding details as the first parameter argument.

That’s it!  Now when I make a call from Postman to http://localhost:8080/api/demo, here are the results:



Source Code

GithubThe source code for this demo is available on Github.


Next up I’ll continue adding to the demo to illustrate how to easily turn the console application into a windows service, serving static content and other middleware.

Read More

Event Stream as a Message Queue

I was recently having a discussion around a system being built using Microsoft Azure.  Some concepts being discussed for this system where CQRS, Event Sourcing and Message Queue.

The diagram below is fairly typical when discussing CQRS and Event Sourcing.

Message Queue

One of the first things that stood out to me was the use of the Message Queue and Azure Service Bus.

For this blog post, I want to focus on the Service bus, which is used for publish-subscribe pattern.  The domain will emit events that are stored to the event stream and then will be published to the Service Bus.  Subscribers, such as Projections or other Bounded Contexts will process these events.

Forgotten Option

There is nothing wrong with using a service bus to publish domain events.

However, one option which is seemingly always forgotten to developers that are new to CQRS and Event Sourcing:

Your event stream can be used as a message queue

Other bounded contexts or projections can query/poll your event storage to retrieve new events that have been persisted.

At regular intervals, the event consumer could poll your event storage requesting any number of new events based on the last event it processed.

The consumer would be required to keep track of the last event it processed in order.  This provides some benefits as it may not be a process that is required to be continuously running.

You may be thinking: Polling? Really?

If you rolled your own event storage, I could understand how this might be problematic and would likely be easier to use a service bus.  Or you may want your event consumers to process the event as soon as possible.  Your implementation of how to handle this is dependant on how you are currently storing your events.

But the point still remains: Your event stream is a message queue.

As always, context is king.  Requirements and many other factors will play into how you want to handle messaging.

It is another option that may fit a scenario that you run into.

Event Store

Event Store

If you are just thinking about getting into Event Sourcing, I would highly recommend looking at Event Store by Greg Young as your event storage.

Event Store supports multiple types of Subscriptions including Competing Consumers.

Read More

ConfigR: Look Mom, No XML

driving-nohandsI stumbled upon ConfigR a several months ago  on twitter from Glenn Block.  It uses ScriptCS (and Roslyn) and was developed by Adam Ralph.

I finally got around to take it for a test drive on a side project.  It’s really a simple tool that I’ve been waiting for.

Why ConfigR?

The purpose of ConfigR is pretty straight forward.  It allows you to write C# code to define configuration settings which you would normally place in a the appSettings section of a web.config/app.config.

If you have used the appSettings at all, you probably wished they could be typed instead of always having to be strings.

From Adam Ralph, the creator of ConfigR

ConfigR allows you to write your config in C# instead of XML – that’s really all there is to it. From that point on you can use your imagination to go wild in what you do in that C#.

Install via NuGet

Make sure your project is set to be using .NET 4.5 or greater

You need to get ConfigR into your project.  Install via the Package Manager in Visual Studio.

PM> Install-Package ConfigR

Or if you prefer via the NuGet UI


Web Application

This portion has been updated to reflect the proper way of sing ConfigR with a web application.  Thanks to creator Adam Ralph for clarification below in the comments.

The default naming convention ConfigR uses to automatically load your configuration file is to look for a file in your output directly named Web.csx.

  1. Create a new file in your project named Web.csx
  2. Make sure the Copy to Output Directory is set to Do not copy.

This is different than a console app in which you do want to copy to output dir.  In a web application, we want the Web.csx in the same location as you would normally see the web.config.


I’m going to create two simple configuration settings in our new Web.csx file

As you can expect the Add method is adding items into the ConfigR global configuraiton.  The two configuration settings I’ve created are of different types: boolean and string.

Now in code when we need to access these configuration settings, it couldn’t be any easier.

Loading from Custom Location

Want to load a config file not using the default naming convention? Easy.

Complex Types

You can use complex types defined in your assembly or another referenced assembly.  When using a referenced assembly, you must specify the ScriptCS reference directive to the DLL in bin/ directory.

Here is my type defined in another referenced project called AnotherProject.dll

Here is my new Web.csx.  Again, note the #r ScriptCS reference directive and the using statement.

Now we can get our our complex type.


Read More

How to get started with CQRS & Event Sourcing

hammernailWhen I first heard about CQRS & Event Sourcing concepts through various blogs and videos, primarily from Greg Young and Udi Dahan, I wanted to apply it everywhere.

It seems really natural to want to take the limited knowledge we have about a new concept or technology and try and apply it to any problem.

Most of us know this is a terrible idea, but we are so tempted to push the concepts on a problem that it just doesn’t fit.

I realize I’m grouping CQRS and Event Sourcing together in this post.  Generally, if you are applying Event Sourcing then you are doing CQRS.  The other way around isn’t always true.

The Problem

In the very beginning I had a difficult time seeing where CQRS and Event Sourcing were best applied.  Again, as a beginner with our new shiny new knowledge we have our blinders on.

We look at any new problem and try to make it fit what we think CQRS and Event Sourcing solves.

There are some pretty good examples scattered around the internet about different situations that CQRS and Event Sourcing have been applied.  You may be able to read these examples and get a better understanding about what the context and how it was a good fit.  Also, you may read horror stories about how it was a complete failure and why.

To be honest, I haven’t read that many horror stories as I assume people are too afraid to admit their failures, although it would be very helpful to the community.

Feeling the Pain

I could read all kinds of blogs about where not to apply CQRS & Event Sourcing, but I need to feel the pain first hand to really understand where it’s best used.

I needed to apply the concepts I read about in a meaningful project.

For me a meaningful project was a side-project I worked on after hours at home that was large enough in scale that wasn’t incredibly trivial.

The learning experience of failure (and success) gave me greater insights and a deeper understanding to the words I’ve previously read from others discussing CQRS & Event Sourcing.


Start using CQRS and Event Sourcing in a project that is meaningful to you.  Obviously, I’m not recommending it in a project at work.  Do it in on a project where you can fail.  Feel the pain of applying these concepts where they don’t provide enough value or are cumbersome (hint: CRUD).

With real practice, your understanding matures and not everything will look like a nail with your shiny new hammer.

Read More

Handling Async Await Exceptions

Async Await Exceptions


There’s a ton of information about async await support in .NET 4.5.  I don’t want to go over all the best practices and gotchas in this post, but I did want to point out one common trend I’ve seen lately, which is handling async await exceptions.

Await or forget about it

Any async method that returns a Task or Task<T>, you should always await the result.

If you do not await, any exceptions that occur in the calling method will be swallowed.  Essentially you are turning the method call into a fire and forget.

Async Await Exceptions Example

Below is a simple example that demonstrates two behaviors of calling await on an async.  

To run the example, just copy and paste in a new console application.  If you run with the debugger, you should notice the following:

  1. MethodCallWithoutAwait will be called, however no exception will be raised in the debugger because await is not called.
  2. MethodCallWithAwait will be called and the exception will be raised in the debugger because await is called.

Async Lambdas

There be dragons!  Next post I’ll explore of using async lambdas and how you need to pay close attention in order to avoid creating a void lambda.

Read More

Mediator Pattern using MediatR and Unity

MediatRIn a couple previous posts I’ve discussed using Query Objects instead of Repositories and the Mediator pattern.  I find creating query objects being used with the command pattern much cleaner than polluting repositories with a ton of query methods.

The concept is nothing new as many people already use the command pattern in the context of executing commands/behavior following CQRS.   However, there is nothing wrong with using the same patterns for the query side.

I’ve been using my own home grown solution of the mediator pattern in a few different projects but had nothing really formalized.  I was thinking about creating a simple library until I stumbled upon MediatR created by Jimmy Bogard.

It is incredibly simple and only has one dependency, CommonServiceLocator.

The Github repo has a good set of docs and some examples with different dependency injection containers.

Unity RegisterType

I did notice the Unity example didn’t quiet work as described in the example.

The Mediator class takes a ServiceLocatorProvider in its constructor which was not being resolved properly by Unity.

In order to get it functioning correctly, I defined an injection factory and created the Mediator and passed in the UnityServiceLocator.

My complete Unity configuration which is also using MediatR to publish events from NEventStore:

MediatR v2.0

Although v1 has a dependency on CommonServiceLocator, it appears that v2.0 will not have any external dependencies.




Read More