Q & A

Q1. When is this free training available?
A1. The entire weekend of Nov 12th 2011 through Nov 14th 2011.

Q2. Do I have to be a Pluralsight subscriber to get this awesome training?
A2. This training will be freely available to everyone. You do not have to be a subscriber.

Q3. What does the course cover?
A3. Well let’s take a look:

• Getting started with Prism
• Bootstrapper and Shell
• Regions
• Modules
• Views
• Communication
• State-Based Navigation
• View-Based Navigation

More course information.

Q4. Who is the author of this kick ass Prism course?
Q4. That would be me.

Q5. Is it really free?
Q5. You’re kidding right? Didn’t I already cover this part? Yes, it is free.

New and Improved

If you are a subscriber and have already watched the course, I would like to bring to your attention that there have been two new modules added.  These modules will cover everything you need to know in order to start using the navigation services provided by Prism.  This includes state-based navigation and view-based navigation.

Mark your calendar for Nov 12th and be sure to cram as much Prism knowledge into your brain as you can before the weekend ends.  Don’t worry, if you run out of time you can always ask me questions directly.  You can contact me either through Twitter (@brianlagunas) or through the Extended WPF Toolkit project site.  I hope you enjoy the training.

Specifying Properties

Custom Editors

• CheckBoxEditor
• CollectionEditor
• ColorEditor
• DateTimeUpDownEditor
• DecimalUpDownEditor
• DoubleUpDownEditor
• EnumComboBoxEditor
• FontComboBoxEditor
• IntegerUpDownEditor
• ItemsSourceEditor
• PrimitiveTypeCollectionEditor
• TextBlockEditor
• TextBoxEditor
• TimeSpanEditor

Custom ItemsSource

Expandable Properties

Conclusion

Let’s begin by defining what the BusyIndicator is used for.  The BusyIndicator is used to give an application user a visual indicator that a long running process is occurring.  So from this definition we can make two assumptions. One; There must be a mechanism for notifying the BusyIndicator when the long running process begins and when it ends.  Two; the long running process will have to occur on a separate thread as to not block the UI.

Anatomy of the BusyIndicator

The first thing you need to do when using any control inside the Extended WPF Toolkit is add a namespace declaration to the consuming view.

The BusyIndicator is a ContentControl.  What this means is that the BusyIndicator can contain a single child element within it’s open and closing tags.  For example:

Looking at this code snippet you can see that the Grid is the BusyIndicator’s Content.  If you were to place anything outside of this Grid element you would receive an exception.

The BusyIndicator has two visual states:

Not Busy:

Busy:

Toggling between these states is as simply as setting a single property called IsBusy.

When the BusyIndicator.IsBusy property is set to True, the BusyIndicator becomes visible and prevents any user interaction with the BusyIndicator’s Content.  So any elements that you have defined within the Content of the BusyIndicator will be disabled.  When the IsBusy property is set to False, the Content re-enables and user interaction can continue.

The Common Problem

The most common problem I see when people are having trouble using the BusyIndicator is that they are doing everything on the UI thread.  Let’s look at an example:

The event handler for the button looks like this:

Now the assumption is that first the BusyIndicator will be shown, then the long running process will occur, and lastly the BusyIndicator will be hidden.  To most people’s surprise it doesn’t work.  The BusyIndicator never shows and the UI is not responsive.  Do you see the problem?  The problem is that everything is running on the UI thread.

Solution

As we have already stated, the long running process must occur on a separate thread.  The UI thread needs to stay responsive while the process is running.  The most common method to place a long running process on a separate thread is to use the BackgroundWorker.

Let’s modify the event handler to utilize a BackgroundWorker.

Examine the code.  First we create an instance of a BackgroundWorker and add delegates for the DoWork and RunWorkerCompleted events.  The DoWork hander is where the long running process should go.  NO DIRECT INTERACTION WITH THE UI IS ALLOWED.  The RunWorkerCompleted handler is code that will run when the long running process has completed.  This is where you can interact with the UI again, meaning that this would be a perfect place to set the IsBusy property to False.  After the long running process has finished.  Now pay special attention to where we are calling RunWorkerAsync.  Just before that call, we are setting the IsBusy property to true.  Then the call to RunWorkerAsync is made.  This will show the BusyIndicator and then start the long running process.  When the process is complete the BusyIndicator is hidden again.  Perfect!

