Archive Page 2

Project StoneHenge Podcast from the ConnectedShow

The ConnectedShow podcast is a new podcast created to help Developers get up to speed with .NET technologies.  They just recently posted an episode related to Project Stonehenge, a project I’ve been working with recently.

ConnectedShow Podcast #8: Project Stonehenge

http://www.connectedshow.com/default.aspx?Episode=8

Keep up the good work Dimitry and Peter

Microsoft and Sun commit to support WS-* standards by building interoperating reference applications under “Project Stonehenge”

At the JavaOne conference on June 4, Dan’l Lewin and Steven Martin from Microsoft appeared for the keynote to announce their further support of Interoperability. This effort is backed by Sun joining the Apache Stonehenge Incubator project. Stonehenge is sponsored by the Apache Software Foundation, a leader in the Open Source community, and was created to build reference applications that demonstrate the use of WS-* Standards in real-world project implementations.

This came at a great time,  the StoneHenge project just completed their M1 release of the StockTrader application.  M1 comes complete with installation guides and interoperability walkthroughs for connecting .NET, PHP, and WSO2’s Web Service Application Server (WSAS), a Java implementation.

The Sun Metro implementation discussed at JavaOne is currently contributed to the project.  Additionally, there is a patch available for the .NET stack that supports this Metro implementation.  The commiters at Stonehenge hope to have the Metro Implemetation added to trunk by the M2 release.

This is really good news, as I mentioned in my previous post, I’ve recently been contributing to the StockTrader application.  This announcement in some ways confirms the success and commitment to open standards and interoperability in enterprise environments.  Although, the real success and adoption is now in the hands of the Open Source community.  That being said, I’d like to take this opportunity to once again encourage developers to take a look at the Apache Stonehenge project, download the bits, and offer feedback and support.

Updated jQuery formatCurrency plugin posted on GoogleCode

After receiving some comments on my formatCurrency plugin regarding international support I decided to create an official release of the formatCurrency jQuery plugin.

The new plugin is available on the Google Code at http://jquery-formatcurrency.googlecode.com.

Thank you to everyone on for your downloads and comments. Please contact me if you are interested in becoming a member on the project.

Create SendAsync Convenience Extensions for the WCF REST HttpClient to GetAsync and PostAsync

I recently had the pleasure of speaking with some industry icons. We compared some RESTful jQuery code with the new HttpClient code from the WCF Rest Starter Kit Preview 2. The line by line comparison on the code was quite similar (the WCF REST team has done an excellent job with this API, I’m always amazed at how easy it is to use), the main difference was that the jQuery code was transmitting asynchronously. After our conversation, I decided to create these convenience extensions to give developers an API for using lambda expressions to call RESTful services asynchronously in .NET.

Download

In this application I use the jQuery code from my Intro to jQuery presentation and the Live Search WPF Application. The first method I wrote was the GetAsync extension, and after realizing how simple it was I created this entire Extension Library. Additionally, since all the code fit nicely into a single class I’m going to publish the code as a single cs file. As usual, I’m also including the Sample application for download.

HttpAsyncMethodExtensions.cs (12.1KB)

HttpClientExtensions Sample WPF Application (Compressed Zip, 13.1KB)

Code Comparison

The goal of this API was to mimic the jQuery AJAX code that I had previously written. Here is a actual ajax portion of the jQuery code that retrieves some google search results:

$(document).ready(function() {
	$('.getGoogle').click(function(e) {
		//  Prevent the event and Set Loading Message
		e.preventDefault();
		$('.results .noResults').html('Loading...');

		// Generate the google Url
		var googleUri = "http://www.google.com/search?q=" + $('.searchText').val();

		// Send Async GET call
		$.get(googleUri, {}, function(html) {

			// Parse result and create placeholder
			var google = $(html);
			var ul = $('<ul />');

			// find links from results
			$('.g .r .l', google).each(function() {

				// create the list item, generate the list item, and add it to the placeholder
				ul.append($('<li />')
					.append($(this).clone().removeAttr('onmousedown')) // this.clone() clones the google link
				);
			});

			$('.results').append(ul).find('.noResults').remove();
		});
	});
});

