I did add some additional bullet points and text content to the slide deck since I’m not a big fan of standing in front of a bunch of that during a presentation and would rather talk with the attendees and show some code. Either way, check the slides out if you’d like.

http://www.slideshare.net/adammokan/introduction-to-signalr-10082193

Next up is some tweaks to my samples, which were not cooperating with me so much during my session. I will expose that repo on Github soon and post an update.

Enjoy.

Based on the test yesterday, I dug up an old blog post by Steve Marx (@smarx on twitter) that demonstrated running the Mongoose web server in a Windows Azure Worker Role on port 80. Using his example as a basis, I did the same with node.exe and it worked on the first attempt.

Check out the live site here* - http://nodetest.cloudapp.net/

node.js worker role in my azure dashboard

worker role settings in azure

I’ve not even messed with nvm or npm on Windows (and have no clue if they even work yet) or frameworks such as Express, which I enjoy for larger node projects. Here is a gist for the basic sample in the project. Even if you have never looked at node (but understand HTTP), it should be fairly clear.

I have posted the full source for the entire project on github and you should be able to simply download/clone and deploy to Azure with no issues. As mentioned in the readme file, the node application code is in the src/WorkerRole/node/ directory, along with node.exe itself.

I used a single ‘Extra Small’ instance and OSFamily ’2′ in case I wanted to do anything more advanced with PowerShell later on. I’m sure OSFamily ’1′ would be perfectly fine.

Github source - https://github.com/amokan/node-on-azure

If anyone else is doing any work with node.exe in an Azure role, be sure to post your findings and let’s see how far we can push this thing. Node is an amazing piece of technology and a great solution for high-performance APIs and shows the true power of JavaScript. The next step is integrating node with Azure Table Storage and other features in the Azure ecosystem. Maybe that’s already been done?

* I will leave the live sample running on Azure for a while. If the extra small instance gets slammed for some odd reason, I will drop it and update the post.

On deck, in no particular order :

• A detailed post (with code and a Templify template to get you started) on a generic repository pattern for ASP.NET MVC 3 and Entity Framework 4.1 along with a unit tests that utilize SQL Compact edition that automatically create a new SQL Compact file upon starting tests, populates the schema with sample data, and then subsequently deletes the file after tests are complete. Dependency injection is done via Ninject, which is my IoC of choice for MVC3.
• A post on consuming portable areas in MVC 3 for a plugin-like architecture. Think “modules” that can be dynamically loaded.
• A post on the MVC lifecycle and when and why to use the various filter interfaces provided by ASP.NET MVC3.
• A post on Node.js from a .NET developers perspective and how to get started with hosting, the current state of node on Windows and so-on.
• A post on custom HtmlHelpers for MVC3 showing various techniques to keep those views nice and DRY.
• A post on running JetBrains TeamCity 6.5 in the cloud using Amazon’s EC2 “micro” instance and automatically bringing up build agents and terminating them after the build. The post would be aimed at .NET development.

It’s been a fairly successful start, although I’m the first to admit my raw JavaScript skills have gotten rusty after years of web forms and, more recently, relying on things like jQuery for UI work in my web applications. Combining that with my first heavy foray into Mongo, which I’ve tinkered with in the past, and it’s provided a lot of excitement for me to learn some totally new approaches to system architecture which always inspires me to look at how to leverage some of the approaches/techniques to my primary role as a .NET consultant.

As with many edge frameworks, node.js is easy to get going with on OSX or Linux. Windows is a bit trickier, but Tatham Oddie posted a good little tidbit of info explaining how to get node up and running using the MinGW approach described. I tried this last night on my Windows7 boot and it worked pretty well.

I encourage those of you who at least haven’t looked into node.js to do so. Just to understand what it is. I’m not looking at this as a replacement for Rails, Sinatra, ASP.NET, or anything like that; But for an API that just responds to and receives data via RESTful calls, it seems ideal.

Once I get the project wrapped up, I plan to do some more posts showing what I’ve learned and pitfalls to avoid, from a .NET-developers perspective.

Here is a bundle thanks to bit.ly and bridgeurl.

http://bit.ly/sevdnug_mvc3_presentation_links

That brings me to (one of) the jQuery Autocomplete plugins. I need this functionality in an ASP.NET webforms application and wanted to give it a shot. I started messing with “jQuery Autocomplete plugin 1.1″ by Jörn Zaefferer. You can find the code and info at http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/. 

I’m mostly interested in doing an autocomplete via a remote web service call that returns json data. The example in the zip file includes a little php page that just responds to a HTTP-GET and spits out some hard-coded json. I’m working in .NET, so I made a simple ASMX web service to query my database and return a DataTable as json. (Note – There are isues with the built-in serializer to return a DataTable as json. A google search will find you a number of functions or alternate ways to generate a json string from a DataTable.) 

Right away, I found I was having problems with the autocomplete in this environment. First off, you have the whole issue with ASMX web methods only accepting a POST by default. This is easy to change, but not advised. You can find info on that issue here – http://encosia.com/2008/03/27/using-jquery-to-consume-aspnet-json-web-services/ and some other good info here – http://encosia.com/2008/06/05/3-mistakes-to-avoid-when-using-jquery-with-aspnet-ajax/ 

You’ll also notice in the above blog links that there can often be issues when POST-ing to a web method with encoding set to json, that you will need to pass your json params as a string. If you’re using something like Firebug to watch your ajax posts, you’ll catch this right away. 

But the main issue for me were the assumptions that the autocomplete plugin makes. It, by default, will only do a HTTP-GET. You can use the $.ajaxSetup in jQuery to set your future ajax calls to a default, but I wanted the ability to make this decision when calling the autocomplete plugin. 

I made these changes to jquery.autocomplete.js in the $.ajax section :

$.ajax({
// try to leverage ajaxQueue plugin to abort previous requests
mode: "abort",
// limit abortion to this input
port: "autocomplete" + input.name,
dataType: options.dataType,
//setup new options for asmx - amokan
type: options.httpMethod,
contentType: options.contentType,
//end new options - amokan
url: options.url,

This allows me to now handle my client side code a little better.

$("#task").autocomplete(
"http://somecomputername/jsonServiceTest/Testing.asmx/GetSomeDataNoParam",
{
dataType: 'json',
httpMethod: 'POST',
contentType: 'application/json; charset=utf-8',
max: 100,
scroll: true,
matchContains: true,
minChars: 3,
parse: function(data) {
var rows = new Array();
//your parsing logic
},
formatItem: function(row, i, n) {
//do something
},
width: 260
}
);

I’m still working on cleaning up the data parameter section of the plugin a bit before I post the full code.
If you’re curious, here is my ASMX method. Be sure to add the [ScriptService] attribute to your class in the ASMX file so it can handle AJAX properly. If you are using an older .NET without the System.Web.Script.Services namespace, this will not work for you. Note that the parameters “q” and “limit” are sent automatically by the autocomplete plugin. “Q” is the string currently typed into the text control so you can filter your query based on what the user has typed and “limit” is the max number of rows. Obviously, its up to you to implement these in your query if you chose to.  

[WebMethod]
[ScriptMethod(UseHttpGet = false, ResponseFormat = ResponseFormat.Json)]
public string GetSomeDataNoParam(string q, int limit)
{
DataTable dtSomething;
//connect to db, do your exception handling, etc
dtSomething = //your DAL or whatever you use
//use my method to parse the datatable into json
return GetJSONString(dtSomething);
}

Hope this helps a bit and I will be sure to upload some more code as I get this working a bit smoother in my environment.