Common Problem 2

The next common problem is dealing with using data that is generated on the background thread in the UI.  Well if you read my post on multi-threading then you should already know how to solve this one.  If you haven’t, I will show you again.  This scenario requires that our UI have a ListBox control that is populated with items on a background thread.  While the items are being populated, the BusyIndicator should show the user something is happening and that they need to be patient.  Let’s modify our UI and our code behind to support his new scenario:

This is similar to what the problem cases look like.  This code will most definitely fail.  Remember, you cannot access any UI elements on a separate thread.  Now let’s modify this code to make it run correctly.

Solution

First we had to remove any reference to a UI element from the DoWork handler.  Now in order to propagate the generate list of strings back to the ListBox we enlist the help of the Dispatcher.  The Dispatcher will take the collection of strings, and in a thread safe way, give them to the ListBox for consumption.  Our BusyIndicator will be shown while the collection is being generated, and then be hidden when the process has been completed.

That about wraps it up.  These are the most common troubles developers have had using the BusyIndicator control.  If you have different problems that you haven’t been able to solve, feel free to post your question in the Discussions page of the project site.  You never know, it may be worth blogging about.

1. Get the Bing Maps WPF control.
2. Get a Bing Maps API key.

You MUST have a Bing Maps API key in order to use any of the SOAP services.

For this application we will be using the Geocode Service and the Route Service.  The Geocode service is used to match addresses, places, and geographic entities to latitude and longitude coordinates on the map, as well as return location information for a specified latitude and longitude coordinate.  The Route service is used to generate routes and driving directions based on locations or waypoints.

Now that you have that out of the way let’s write an application. Create a new WPF application targeting the .NET 4.0 framework. Add a reference to the Microsoft.Maps.MapControl.WPF.dll. This will most likely be located in Program Files or Program Files (x86) –> Bing Maps WPF Control –> Beta –> Libraries.

Open up your App.xaml. You need to add an ApplicationIdCredentialsProvider as a resource and enter your ApplicationId:

We need to add the Geocode and Route service to our application.  First, let’s start by adding the Geocode service.  Right click the project and select “Add Service Reference”.  Use the following address:

http://dev.virtualearth.net/webservices/v1/geocodeservice/geocodeservice.svc

Give your service a name. I called mine BingServices.  Now we need to add the Route service, but we don’t want to add a separate service reference.  Ideally we would have a single service that contained both the Geocode and Route services.  Luckily there is a trick we can use to do just that.  Select the Project and click the “Show All Files” button at the top of the Solution Explorer.  Expand the Service Reference folder and then expand the BingServices service.  Look for a file called Reference.svcmap. Open the References.svcmap and locate the MetadataSource node.  It will loko something like this:

Simply add a new MetatdataSource as follows:

As you can see we added a new MetadataSource that points to the Route service and we gave it a SourceId of 2.  Now right click the service and select “Update Service Reference”.  This will generate a single service proxy for both the Geocode and Route services.  Pretty slick huh?

The next step will be to create a ViewModel that will contain an ICommand that will execute the route calculation, properties that will represent a “To” address and a “From” address.  We will also need a property for the RouteResult and for the directions we generate.  Lets first create our Direction object:

Now we will need a make-shift delegate command (do not use in production code):

Now on to the ViewModel itself:

Let’s walk though the CalculateRoute Method.  First we geocode the “From” and “To” properties the same way we did in the geocoding post.  Once we have our From and To locations we use those results to generate a RouteRequest and send that request to the Route service.  The service will generate a result and we set our RouteResult property accordingly.  This property will be used in data binding shortly.  Next we generate an ObservableCollection<Direction> by looping through all the ItineraryItems in the result. 

Now that we have generate all of our data, we need to create a View that supports and displays this data, but before we do that we need to create some attached properties.  Why do you ask?  Well because as it stands, the Bing Maps WPF control is not data binding friendly.  So we need to enable data binding with the use of attached properties.  We will need an attached property for the Route result which will be responsible for drawing the route line on the map.  We will also need one for the MapLayer that will be used to contain the route line.  Here is the code:

The RouteResult property simply creates a MapPolyline, loops through all the points in the result and adds the locations to the route line.  It then gets the RouteLineLayer and adds it to the map.  Lastly, it sets the map’s view to best fit the route line.

Now we are ready for the View:

Oh and don’t forget the code behind:

Now let’s view the fruits of our labor at runtime.

As you can see, given a “From” and “To” address, we can draw a route line and provide turn-by-turn directions as the user hovers over the direction pins.  Pretty neat huh?  And it wasn’t too difficult to pull off.  As always you can Download the Source and start playing.

The concept is simple.  We want a Bing Maps application that can be extended at runtime.  By extended, I mean that I want the ability to add new elements/modules to the Map at runtime.  The important thing about these elements/modules is that they can come from anywhere and they should be loosely coupled from the Map as well as other elements/modules that may exist on the Map.

Luckily for us this is extremely simple to accomplish.  All we have to do is create a custom RegionAdapter, register it with our Prism application, and then apply it to our Bing Map control.  So let’s start with the RegionAdapter.

Now in the Bootstrapper we need to register our mapping.

Now we simply give the Map a region name. (this is actually all the shell has in it)

That is all there is to it.  You can now start injecting modules onto the Map at runtime.  Lets look at my two modules I am using as an example.  Here is the structure of my application:

• ModuleA will inject a MapPolygon in the Shape of Texas.
• ModuleB is the Earthquake application we built in an earlier post.
• Infrastructure is the project where shared code goes, in this case our MapRegionAdapter
• BingMapsPrismfiedDemo is of course our shell project.

This is what the application looks like at runtime when both modules have been injected into it.

Now I can easily add more layers to this map as I see fit.  As always, Download the Source and start playing.  You may want to add MEF support as well.

Let’s start with the Geocode Service which is used to match addresses, places, and geographic entities to latitude and longitude coordinates on the map, as well as return location information for a specified latitude and longitude coordinate.  We will create a simple application that allows you to enter an address and place a pushpin at that location.  First thing is first:

1. Get the Bing Maps WPF control.
2. Get a Bing Maps API key.

You MUST have a Bing Maps API key in order to use any of the SOAP services.  Now that you have that out of the way let’s write an application. Create a new WPF application targeting the .NET 4.0 framework. Add a reference to the Microsoft.Maps.MapControl.WPF.dll. This will most likely be located in Program Files or Program Files (x86) –> Bing Maps WPF Control –> Beta –> Libraries.

Open up your App.xaml.  You need to add an ApplicationIdCredentialsProvider as a resource and enter your ApplicationId:

Now create a very simple UI that will accept an address and a button to perform the geocoding:

The next thing we need to do is add a new Service Reference to the project and point to the following service:

http://dev.virtualearth.net/webservices/v1/geocodeservice/geocodeservice.svc

Give your service a name (I called mine BingMapsService) and just for fun, in the “Add Service Reference” dialog, click the “Advanced” button and click “Generate asynchronous operations”.

Next we need to create a ViewModel to support our View.  This is a WPF application after all.  This ViewModel will need a command for the button that will perform the geocoding, and a property that will represent the result of the service that the UI will use to map the address.  It should resemble something like this:

I want to point out that the DelegateCommand<T> is a very simple ICommand implementation and should NOT be used in production applications.  Here is the code:

Let’s hook our UI up to our command.  it should look something like this:

Notice that we are using the text of the TextBox as the CommandParameter.  Next, we need to implement the command:

In this command we are simply creating an instance of the service client, creating a GeocodeRequest, setting the credentials using the ApplicationId we have stored in the App.xaml, and then using the address as the Query for the request.  When the call to the service is completed we are setting the GeocodeResult property to the first element in the results.

Now the tricky part.  We want to place a Pushpin on the address that was entered and then move the map to that location.  We also need to make sure that when another address is entered, we clear any previous Pushpins that may exist on the map.  We also have to be aware that other elements my be on the map and we don’t want to accidentally alter those elements.  Oh and did I mention this was an MVVM application and this has to be done with just data binding?