Using this jQuery code as a guide I created the usage code first:

private void Search_Click(object sender, RoutedEventArgs e)
{
	// Set Loading Message
	this.Items.Clear();
	this.Items.Add("Loading ...");

	// Generate Google Uri
	const string googleApiUrl = "http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q={0}";
	var uri = string.Format(googleApiUrl, this.SearchText.Text);

	// Create Client and Send Asynchronous GET
	var client = new HttpClient();
	client.GetAsync(uri, (s, r) =>
	{
		// Clear Loading Message
		this.Items.Clear();

		// Parse Results
		var results = r.Response.Content.ReadAsJsonDataContract<GoogleResults>();

		// Find and add the results
		this.Items.AddRange(results.responseData.results.Cast<object>());
	});
}

I tried to keep the two samples consistent, and as you can see the HttpClient code is 5 lines smaller than its jQuery counterpart. Unfortunately, these samples are not identical implementations. For instance, one client is a web browser and the other is a WPF application. Additionally, both projects have additional code, behind the scenes. But since the goal was to create a similar API I think it works.

HttpClient Extension Methods

What you may not know, is that the HttpClient gains most of its leverage from extension methods. The core functionality of the HttpClient is in its Send method. In the existing API, the Get, Post, Put, Delete methods are extension methods which simple call Send. Using that same concept, here is a GetAsync extension method to the HttpClient:

public static class HttpAsyncMethodExtensions
{
	public static void GetAsync(this HttpClient client, string uri, EventHandler<SendCompletedEventArgs> completed)
	{
		// register callback
		client.SendCompleted += completed;

		// call SendAsync
		var message = new HttpRequestMessage(HttpMethod.GET.ToString(), uri);
		client.SendAsync(message);
	}
}

The HttpClientAsyncExtensions Library, that is downloadable above, contains the full implementation of these extension methods for SendAsync, GetAsync, PostAsync, PutAsync, DeleteAsync, and HeadAsync. There are also a few overloaded helper methods to avoid repeating code.

Conclusion

I think its great that we have the ability to choose between synchronous and asynchronous processing of remote calls. Unfortunately, the amount of code required to perform these tasks is often quite different.

We’ve all seen applications that block the UI thread while executing a long running task synchronously. I’m not sure if this is because of the tools or because of a lack of knowledge around asynchronous programming. Either way, developers often feel that asynchronous programming is difficult.

I’m hoping that these extension methods will show that this doesn’t have to be the case, and that we can actually make remote services calls asynchronously with very little code.

Contributing to the Apache StoneHenge Incubator Project

I’m currently following the Apache StoneHenge Project.   This is an Incubator project that demonstrates using WS-* Standards to interoperate between multiple platforms.  The flagship project is the StockTrader application which currently has an implementation where .NET, JAVA, and PHP can communicate using standard SOAP messages or encrypted SOAP messages. 

StoneHenge is a great project and since it is in this early phase of incubation they’re still looking for new members.  Below is some useful information for getting started.

Proposal

“The aim of the Stonehenge project is to develop a set of sample applications to demonstrate seamless interoperability across multiple underlying platform technologies by using currently defined W3C and OASIS standard protocols.”  Full proposal

Microsoft MSDN StockTrader

The Apache StockTrader application is a subset of MSDN StockTrader Project.  There is no need to install this, it’s just helpful to know that this project exists.

StoneHenge Links

Apache Links

Connecting to Live Search using the HttpClient

Preview 2 of the WCF REST Starter Kit has been posted to CodePlex. Check it out at http://tinyurl.com/wcf-rest-kit2. Included in this latest release of the WCF REST Starter Kit are a great new set of client connection tools that make consumption of RESTful services a breeze.