The approach that I decided to go with is to use Attached Properties.  So I created two attached properties; one for the GeocodeResult and another for a MapLayer that will be dedicated to the GeocodeResult.  This will allow us to create a MapLayer that is specific to our GeocodeResut and not alter any other elements that may be on the map.  Let’s check out the code.

Notice that when the GeocodeResult changes we get the Location and create a pushpin for that location.  We also set the tooltip to the FormattedAddress of the GeocodeResult.  So when we hover over the pushpin we will see a nice little tooltip of the address.  Next we try to get the GeocodeResultLayer from the map, if it is null this means it doesn’t exist on the map yet so we create one and assign it accordingly.  We clear the layer child elemnts and then add out pushpin.  The last thing we do is call the SetView method of the Map control passing in the location and the current ZoomLevel.

The final step is to use our AttachedProperty on the map.  Be sure to create a namespace for the MapInteractivity class and define it as follows:

One last thing.  Be sure to remember to set your DataContext of your View to the ViewModel we have created:

That’s it.  You now have an application the can map (geocode) an address using the Bing Maps WPF Control and the Geocoding SOAP Service.  Oh and we are doing this all with MVVM and data binding which is my favorite part.  Be sure to Download the Source and start playing around.

1. Get the Bing Maps WPF control.
2. Get a Bing Maps API key. (not needed for development)

Now that you have that out of the way let’s write an application.  Create a new WPF application targeting the .NET 4.0 framework.  Add a reference to the Microsoft.Maps.MapControl.WPF.dll.  This will most likely be located in Program Files or Program Files (x86) –> Bing Maps WPF Control –> Beta –> Libraries.  Next you need to declare a namespace in XAML:

Not much to look at, but it’s definitely a map. Notice that because we are not using an API key we get a nice little message that tells us where to get one.  Well this is great and all, but we want to see earth quakes!  So let’s start doing the real coding now. We know we will need an object to hold information about the earthquakes.

That should take care of that.  Next we need data about earthquakes and their locations.  Luckily for us there is a free resource available to grab this information from USGS.  So let’s write a simple service to get this information:

The last thing we need is a ViewModel that will expose our earthquakes from consumption by our view:

Don’t forget to set the DataContext of the view to our ViewModel:

Here is what you will see when you run the application:

HEY! Where the hell are my earthquakes?  This thing sucks!  Piece of sh….. Oh wait, I need to tell the map how to render the earthquakes.  So we need to create a DataTemplate:

And don’t forget to specify the ItemTemplate:

Now let’s see what we get when we run the application:

Hey look! Earthquakes.  That is so cool. But wait, I want to see information about the earth quake.  Preferably in a popup when I hover over a Pushpin.  Well Lets wire that up real quick.  First we need to add a MapLayer to the map that will act as our popup:

Now we need to add some event handler to the ItemTemplate.

We have added two event handlers; one for when we mouse over and the other for when the mouse is no longer over the pushpin.  Notice that I am storing the bound item in the Tag of the Pushpin object.  We will need that to change the location of popup.

Now when we hover over the Pushpin we get some useful information about the earthquake:

That’s it for this application.  The Bing Maps WPF Control has been a long awaited control and I am glad it finally made it to WPF.  As you can see it is pretty easy to use as well.  Now you can Download the source and start playing.

Calculator

The Calculator is a control used for performing mathematical calculations.

It provides basic math functions, memory functions, as well as mouse and keyboard support.

CalculatorUpDown

The CalculatorUpDown provides a TextBox with button spinners that allow incrementing and decrementing numeric values by using the spinner buttons, keyboard up/down arrows, or mouse wheel. It also provides a Calculator dropdown which allows you to perform mathematical calculations.

ColorCanvas

The ColorCanvas allows you to select a color either using an advanced color canvas, by setting the HexadecimalString, or by setting the ARGB values.  This control has also been merged with the ColorPicker to provide advanced color editing abilities.

DateTimePicker