At the forefront of these client connection tools is the HttpClient. This class allows quick and easy access to download any content from a url. I’ve created a simple WPF Application that demonstrates using the HttpClient and the Live Search API.  For more information on the LiveSearch API or to get your LiveSearch API Key goto http://dev.live.com/getstarted/

Click here to Download the Full Source Code

Windows Live Search WPF Application

This WPF Application consists of a Window with some code-behind,  and a LiveSearch.cs file that was created using the Paste as XML Type feature of the WCF REST Starter Kit.  Before you can serialize your results from the Live Search API you need to run the query in your browser and copy the xml results into your clipboard.  After that you can go into Visual Studio and create a file in your project called LiveSearch.cs and then go to Edit-> Paste as XML Type.  As for the WPF Window it has a Grid with 2 rows and 3 columns.  In the top row is a search textbox and two buttons.  In the second row is a ScrollViewer that contains an ItemsControl. 

The first button does a single threaded search call to the Live Api and sets the ItemsSource of the ItemsControl.  As you can see by the code below its very simple, first we construct the uri, then we call .Get on that uri.  The Get call returns an HttpResponseMessage.  The response message has a number of different chaining methods and extension methods,  we are using the EnsureStatusIsSuccess, which is equivalent to the EnsureStatusIs(HttpStatusCode.OK).  After we call EnsureStatusIsSuccessful (which returns the original message or an exception) we can read the content.  In this case we are reading the content as a xml serialized response of the type created above using the Paste as XML Type feature.

private void Search_Click(object sender, RoutedEventArgs e)
{
      string liveApi = "Your Live Api";
      string uriFormat = "http://api.search.live.net/xml.aspx?AppId={0}&Market=en-US&Query={1}&Sources=web&Web.Count=25";

      using (var client = new HttpClient())
      {
          string uri = string.Format(uriFormat, liveApi, this.SearchText.Text);

          var response = client.Get(uri).EnsureStatusIsSuccessful()
              .Content.ReadAsXmlSerializable<SearchResponse>();

          this.Results.ItemsSource = response.Web.Results;
      }
}

Since its not recommended to run potentially long running operation on the UI thread.  I created a second button to demonstate the Live Search feature using the SendAsync method.  Below is the code for that.

private void SearchAsync_Click(object sender, RoutedEventArgs e)
{
      string liveApi = "Your Live Api";
      string uriFormat = "http://api.search.live.net/xml.aspx?AppId={0}&Market=en-US&Query={1}&Sources=web&Web.Count=25";

      var client = new HttpClient();
      string uri = string.Format(uriFormat, liveApi, this.SearchText.Text);

      client.SendCompleted += client_SendCompleted;
      client.SendAsync(new HttpRequestMessage(HttpMethod.GET.ToString(), uri));
}

void client_SendCompleted(object sender, SendCompletedEventArgs e)
{
      var response = e.Response.EnsureStatusIsSuccessful()
              .Content.ReadAsXmlSerializable<SearchResponse>();

      this.Results.ItemsSource = response.Web.Results;
}

Feel free to download the full demo using the link above, I hope you enjoy it. The new client connect features of the WCF REST Starter Kit create a really simple way of communicating with third party REST services.

Introduction to jQuery Presentation

I just finished my Introduction to jQuery presentation at the NYC Web Design Meetup.  Thanks for all that attended.  We had a really good time and had lots of great questions.

Download

I’ve posted the presentation and demos online.

Intro to jQuery.zip

Note

I made some minor changes to the Google AJAX sample.  The sample shown at the meeting didn’t support repeated clicks of the Get Google Links button.


What else am I doing?

StackOverflow Facebook Twitter LinkedIn Live

Twitter

Pages

May 2017
M T W T F S S
« Feb    
1234567
891011121314
15161718192021
22232425262728
293031