Get the best of both worlds. The DateTimePicker provides a DateTimeUpDown control as well as a dropdown with a calendar and a TimePicker.

DecimalUpDown

The DecimalUpDown control provides a TextBox with button spinners that allow incrementing and decrementing Nullable<Decimal> values by using the spinner buttons, keyboard up/down arrows, or mouse wheel.

When using the DecimalUpDown in data binding scenarios, bind your object’s value to the Value property. You can specify how much to increment the value by setting the Increment property. You can control the minimum and maximum allowed values by setting the Minimum and the Maximum properties. You can also specify if the user can directly edit the values in the text box by setting the IsEditable property. If you would like to get the actual fromatted string representation of the value, you can use the Text property.

DoubleUpDown

The DoubleUpDown control provides a TextBox with button spinners that allow incrementing and decrementing Nullable<Double> values by using the spinner buttons, keyboard up/down arrows, or mouse wheel.

IntegerUpDown

The IntegerUpDown control provides a TextBox with button spinners that allow incrementing and decrementing Nullable<int> values by using the spinner buttons, keyboard up/down arrows, or mouse wheel.

PropertyGrid

The PropertyGrid is a pure WPF replacement for the WinForm PropertyGrid control.  Currently the PropertyGrid is in beta and still has a lot of work to be done on it.  But it is ready from simple use and testing.

SplitButton

The SplitButton control is a button that can be clicked and also provides a drop down in which you can place any custom content within.

TimePicker

The TimePicker is a control that is specifically for the Time portion of a DateTime property.  It provides a ButtonSpinner as well as a list of times to choose from.  You can also manually type in the time as long as it matches the specified format.

WatermarkTextBox

The WatermarkTextBox is simply a TextBox that allows you to sepcify an object, usually a String, to represent null or missing text.  Don’t think you are limited to just text!  With this control you may use any object as a watermark.  Here is an example using an image with text:

Also, all input controls in the Extended WPF Toolkit now provide a Watermark option.

That’s it for the new controls.  I hope you enjoy version 1.4.0 and be sure to report any bugs or request new features in the Issue Tracker.  As always if you have any questions be sure to ask them in the Discussions.

And thanks to the generosity of the AppHarbor team, we were able to raffle off a Reflector license to one of our attendees!

Getting Started with AppHarbor

You can find many blog posts (and videos) detailing the process of getting started with AppHarbor (see below).  But the basic scenario comes down to these steps*:

1. Installing and configuring Git. (I use msysgit and Git Extensions.)
2. Initialize a repository for your application.
3. Deploy your application to AppHarbor. (If you do not have an AppHarbor account yet, feel free to use this referral link.)

* If you prefer to use Mercurial, follow these steps instead.

If you develop .NET web applications and haven’t tried out AppHarbor yet, do so…Now! I did mention the service is free, right?!?

Mimicking AppHarbor Deployment

Disclaimer: The process I am about to describe is informational and not prescriptive. AppHarbor provides much more value than just deployment, and I do not want to detract from that in any way.

If you have read my previous posts, you know that I use TeamCity and Rake for my build server environment. So I thought I would try to mimic the AppHarbor experience using those tools.

In order to follow along you will need to:

1. Install Git on your development workstation and build server
2. Install Ruby on your build server
3. Install TeamCity on your build server
   * If you need to learn how to install and use TeamCity, I posted a series on TeamCity 4.5.
4. Install Web Deployment Tool 2.0 on your build server and IIS web server
5. Start the web deployment service on your IIS web server
   

* For the purposes of the user group presentation and this post, my development workstation, build server, and web server are all on the same machine.

We need to manually provision much of the infrastructure that would be provided for us automatically by AppHarbor, including:

• Configure the web application in IIS
• Set up a bare Git repository
• Configure TeamCity to watch the bare repository (VCS Settings)
• Use customize build scripts in TeamCity (Build runner/task)
• Push your application to the TeamCity repository

Other tasks I will not be considering for this sample include database provisioning and custom configuration variables.

Remember, with AppHarbor, the initial provisioning takes a matter of seconds. With that, let’s get our environment ready.

Configure the web application in IIS

1. Create a folder on your web server to store the website. (e.g., c:\sites\sample)
2. In IIS, create a new virtual directory under the default site and set the path to the folder you just created. My virtual path is sample.
3. Note the IIS application path. Mine is Default Web Site\sample. My url will be http://localhost/sample.

Set up the bare Git repository

1. Create a folder to store your bare repository. This is the repository TeamCity will watch and use to get code to build. You can create the repository on the build server or on a remote server.  (e.g., c:\repos\sample.git\)
2. Right-click the folder and run the Git Bash from the context menu
3. In Git Bash, type git init –bare

Configure the TeamCity build configuration

1. Create a new project (e.g., Sample)
2. Create a new build configuration (e.g., Deploy) and name it
3. Leave all other settings on the first page of the wizard at their default
4. Attach a new VCS and name it
5. Select Git as the VCS type
6. Set the Fetch URL to the bare repository you just created (e.g., c:\repos\sample.git)
7. Leave all other settings at their default
8. Add a new build task
9. Select Rake as the build runner
10. Select Rakefile content and copy the following into the textbox (Update the site path and project names as appropriate)
    

    require 'rubygems'
    require 'erb'
    require 'fileutils'
    require 'find'
    require 'rake'
    require 'rake/tasklib'
    
    task :default do
        package_location="sample/"  # website folder location relative to checkout root
        project_file =  "sample/sample.csproj" # website project location relative to checkout root
        package_name = "website"
        package = "website.deploy.cmd"
     
        destination_site = 'Default Web Site/sample' # Change to match IIS path
        clr_version = 'v4.0.30319' 
        framework_dir = File.join(ENV['windir'].dup, 'Microsoft.NET', 'Framework', clr_version)
        msbuild_file = File.join(framework_dir, 'msbuild.exe')
    
        FileUtils.remove_file("#{package_location}#{package}", true)
        FileUtils.remove_file("#{package_location}#{package_name}.zip", true)
        FileUtils.remove_file("#{package_location}#{package_name}.deploy-readme.txt", true)
        FileUtils.remove_file("#{package_location}#{package_name}.SetParameters.xml", true)
        FileUtils.remove_file("#{package_location}#{package_name}.SourceManifest.xml", true)
    
        # Package website (requires VS2010 version of msbuild)
        sh "#{msbuild_file} \"#{project_file}\" /maxcpucount /nr:true /v:m /T:Clean,Package /P:BuildInParallel=true;WarningLevel=0;Configuration=debug;DeployIisAppPath=\"#{destination_site}\";PackageLocation=#{package_name}.zip"
    
        # Deploy website (requires Web Deployment service running on web server)
        sh "#{package_location}#{package} /M:localhost /Y \"-skip:objectName=dirPath,skipAction=Delete,absolutePath=logs\""
    
    end

    view raw rakefile.rb This Gist brought to you by GitHub.
11. Leave all other settings at their default
12. On the Build Triggering page, add a new VCS trigger to build on a VCS change.

Whew! Now that all the infrastructure is in place, let’s do this!

Push your application to your TeamCity repository

1. Assuming your local Git repository is set up and you’re application is ready to deploy…from Git Bash in your local repo, add your remote repository.  Given the settings described above, I would use the following command: git remote add teamcity /c/repos/sample.git
2. Then type: git push teamcity master
3. In less than a minute, TeamCity should start to package and deploy the website.

Using TeamCity for deployment takes markedly longer than AppHarbor. TeamCity uses a polling interval to determine if there are changes; whereas, I assume AppHarbor is using a git post-commit-hook. As an aside, if you haven’t already, start looking into the Web Deployment Tool.

Auto-provisioning and super-fast deployment on an elastic infrastructure…wish I had implemented it first.

Update:

A bug was introduced in Visual Studio 2010 SP1 which causes an error when deploying with parameters. You may need to update your Microsoft.Web.Publishing.targets file referenced in the KB article (although I cannot confirm that this fixes the problem, yet).

It took about and week and then Nancy got the first pull request on her github account and from there it started to build up momentum quite fast. At the time of this writing there’s been 53 pull requests, by about 20 different people, for all kinds of features, bug fixes, custom hosts… you name it. Not bad, eh?

Not only that, but Nancy has managed to pull together a nice little community, over at Google Groups, where the future of Nancy is being discussed every day. She’s also getting some attention on Twitter and we’re trying to gather it all under the #NancyFx hashtag and seems like every day there is a new face popping up.

In the initial commit there were a couple of abstractions and light extension points in place for things like custom hosts, view engines and response formatters. These turned out to be a very smart move, because the community really embraced and ran with them. Let me recap some of the things that has happened since day zero

• View engines; there are currently support for Spark, Razor, NDjango and Static templates. We did have support for NHaml for a while, but that community seems to have gone into hibernation, so the decision was made to pull it and not waste dev cycles on it until there was a demand
• Inversion of Control integration; this has been one of the big one. Right from the very first beginning I wanted Nancy to be a self composing framework, that is have a small internal container that glued the framework together at runtime. I also wanted the possibility to register module level dependencies. It took a while and a couple of iterations, but we finally settled on a design and made TinyIoC the internal container. It was very important that it was a transparent experience to the end user and unless you have a need for it, you never know it’s there. Not only that, but thanks to community contributions we’ve managed to create hooks (known as bootstrappers in Nancy) for all of the major players such as StructureMap, Autofac, Unity, Ninject and Windsor. Using one of these container with Nancy is a very easy thing to do and only adds one more file to your project
• Response formatters; one of the powerful features in Nancy is the response model and how it lets you return different kinds of things and leverages implicit cast operators to hide the complexity behind it. Thanks to the awesome Nancy community we now have the capability to return JSON, XML, images and perform redirect responses. It’s super easy to write a response extension and hook it into Nancy, so if you have any ideas….
• Bug fixes; yeah I know, it’s shocking, but it’s still true. Every now and then someone finds a bug but, more importantly, most of the time the same person is part of contributing a patch to resolve it!
• Hosts; Nancy has been designed with the idea of being able to run in multiple environments and shipped with a host to run on top of ASP.NET. Right now we have additional hosts for running Nancy on a WCF host and on a stand alone host. There are more of them on the way
• HEAD requests; the first release of Nancy supported GET, POST, PUT and DELETE requests, but thanks to a clever little contributions she now also serves up HEAD requests
• Cookies; not he ones you can eat….
• Cookie based sessions; I think this is also self describing.. oh… yeah they are encrypted in case you were wondering!
• Mono; we’ve started to seriously look at getting Nancy to run on top of the up coming mono 2.10 release (we need the improvements they’ve made to the dynamic keyword) and have already managed to run the sample application on both Linux and Mac OSX. Moving forward mono is going to be a supported and equally priorities platform to support
• Visual Studio templates; these are still work in progress but right now I have the ability to new up a new Nancy project, based on the html5boilerplate … and we have a bare bone template in the making
• Buildscript; a couple of days a go we added what every self respecting open-source project needs; a build script. We choose to use Rake (that’s a ruby powered format, for those of you that’s never seen it before) and make use of the excellent Albacore gem, but the awesome Derick Bailey

I’ve probably forgotten a bunch of things, there’s been so much going on that I can’t remember it all without looking at the commit history! That said, there are still things we want to put in place and there are already extensive discussions on the user group about them

• Security
• Content negotiation
• OWIN hosting (we’re keeping track of the OWIN 1.0 specification)
• Self-hosting (Benjamin van der Veen, if you are reading this – maybe Kayak can be a candidate!)

The one thing that we can’t seem to pull of

Is to find a designer to design a proper logo for the framework! We are in desperate need to get an awesome logo that we can put everywhere and start creating a website. So if you know any good designers that wouldn’t mind putting in some time in designing an awesome logo for an open-source project (read pro bono) and please tell them about us and about Nancy! A while back I created a post about the Nancy logo on our user group. It contains some information on the philosophy and goals for a logo for Nancy. I can’t stress enough how much I would appreciate if you took this and shared it with your designer friends!

As always, if you want to ping me either drop me a comment right here on the blog or find me on on Twitter account @TheCodeJunkie

… I can’t help to wonder what Nancy will be like in another two months!