Michael Ballhaus (MCPD + SCJP)

LinqToBitTorrent - a custom .NET Linq provider for BitTorrents

2010-02-10T18:57:11-05:00:00

LINQ to BitTorrent is a custom .NET LINQ query provider implementation that translates LINQ queries into HTTP requests that accesses various BitTorrent search engine APIs and RSS feeds.

Full documentation will be posted here soon...

You can freely download the source code and/or binaries from the Codeplex site as well as view a live demo of the provider.

LinqToWikipedia - A custom .NET Linq provider - Part II

2010-01-29T13:10:16-05:00:00

This article is a two-part series regarding the LinqToWikipedia provider. The first article covers the basic concepts of Linq as well as the client usage of this particular provider while the second article covers the inner workings of the LinqToWikipedia provider to give you an understanding of what it takes to create your own IQueryable provider.

NOTE: You should download the latest build from Codeplex so you can follow along with the code samples.

Creating your own IQueryable provider

First off we have to ask ourselves the question..."Why would we want to create our own IQueryable provider?" It certainly isn't the easiest coding task that you'll undertake, the internet isn't exactly overflowing with end to end simple examples of how to accomplish this. What benefits do we really get out of doing this?

Well we already know the advantages of using Linq, we already covered that in my previous article; allowing for a consistent querying syntax, whether using Linq or Lambda expressions, no matter what the data source of the data gives us a pretty good first reason to build our own provider. Here are a couple more potential uses:

You have several applications in your organization that need to verify addresses. You could write a Linq provider that would translate queries to consume the United States Post Service API's to verify physical address locations.
Your organization has employee demographic data in various systems such as PeopleSoft, Active Directory, etc. You could write a Linq provider that allows applications to query and return employee data from these various systems in one result set.
You maintain websites for Real Estate agents and want to give potential customers the ability to look at the value of nearby homes in a certain area without leaving the agent's website. You could write a Linq provider that would connect to the Zillo.com API and return a wealth of information for the user to gauage the value of a potential home.

So we discussed some reasons why you may want to create your own IQueryable provider, let's walkthrough the LinqToWikipedia provider to show you how you can create you own provider.

NOTE: I am only going to show code highlights of important concepts, but you can always download the full source code from CodePlex to view the code in it's entirety. Additionally, to keep the examples simple I will only focus on the OpenSearch functionality of the provider

At a high level, there are two interfaces that you will need to implement in order to create your own IQueryable provider:

IQueryable<T>
- We implement this interface so that our results will be able to be enumerated over
IQueryProvider
- We implement this interface so that we can examine the query (expression tree) to perform any translations to create our actual query for whatever API we are calling into and then execute the query

Before we get into the actual provider code, we will fist start at the client call so we can follow a path through the execution process:

   1:  WikipediaContext datacontext = new WikipediaContext();

2:

   3:  var opensearch = (

   4:      from wikipedia in datacontext.OpenSearch

   5:      where wikipedia.Keyword == "Microsoft"

   6:      select wikipedia).Take(5);

Here you can see that we can created a new instance of the WikipediaContext class and then called to the datacontext.OpenSearch property. This allows the query to return as type IWikipediaQueryable<WikipediaOpenSearchResult> (this will be explained in the later sections). Then we are going to query the results to only inlude those where Keyword == "Microsoft". Finally, we are going to only want to return the first 5 records via the Take() extension method.

We have broken the query down so that you can see where everything more or less fits together as we review the code later.

Let's now look at the WikipediaContext class:

   1:  public class WikipediaContext

   2:  {

   3:      public IWikipediaQueryable<WikipediaOpenSearchResult> OpenSearch

   4:      {

   5:          get { return new WikipediaQueryable<WikipediaOpenSearchResult>(); }

   6:      }

   7:  }

Seems pretty simple. A class with one property OpenSearch that returns type IWikipediaQueryable<WikipediaOpenSearchResult>. In actuality, we are returning the concrete type WikipediaQueryable<WikipediaOpenSearchResult> that implements the IWikipediaQueryable<T> interface. This is important because that interface also implements IQueryable<T> which is what allows our provider to return itself as an IQueryable.

Up to this point we will be returning an enumerable list of WikipediaOpenSearchResult, which is the result class that we will be populating from the Wikipedia API.

   1:  public class WikipediaOpenSearchResult : IWikipediaOpenSearchResult

   2:  {

   3:      public string Text { get; set; }

   4:      public string Description { get; set; }

   5:      public Uri Url { get; set; }

   6:      public Uri ImageUrl { get; set; }

   7:      public string Keyword { get; set; }

   8:  }

Since we are implementing the IQueryable<T> interface, we are also implementing from IEnumerable<T>, IQueryable, and IEnumerable so we are obligated to provide implementations of the following:

IEnumerator IEnumerable.GetEnumerator()
IEnumerator<T> IEnumerable<T>.GetEnumerator()
Type IQueryable.ElementType
Expression IQueryable.Expression
IQueryProvider IQueryable.Provider

For the purposes of this tutorial we will only focus on the IEnumerator<T> IEnumerable<T>.GetEnumerator() method, this is where the acutal call to our custom query provider takes place.

Here is the WikipediaQueryable class:

   1:  internal sealed class WikipediaQueryable<T> : IWikipediaQueryable<T>

   2:  {

   3:      private Expression _expression;

4:

   5:      public WikipediaQueryable()

   6:      {

   7:          _expression = Expression.Constant(this);

   8:      }

9:

  10:      public WikipediaQueryable(Expression expression)

  11:      {

  12:          _expression = expression;

  13:      }

14:

  15:      IEnumerator<T> IEnumerable<T>.GetEnumerator()

  16:      {

  17:          WikipediaQueryProvider provider = new WikipediaQueryProvider();

18:

  19:          IEnumerable<T> sequence = provider.Execute<IEnumerable<T>>(_expression);

20:

  21:          return sequence.GetEnumerator();

  22:      }

  23:  }

Notice on lines 17 - 21 we are calling our customer query provider WikipediaQueryProvider. This is where the provider is passed the lambda expression via it's Execute method. Once the provider has translated and executed the query to the API, it will subsequently return an IEnuberable of type <T>, which is actually the WikipediaOpenSearchResult type in this case.

Since our custom query provider will implement IQueryProvider we must provide implementations for the following:

IQueryable CreateQuery(Expression expression)
IQueryable<TElement> CreateQuery<TElement>(Expression expression)
object Execute(Expression expression)
TResult Execute<TResult>(Expression expression)

For the purposes of this tutorial we will only focus on the object Execute(Expression expression) method, this is where the HTTP send and get request calls are made to the Wikipedia API.

Here is the WikipediaQueryProvider class:

   1:  internal sealed class WikipediaQueryProvider : IQueryProvider

   2:  {

   3:      public object Execute(Expression expression)

   4:      {

   5:          return WikipediaOpenSearchResponse.Get(WikipediaOpenSearchRequest.Send(expression));

   6:      }

   7:  }

Line 5 is returning a string result from the WikipediaOpenSearchRequest.Send method which is really just sending our formatted URL to the Wikipedia API and returning the results to the WikipediaOpenSearchResponse.Get method which parses the results and returns them as type IEnumerable<WikipediaOpenSearchResult>.

We'll cover the WikipediaOpenSearchResponse.Get method later, for now let's take a look at the WikipediaOpenSearchRequest.Send method.

   1:  internal static class WikipediaOpenSearchRequest

   2:  {

   3:      internal static string Send(Expression expression)

   4:      {

   5:          WikipediaOpenSearchUriBuilder uriBuilder = new WikipediaOpenSearchUriBuilder();

6:

   7:          Uri uri = uriBuilder.BuildUri(expression);

8:

   9:          return HttpRequest.Send(uri);

  10:      }

  11:  }

This static method is building a URI based on the expression and then utlizing a helper method HttpRequest.Send which sends the URI using HttpWebRequest. The WikipediaOpenSearchUriBuilder class contains the code that will parse the expression so that we can translate it into a usable URI.

NOTE: Learning to parse lambda expressions is a topic worthy of being covered in a book. You will see some basic samples below on parsing expressions however the focus of this article is to demostrate how to create a Linq provider. I would suggest further exploration on learning the ins and outs of expression parsing to ensure that you have a good solid foundation on lambda expressions. Here are a few good starting points:

Here is the WikipediaOpenSearchUriBuilder class.

   1:  internal sealed class WikipediaOpenSearchUriBuilder : ExpressionVisitor

   2:  {

   3:      private StringBuilder _urlBuilder;

   4:      private Dictionary<string, string> _queryString;

   5:      private string query = string.Empty;

6:

   7:      public WikipediaOpenSearchUriBuilder()

   8:      {

   9:          _queryString = new Dictionary<string, string>();

  10:          _queryString["format"] = "xml";

  11:          _queryString["action"] = "opensearch";

12:

  13:          _urlBuilder = new StringBuilder();

14:

  15:          _urlBuilder.Append("http://en.wikipedia.org/w/api.php?");

  16:      }

17:

  18:      public Uri BuildUri(Expression expression)

  19:      {

  20:          foreach (KeyValuePair<string, string> parameter in _queryString)

  21:          {

  22:              _urlBuilder.Append(parameter.Key);

  23:              _urlBuilder.Append("=");

  24:              _urlBuilder.Append(Uri.EscapeDataString(parameter.Value));

  25:              _urlBuilder.Append("&");

  26:          }

27:

  28:          // parse expression tree

  29:          Visit((MethodCallExpression)expression);

30:

  31:          return new Uri(_urlBuilder.ToString());

  32:      }

33:

  34:      // override ExpressionVisitor method

  35:      protected override Expression VisitMethodCall(MethodCallExpression m)

  36:      {

  37:          if ((m.Method.DeclaringType == typeof(Queryable)) || (m.Method.DeclaringType == typeof(Enumerable)))

  38:          {

  39:              if (m.Method.Name.Equals("Where"))

  40:              {

  41:                  LambdaExpression lambda = (LambdaExpression)StripQuotes(m.Arguments[1]);

42:

  43:                  ParseQuery(lambda.Body);

44:

  45:                  _urlBuilder.Append("search=" + query);

46:

  47:                  return m;

  48:              }

  49:              if (m.Method.Name.Equals("Take"))

  50:              {

  51:                  Visit(m.Arguments[0]);

52:

  53:                  ConstantExpression countExpression = (ConstantExpression)StripQuotes(m.Arguments[1]);

54:

  55:                  _urlBuilder.Append("&limit=" + ((int)countExpression.Value).ToString(CultureInfo.InvariantCulture));

56:

  57:                  return m;

  58:              }

  59:          }

60:

  61:          return m;

  62:      }

63:

  64:      internal void ParseQuery(Expression e)

  65:      {

  66:          if (e is BinaryExpression)

  67:          {

  68:              BinaryExpression c = e as BinaryExpression;

69:

  70:              switch (c.NodeType)

  71:              {

  72:                  case ExpressionType.Equal:

  73:                      GetCondition(c);

  74:                      break;

  75:                  default:

  76:                      throw new NotSupportedException("Only .Equal is supported for this query");

  77:              }

  78:          }

  79:          else

  80:              throw new NotSupportedException("This querytype is not supported.");

  81:      }

82:

  83:      internal void GetCondition(BinaryExpression e)

  84:      {

  85:          string val = string.Empty, attrib = string.Empty;

86:

  87:          if (e.Left is MemberExpression)

  88:          {

  89:              attrib = ((MemberExpression)e.Left).Member.Name;

  90:              val = Expression.Lambda(e.Right).Compile().DynamicInvoke().ToString();

  91:          }

  92:          else if (e.Right is MemberExpression)

  93:          {

  94:              attrib = ((MemberExpression)e.Right).Member.Name;

  95:              val = Expression.Lambda(e.Left).Compile().DynamicInvoke().ToString();

  96:          }

97:

  98:          if (attrib.Equals("Keyword"))

  99:          {

 100:              if (query.Length > 0)

 101:                  throw new NotSupportedException("'WikipediaOpenSearchResult' Query expression can only contain one 'Keyword'");

 102:              else

 103:                  query = val;

 104:          }

 105:          else

 106:          {

 107:              throw new NotSupportedException("'WikipediaOpenSearchResult' Query expression can only contain a'Keyword' parameter");

 108:          }

 109:      }

 110:  }

This class is doing most of the heavy lifting for our provider so let's break it down:

First, on line 1 one we are inheriting from the abstract class ExpressionVisitor which is a helper class that allows us to easily parse lambda expression trees. We will cover this a bit more later.

Next, on line 7 in our contructor...

_queryString = new Dictionary<string, string>();
_queryString["format"] = "xml";
_queryString["action"] = "opensearch";

br /> We begin the process of building our querystring variable that will be sent to the Wikipedia API. Throughout the class we will be appending new items to the querystring as we begin parsing the expression tree.

Next, on line 18 we define our method which then takes over in building our URL from the lamda expression...

public Uri BuildUri(Expression expression)

and the actual parsing of the expression tree starts on line 29:

Visit((MethodCallExpression)expression);

This method in the ExpressionVisitor class begins evaluating the expression and subsequently takes us back to our overridden method on line 35:

protected override Expression VisitMethodCall(MethodCallExpression m)

This method is where we can check the values contained in the expression, specifically in the Where() and Take() extension methods so that we can parse the expression and extract the values that we are looking for.

if (m.Method.Name.Equals("Where"))

and..

if (m.Method.Name.Equals("Take"))

Lines 39-48 are where we parse the lambda expression and look for the keyword that was supplied to the Where() extension method. This value is then appended to the querystring as the "search" value passed to the Wikipedia API.

_urlBuilder.Append("search=" + query);

Next on lines 49-58 we look for the value that was supplied to the Take() extension method. This value is then appended to the querystring as the "limit" value passed to the Wikipedia API.

_urlBuilder.Append("&limit=" + ((int)countExpression.Value).ToString(CultureInfo.InvariantCulture));

Recap:

So up to this point, we have translated the lambda expression into a URL that is ready to be passed to the Wikipedia API. We now need to get ready to accept the returned data (xml) from the Wikipedia API and then populate our WikipediaOpenSearchResult class with the data. So let's move on to the WikipediaOpenSearchResponse.Get method.

   1:  internal static class WikipediaOpenSearchResponse

   2:  {

   3:      internal static IEnumerable<WikipediaOpenSearchResult> Get(string xml)

   4:      {

   5:          List<WikipediaOpenSearchResult> resultList = new List<WikipediaOpenSearchResult>();

6:

   7:          var descendants = from i in XDocument.Parse(xml).Descendants() select i;

8:

   9:          foreach (XElement element in descendants)

  10:          {

  11:              if (element.Name.LocalName.ToString().Equals("Item"))

  12:              {

  13:                  WikipediaOpenSearchResult wsr = new WikipediaOpenSearchResult();

14:

  15:                  var items = from x in element.Nodes()

  16:                              select x;

17:

  18:                  foreach (XElement item in items)

  19:                  {

  20:                      switch (item.Name.LocalName.ToString())

  21:                      {

  22:                          case "Text":

  23:                              wsr.Text = item.Value;

  24:                              break;

  25:                          case "Description":

  26:                              wsr.Description = item.Value;

  27:                              break;

  28:                          case "Url":

  29:                              wsr.Url = new Uri(item.Value);

  30:                              break;

  31:                          case "Image":

  32:                              wsr.ImageUrl = new Uri(item.Attribute("source").Value);

  33:                              break;

  34:                      }

  35:                  }

36:

  37:                  resultList.Add(wsr);

  38:              }

  39:          }

40:

  41:          return resultList;

  42:      }

  43:  }

This class has one static method that accepts a string of xml and returns a a generic List<> of type WikipediaOpenSearchResult as an IEnumerable. We are using LinqtoXml to parse out the data and return the elements that we need to populate our WikipediaOpenSearchResult class.

From here the IEnumerable is passed back on up the stack to the WikipediaQueryProvider and returned to the client as type WikipediaQueryable<WikipediaKeywordSearchResult>.

LinqToWikipedia - A custom .NET Linq provider - Part I

2010-01-16T11:21:56-05:00:00

This article is a two-part series regarding the LinqToWikipedia provider. The first article will cover the basic concepts of Linq as well as the client usage of this particular provider while the second article will explore the inner workings of the LinqToWikipedia provider to give you an understanding of what it takes to create your own IQueryable provider.

NOTE: You should download the latest build from Codeplex so you can follow along with the code samples.

What is Linq?

Let's spend a moment and talk about what Linq is all about from a high-level.

Linq (Language Integrated Query) is a .NET programming model that allows for a consistent SQL-like querying syntax (called query expressions) against various data sources. These data sources can be anything from SQL server, Oracle, XML, in-memory objects, web services... just about anything. There are many Linq providers that are provided with .NET such as Linq to SQL, Linq to XML, Linq to Objects, while there are many 3rd party Linq providers out there that are available such as Linq to Oracle, Linq to Amazon, Linq to MySql, etc.

The following code is an example of a Linq query that searches for customers that start with the letter "M" and return the records to an ASP.NET DataGrid.

   1:  protected void Page_Load(object sender, EventArgs e)

   2:  {

   3:      var customers =

   4:          from c in Customers.GetCustomers()

   5:          where c.Name.StartsWith("M") && c.Age > 11

   6:          orderby c.Age descending

   7:          select c;

8:

   9:      dg_customers.DataSource = customers;

  10:      dg_customers.DataBind();

  11:  }

12:

  13:  public class Customers

  14:  {

  15:      public string Name { get; set; }

  16:      public int Age { get; set; }

17:

  18:      public static List<Customers> GetCustomers()

  19:      {

  20:          List<Customers> customerds = new List<Customers>();

21:

  22:          customerds.Add(new Customers() { Name = "Elo", Age = 6 });

  23:          customerds.Add(new Customers() { Name = "Myranda", Age = 11 });

  24:          customerds.Add(new Customers() { Name = "Mikayli", Age = 12 });

  25:          customerds.Add(new Customers() { Name = "Elias", Age = 13 });

  26:          customerds.Add(new Customers() { Name = "Memori", Age = 15 });

27:

  28:          return customerds;

  29:      }

  30:  }

Output:

Name	Age
Memori	15
Mikayli	12

The compiler will actually translate the Linq query into a lambda expression so if you wanted to you could write this query as a lambda expression directly:

IEnumerable<Customers> customers = Customers.GetCustomers().Where(c => c.Name.StartsWith("M") && c.Age > 11).OrderByDescending(y => y.Age);

But as you can see, the Linq code is much more intuitive and especially if you have multiple statements in your Where clause. Either way, this code will work for any Linq provider that exposes a Customers entity whether they are stored in a database, XML files, web service lookup, etc. The Customers entity happens to be in-memory objects in this case.

LinqToWikipedia search options

Before we dive into actually building the Linq query, let's review the two search options provided by LinqToWikipedia. There are two different types of searches that the provider offers via the MediaWiki API:

Open Search
Keyword Search

Open Search

OpenSearch is a standardized collection of simple formats for the sharing of search results. OpenSearch was created by A9.com, an Amazon.com company, and the OpenSearch format is now in use by hundreds of search engines and search applications around the Internet. LinqToWikipedia can format the returned data so that it adheres to this standard. For more information on the OpenSearch standard visit OpenSearch.org.

Open Search will return the following data elements from a Wikipedia search when querying by a single search term:

Text - Title of the page
Description - Short description of the page
Url - The absolute Url to the page
ImageUrl - The absolute Url to the main image of the page (if it exists)

See a live demo of the Open Search function.

This search option will return up to 15 records at a time using the .Take() query extension. You will see an example of this code later on.

Keyword Search

This query option allows you to search the Wikipedia database using multiple keywords and returns data in the following format:

Title - Title of the page
Description - Short description of the page
Url - The absolute Url to the page
WordCount - Total count of words
TimeStamp - The date/time the page was last updated)
RecordCount - The total number of records in the result set (this is used for paging)

See a live demo of the Keyword search function.

This query option will return up to 100 records at a time and also supports paging through the data by using a combination of .Skip() and .Take()

Using the LinqToWikipedia provider

Now let's move on to using the LinqToWikipedia provider. You have two options:

Download the source code and add to an existing project and make a project reference or...
Download the source code and just copy/reference the linqtowikipedia.dll within your project

Now that you have a reference, you need to add a using statement to your code to add the namespace:

using LinqToWikipedia;

Next you need to instantiate the LinqToWikipedia object via the WikipediaConext class.

WikipediaContext datacontext = new WikipediaContext();

//WikipediaContext datacontext = new WikipediaContext(new WebProxy("yourproxy", 80), new NetworkCredential("username", "password", "domain"));

Note: If your application is running behind a firewall/proxy, you can alternatively instansiate the provider passing in a new WebProxy and NetworkCredential to the constructor.

Now we will create our Linq code to query Wikipedia using the OpenSearch method.

We will query using soccer as our keyword and request that the provider return 10 records by calling the .Take(10) query extension method:

   1:  var opensearch = (

   2:      from wikipedia in datacontext.OpenSearch

   3:      where wikipedia.Keyword == "soccer"

   4:      select wikipedia).Take(10);

The result set is of type IWikipediaQueryable<WikipediaOpenSearchResult> and since this type implements the IQueryable<T> interface, we can iterate over the results with a foreach loop.

   1:  StringBuilder sb = new StringBuilder();

2:

   3:  foreach (WikipediaOpenSearchResult result in opensearch)

   4:  {

   5:      sb.Append("Text = " + result.Text + "<br />");

   6:      sb.Append("Description = " + result.Description + "<br />");

   7:      sb.Append("Url = " + result.Url + "<br />");

   8:      sb.Append("ImageUrl = " + result.ImageUrl + "<br /><br />");

   9:  }

10:

  11:  //ASP.NET Label control

  12:  lbl_diplay.Text = sb.ToString();

Here is a sample of the results:

Text = Association football
Description = Association football, more commonly known as football or soccer, is a team sport played between two teams of eleven players using a spherical ball.
Url = http://en.wikipedia.org/wiki/Association_football
ImageUrl = http://upload.wikimedia.org/wikipedia/commons/thumb/7/7a/Football_header.JPG/50px-Football_header.JPG

Text = Racing Post
Description = The Racing Post is a British daily horse racing, greyhound racing and sports betting newspaper, currently the only one appearing in print form.
Url = http://en.wikipedia.org/wiki/Racing_Post
ImageUrl =

See a live demo of the Open Search function.

Now we will create our Linq code to query Wikipedia using the KeywordSearch method.

We will query using soccer, los angeles, galaxy, donovan as our keywords and request that the provider return 10 records by calling the .Take(10) query extension method but we also want to skip the first 10 records in the result set by using the .Skip(10) query extension method. By using .Skip() and .Take() in tandem we are effectively enabling recordset paging. To determine the total number of pages in the recordset, we can divide the RecordCount property by the number of .Take() records. Then for each new query we increase the .Skip() number to move to the next recordset until we are at the last page of records. Finally, we will have the results displayed to an ASP.NET DataList.

First we need to declare a local variable that will hold the total number of records in the result set.

private int totalrecords = 0;

Now we write our Linq query and set the results as the DataSource of our DataList.

   1:  WikipediaContext datacontext = new WikipediaContext();

2:

   3:  var query = (

   4:      from wikipedia in datacontext.KeywordSearch

   5:      where

   6:          wikipedia.Keyword == "soccer" &&

   7:          wikipedia.Keyword == "los angeles" &&

   8:          wikipedia.Keyword == "galaxy" &&

   9:          wikipedia.Keyword == "donovan"

  10:      select wikipedia).Skip(10).Take(10);

11:

  12:  dl_results.DataSource = query;

  13:  dl_results.DataBind();

NOTE: To use paging, you would want to set the .Skip() number to a variable that you can increment with each subsequent lookup.

Since we are not looping through the results (like we did in the OpenSearch example) we need to find a way to capture the RecordCount value and set it to our local totalrecords variable. To solve this we can use the ASP.NET DataList ItemDataBound event.

   1:  protected void dl_results_ItemDataBound(object sender, DataListItemEventArgs e)

   2:  {

   3:      if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)

   4:      {

   5:          if (this.totalrecords == 0)

   7:              this.totalrecords = ((WikipediaKeywordSearchResult)e.Item.DataItem).RecordCount;

  11:      }

  12:  }

See a live demo of the Keyword search function.

Part II - Explore the inner workings of the LinqToWikipedia provider to create your own IQueryable provider. (coming soon)

.NET WCF services and Java Web Services Interoperability - Part 3 of 3

2009-12-30T09:32:43-05:00:00

Part III - Create the Java Web Service consumed by a .NET client

This article is the third in a three part series demonstrating the interoperability between .NET WCF services and Java Web Services.

NOTE: If you haven't read Part I or Part II, you should review them before continuing on.

In Part I we reviewed the class diagram of the Team class and in Part II we covered creating a WCF service that exposed that class and consumed it with a Java client. Now we will be creating the JWS and consume it with a .NET client.

We will start with creating the Player class:

01 package jws;

02 

03 public class Player {

04 

05     private String _name;

06     private int _age;

07 

08     public String getName() {

09         return _name;

10     }

11 

12     public void setName(String name) {

13         _name = name;

14     }

15 

16     public int getAge() {

17         return _age;

18     }

19 

20     public void setAge(int age) {

21         _age = age;

22     }

23 }

Here we have the Player class that contains Name and Age properties that are exposed using the Java Bean "getter/setter" convention.

Now we will create the TeamType enumerator:

1 package jws;

2 

3 public enum TeamType {

4     Soccer,

5     Football

6 }

This allows us to limit the types of teams returned to only Soccer and Football.

The next step is to create the Team class:

01 package jws;

02 

03 import java.util.*;

04 

05 public class Team {

06 

07     private String _name;

08     private TeamType _teamtype;

09     private List<Player> _players;

10 

11     public String getName() {

12         return _name;

13     }

14 

15     public void setName(String name) {

16         _name = name;

17     }

18 

19     public TeamType getTeamType() {

20         return _teamtype;

21     }

22 

23     public void setTeamType(TeamType teamtype) {

24         _teamtype = teamtype;

25     }

26 

27     public List<Player> getPlayers() {

28         return _players;

29     }

30 

31     public void setPlayers(List<Player> players) {

32         _players = players;

33     }

34 }

Here you can see now that we have included in the Team class a Name property, a TeamType property based off our enum above, and finally a generic list of Player objects. Again these are all exposed using the getter/setter convention.

Now that our Team class is complete, our next step is to create the Java Web Service:

01 package jws;

02 

03 import javax.jws.WebService;

04 import java.util.*;

05 import java.util.ArrayList;

06 

07 @WebService()

08 public class HelloWorldJWS {

09 

10     public List<Team> getTeams() {

11         return GetTeamInfo();

12     }

13 

14     private List<Team> GetTeamInfo() {

15 

16         Player Memori = CreatePlayer("Memori", 15);

17         Player Mikayli = CreatePlayer("Mikayli", 12);

18         Player Myranda = CreatePlayer("Myranda", 11);

19         Player Elias = CreatePlayer("Elias", 13);

20         Player Elogan = CreatePlayer("Elogan", 6);

21 

22         List<Player> girlplayers = new ArrayList<Player>();

23         List<Player> boyplayers = new ArrayList<Player>();

24 

25         girlplayers.add(Memori);

26         girlplayers.add(Mikayli);

27         girlplayers.add(Myranda);

28         boyplayers.add(Elias);

29         boyplayers.add(Elogan);

30 

31         Team dagirls = new Team();

32 

33         dagirls.setName("DaGirls");

34         dagirls.setTeamType(TeamType.Soccer);

35         dagirls.setPlayers(girlplayers);

36 

37         Team daboys = new Team();

38 

39         daboys.setName("DaBoys");

40         daboys.setTeamType(TeamType.Football);

41         daboys.setPlayers(boyplayers);

42 

43         List<Team> teams = new ArrayList<Team>();

44 

45         teams.add(dagirls);

46         teams.add(daboys);

47 

48         return teams;

49     }

50 

51     private Player CreatePlayer(String name, int age) {

52 

53         Player newplayer = new Player();

54 

55         newplayer.setName(name);

56         newplayer.setAge(age);

57 

58         return newplayer;

59     }

60 }

Like our WCF service, our JWS returns one method getTeams() that returns a generic list of Team objects. The GetTeamInfo() method is used to create some test teams and players.

The final step is to create the .NET client. You can either use the svcutil.exe utility or Visual Studio (add reference wizard) to create the proxy based on the JWS WSDL.

   1:  JWS.HelloWorldJWSClient webclient = new JWS.HelloWorldJWSClient();

2:

   3:  JWS.team[] Teams = webclient.getTeams();

4:

   5:  foreach (JWS.team team in Teams)

   6:  {

   7:     jws.Text += "<br /><b>Team name</b>: " + team.name + "<br />";

   8:     jws.Text += "<b>Team type</b>: " + team.teamType + "<br /><br />";

   9:     jws.Text += "Players:<br />";

10:

  11:     foreach (JWS.player player in team.players)

  12:     {

  13:         jws.Text += "&nbsp;&nbsp;Name: <i>" + player.name + "</i><br />";

  14:         jws.Text += "&nbsp;&nbsp;Age: <i>" + player.age.ToString() + "</i><br />";

  15:     }

  16:  }

Here is the sample output from the browser:

Team name: DaGirls
Team type: Soccer

Players:
  Name: Memori
  Age: 15
  Name: Mikayli
  Age: 12
  Name: Myranda
  Age: 11

Team name: DaBoys
Team type: Football

Players:
  Name: Elias
  Age: 13
  Name: Elogan
  Age: 6

This article is the third in a three part series demonstrating the interoperability between .NET WCF services and Java Web Services.

Article Series:

.NET WCF services and Java Web Services Interoperability - Part 2 of 3

2009-12-29T15:50:55-05:00:00

Part II - Create the WCF "Team" service consumed by a Java client

This article is the second in a three part series demonstrating the interoperability between .NET WCF services and Java Web Services.

NOTE: If you haven't read Part I you should review that article before continuing on.

In Part I we reviewed the class diagram of the Team class, so our first step is to create the .NET classes in support of that model. We will start by creating the Player class:

   1:  [DataContractAttribute(Name = "Player", Namespace = "HelloWorldWCFs")]

   2:  public class Player

   3:  {

   4:      [DataMemberAttribute(Name="Name",IsRequired=true)]

   5:      public string Name { get; set; }

6:

   7:      [DataMemberAttribute(Name = "Age", IsRequired = true)]

   8:      public int Age { get; set; }

   9:  }

With WCF, all classes must have a data contract established so that they can be serialized to XML and sent down the wire. Here we created a simple Player class decorated with the DataContractAttribute. This class contains Name and Age properties for each player and are decorated them with DataMemberAttribute attribute.

Next we will create the TeamType enumeration:

   1:  [DataContractAttribute(Name = "TeamType", Namespace = "HelloWorldWCFs")]

   2:  public enum TeamType : int

   3:  {

   4:      [EnumMemberAttribute(Value="Soccer")]

   5:      Soccer = 0,

   6:      [EnumMemberAttribute(Value = "Football")]

   7:      Football = 1

   8:  }

With this enumeration, we simply want the user to be able to either choose Soccer or Football as an option for a team type.

The next step is to create the Team class:

   1:  [DataContractAttribute(Name = "Team", Namespace = "HelloWorldWCFs")]

   2:  [XmlInclude(typeof(TeamType))]

   3:  [KnownType(typeof(TeamType))]

   4:  [XmlInclude(typeof(Player))]

   5:  [KnownType(typeof(Player))]

   6:  public class Team

   7:  {

   8:      [DataMemberAttribute(Name = "Name", IsRequired = true)]

   9:      public string Name { get; set; }

10:

  11:      [DataMemberAttribute(Name = "teamtype", IsRequired = true)]

  12:      public TeamType teamtype { get; set; }

13:

  14:      [DataMemberAttribute(Name = "Players", IsRequired = true)]

  15:      public List<Player> Players { get; set; }

  16:  }

The XmlInclude and KnownType decorations force the Player and TeamType classes to be included as part of the Team class in the serialization process.

Now the next step is to create the interface for our service:

   1:  [ServiceContract(Name="IHelloWorldWCF", Namespace = "HelloWorldWCFs")]

   2:  public interface IHelloWorldWCF

   3:  {

   4:      [OperationContract]

   5:      List<Team> getTeams();

   6:  }

As we can see, our service interface has one method getTeams() that will return a generic List of Team objects.

Finally we need to create the class that implements our new ServiceContract interface we just created:

   1:  public class HelloWorldWCF : IHelloWorldWCF

   2:  {

   3:      public List<Team> getTeams()

   4:      {

   5:          return GetTeamInfo();

   6:      }

7:

   8:      private List<Team> GetTeamInfo()

   9:      {

  10:          var Memori = new Player() { Name = "Memori", Age = 15 };

  11:          var Mikayli = new Player() { Name = "Mikayli", Age = 12 };

  12:          var Myranda = new Player() { Name = "Myranda", Age = 11 };

  13:          var Elias = new Player() { Name = "Elias", Age = 13 };

  14:          var Elogan = new Player() { Name = "Elogan", Age = 6 };

15:

  16:          var girlsteam = new Team() {

  17:              Name = "DaGirls",

  18:              teamtype = TeamType.Soccer,

  19:              Players = new List<Player>() { Memori, Mikayli, Myranda }

  20:          };

  21:          var boysteam = new Team() {

  22:              Name = "DaBoys",

  23:              teamtype = TeamType.Football,

  24:              Players = new List<Player>() { Elias, Elogan }

  25:          };

26:

  27:          return new List<Team>() { girlsteam, boysteam };

  28:      }

  29:  }

Here we are implementing the getTeams() method and subsequently calling another method getTeamInfo() to actually populate our class with team and player information to return to the client.

NOTE: Once you have built the service, you will need to make one modification to the configuration file. In the <system.serviceModel> section you will need to change the endpoint binding from the default wsBinding to basicHttpBinding. This allows the service endpoint to be exposed as WS-1 BP 1.1 compliant and use HTTP as the transport for sending SOAP 1.1 messages.

Our next task is to create the Java client.

We can create a new client in NetBeans by selecting New -> Web Service Client from an existing project such as a web application project. When prompted, you select to create the new project by entering a URL to an existing WSDL. Here you enter the URL path to the WSDL that was generated from the WCF service we just created and NetBeans will then create the required proxy code for you. This proxy code will handle all of the data type mappings for you as well as define the generic lists and enums based on the WSDL.

Hint: You will want to enter a package name for the proxy code so that it is encapsulated, otherwise there will be multiple packages the classes based on the WSDL naming schema.

With the proxy code created, we can now write some code in our JSP file to loop through the data returned from the service and display in a browser:

01 <% 02 wcfservice.HelloWorldWCF service = new wcfservice.HelloWorldWCF(); 03 wcfservice.IHelloWorldWCF client = service.getBasicHttpBindingIHelloWorldWCF(); 04 05 for (wcfservice.Team team : client.getTeams().getTeam()) { 06 out.println(" Team name: " + team.getName() + " "); 07 out.println("Team type: " + team.getTeamtype().value() + " "); 08 out.println("Players: "); 09 10 for (wcfservice.Player player : team.getPlayers().getPlayer()) { 11 out.println("  Name: " + player.getName() + " "); 12 out.println("  Age: " + player.getAge() + " "); 13 } 14 } 15 %>

Here is the sample output from the browser:

This article is the second in a three part series demonstrating the interoperability between .NET WCF services and Java Web Services.

Article Series:

.NET WCF services and Java Web Services Interoperability - Part 1 of 3

2009-12-28T15:25:40-05:00:00

Recently I was involved in a discussion around the concept of interoperability with WCF services. Half of our I.T. shop develops in the Java world and the other half in .NET, so as we were designing our next WCF service we asked ourselves the question, " Will this service ever need to be consumed by a Java client?" The answer to that question would make a difference in our design approach since we were told by our consultants friends that if we were to use custom data types in .NET, we were foregoing the opportunity for our Java teams from ever utilizing the service. We decided not worry about interoperability drawbacks and go ahead and design the service with custom .NET data types, generic lists, enums, etc.

This article is designed to show you how you CAN actually have pretty solid interoperability between JWS and WCF using custom data types, generic lists, and enums both ways; a JWS service consumed by a .NET client as well as a WCF service consumed by a Java client. We'll break it down into three postings:

An overview of our design approach
Create the WCF service consumed by a Java client
Create the Java Web Service consumed by a .NET client

Both the WCF and the JWS services will have the same class structure. Below you will find a class diagram that demonstrates the class layout:

The services will return a list of "Teams" that contain some basic information for each including:

Team Name
Team Type
- This will be an enumeration value of either "Soccer" or "Football"
Players
- This will be a generic list of "Player"(s) that contain a Name and Age

As you will see the code for both platforms is very similar and there are only a couple of caveats to getting the solutions to work "out of the box", which we will discuss later.

For the Java development, we will be using NetBeans IDE version 6.8 and for the .NET development, we will be using Visual Studio 2008.

This article is the first in a three part series demonstrating the interoperability between .NET WCF services and Java Web Services.

Article Series:

Integration Testing WCF services with Unity

2009-12-21T12:46:29-05:00:00

Previously I wrote an article regarding Unit Testing WCF with Unity. Unit testing allows you to test a single component of your application, completely independent of any other components or systems. Once you have successfully created your unit tests, the logical next step is to see how your service works when connected to other components. These integration tests allow you, for example, to run tests against your service and see how it behaves when writing to a database or consuming another service.

Integration Testing WCF services
To perform integration testing against a service, you have a few different options to go with; each with their own advantages and disadvantages:

Utilize the Asp.Net web server (Cassini) within Visual Studio
Deploy your service to IIS
Setting up your service host and starting it from within the integration test environment

1. Use the Asp.Net web server in Visual Studio
This is the most convenient approach during the development phase, however you will have to remember to keep re-starting the development web server whenever it times out. You will also need to create a proxy class (using svcutil.exe or the service reference wizard in VS) as well as maintain the endpoint configuration for the service in your web.config or app.config file.

2. Deploy to IIS
This option allows you to test your service against IIS. A web application directory will need to be created (VS can do this for you) but unlike Cassini, you won't have to worry about the server timing out. This option isn't the best choice if you frequently test different services and will also leave you having to handle multiple web application directories lounging around IIS. Again, you will need to create a proxy class as well as have the service endpoint in your configuration file.

3. Create/start your service host "on the fly"
This is the "cleanest" approach and does not have any of the drawbacks of the first two options. The service is automatically created/started/stopped from within the test class setup/teardown code whenever you run your tests. Another advantage is that you can run your unit/integration tests automatically and unattended using the Build Server within TFS (Team Foundation Server).

Below is an example of how you would accomplish this:

   1:  [TestClass]

   2:  public class WcfIntegrationTests

   3:  {

   4:      private static ServiceHost svcHost;

5:

   6:      [ClassInitialize]

   7:      public static void TestClassInitialize(TestContext testContext)

   8:      {

   9:          svcHost = new ServiceHost(typeof(WcfService), new[] { new Uri("http://localhost/") });

  10:          svcHost.AddServiceEndpoint(typeof(IWcfService), new BasicHttpBinding(), "WcfService");

  11:          svcHost.Open();

  12:      }

13:

  14:      [ClassCleanup]

  15:      public static void TestClassCleanup()

  16:      {

  17:          svcHost.Close();

  18:      }

19:

  20:      [TestMethod]

  21:      public void GetUsers()

  22:      {

  23:          var endptaddr = new EndpointAddress("http://localhost/WcfService");

  24:          var Wcfproxy = ChannelFactory<IWcfService>.CreateChannel(new BasicHttpBinding(), endptaddr);

  25:          var result = Wcfproxy.GetUsers();

  26:          Assert.IsTrue(result.Count > 0, "No users found");

  27:      }

  28:  }

Now if your WCF service is utilizing an IoC container for unit testing by way of WCF extension points (see my previous post on Unit Testing WCF with Unity), you will notice right away that you receive the following error...

System.InvalidOperationException: The service type provided could not be loaded as a service because it does not have a default (parameter-less) constructor

The reason for this error is because of our ServiceHostFactory we created for our unit tests. The Factory doesn't have any available public methods to be able to create the service host from a given service type. What we will need to do is create a wrapper class for the factory and define a public method to create the service host and allow for a type to be passed in as a parameter.

   1:  private class WcfServiceHostFactoryWrapper : WcfSvcServiceHostFactory

   2:  {

   3:      public ServiceHost CreateServiceHost(Type serviceType, string baseAddress)

   4:      {

   5:          return CreateServiceHost(serviceType, new[] { new Uri(baseAddress) });

   6:      }

   7:  }

8:

   9:  [ClassInitialize]

  10:  public static void TestClassInitialize(TestContext testContext)

  11:  {

  12:      var serviceHostFactoryHarness = new WcfServiceHostFactoryWrapper();

  13:      svcHost = serviceHostFactoryHarness.CreateServiceHost(typeof(WcfService), "http://127.0.0.1/");

  14:      svcHost.AddServiceEndpoint(typeof(IWcfService), new BasicHttpBinding(), "WcfService");

  15:      svcHost.Open();

  16:  }

Now you can just select the test to run from the Visual Studio Test List Editor, or run unattended from the TFS Build Server, with no dependencies on IIS or configuration.

Unit Testing your WCF Service

2009-12-12T23:11:14-05:00:00

So you're familiar with TDD (test-driven development)... Failing your tests first, then building up your classes to satisfy your tests so they're all "Green"...

This is a typical scenario and is pretty straightfoward with .NET.

Well now you have to create a WCF service and implement unit testing to ensure you don't break your service when you build out a new version.

This is a bit more challenging but you do have some different options:

Separate out your service code into a library and run your tests against the library code...
- This really only tests your library code and doesn't actually allow you to instate the service itself to perform a realistic test. For example, you might inadvertently forget to decorate a field with a [DataMember] attribute. This wouldn't affect your unit test if you're just testing your library code but could break your service if a client is expecting that field to be serialized.
Use an IoC (Inversion of Control) container to inject your dependencies from within your tests
- This is the most accurate way to effectively unit test your service. Granted, there is a bit more setup involved up front, however this approach is defintely worth the effort once you wrap your head around the concept of WCF extension points

We are going to be focusing on option #2 since we want our tests to be as realistic and thorough as possible.

To help us get started, let's ask ourselves the following questions:

Why do we inject a dependency into our service?
What type of dependency do we inject into our service?
How do we actually inject a dependency into our service?

NOTE: For our examples we will be utilizing Microsoft's Unity application block, however you can just as easily use any IoC container that you are comfortable with such as StructureMap, etc. The actual IoC code is found within our WCF extension points, which you will see described later on.

Why do we inject a dependency into our service?
Dependency injection allows one object's configuration (fields, properties, etc) to be set and/or modified by another external object.

What type of dependency do we inject into our service?
For our purpose, we will be sending in a depency to allow the service to read from a "mock" datastore (XML file) to return a collection of users rather than from the service's default SQL datastore. This way, we will know exactly what the data will look like going into and coming out of the service.

How do we actually inject a dependency into our service?
We will employ dependency injection by passing a data provider interface to the service contructor. How does the service know what concrete implementation of the data provider to use? That's where the IoC container, Unity in our case, comes into play.

Here is a checklist of the tasks we need to employ to allow the service to accept the DI (dependency injection).

Create an interface for our data provider
Modify our service to accept the interface in the contructor
Create our WCF extension points to allow our IoC container to instatiate a concrete implementation of our data provider
- Create our own instance provider that inherits from IInstanceProvider
- Create a custom service behavior that inherits from IServiceBehavior which will allow us to configure the service to use our new instance provider rather than the default WCF instance provider
- We then extend the ServiceHost class and override the OnOpening() method to add our new service behavior to the ServiceDescription Behaviors collection
- Finally we need to extend the ServiceHostFactory class and override the CreateServiceHost method to use our new service host
Now that our extension points are all setup, we need to configure the service to use the new service host factory

1.) Create an interface for our data provider

This interface contains one method, AllUserData(), that returns a collection of Users.

   1:  public interface IRepository

   2:  {

   3:      List<User> AllUserData();

   4:  }

2. Modify our service to accept the interface in the contructor

Now we have to modify our service so that we can pass in a rerence to IRepository in the constructor. Now when the GetUsers() method is called, the concrete implementation of IRepository will return it's version of the AllUserData() method.

   1:  public class UserService : IUserService

   2:  {

   3:      private readonly IRepository userrepository;

4:

   5:      public UserService(IRepository userrepository)

   6:      {

   7:          this.userrepository = userrepository;

   8:      }

9:

  10:      public List<User> GetUsers()

  11:      {

  12:          return userrepository.AllUserData();

  13:      }

  14:  }

Are we done? Not quite...

Trying to run this "as-is" will generate an error since WCF can only instantiate our service using a constructor with no arguments. That is why we need to create our own extension points so that we can control the instatiation of the service without having to create a no args constructor. The beauty in this is that when a client uses the service, they only see the default "no args" constructor, however when we instantiate the service through our unit tests, we will be able to see the second constructor so that we can pass in our own implementation of IRepository to "fake out" the service.

3a. Create our instance provider

This is the class where we are setting up our IoC container to resolve the IRepository interface to the correct concrete implemenation, which you'll see described later when we create the service host factory class. Notice line 19 below, this is where Unity is resolving the passed in serviceType.

   1:  public class WcfSvcInstanceProvider : IInstanceProvider

   2:  {

   3:      private readonly IUnityContainer container;

   4:      private readonly Type _serviceType;

5:

   6:      public WcfSvcInstanceProvider(IUnityContainer container, Type serviceType)

   7:      {

   8:          this.container = container;

   9:          _serviceType = serviceType;

  10:      }

11:

  12:      public object GetInstance(InstanceContext instanceContext)

  13:      {

  14:          return GetInstance(instanceContext, null);

  15:      }

16:

  17:      public object GetInstance(InstanceContext instanceContext, Message message)

  18:      {

  19:          return container.Resolve(_serviceType);

  20:      }

21:

  22:      public void ReleaseInstance(InstanceContext instanceContext, object instance)

  23:      {

  24:          container.Teardown(instance);

  25:      }

  26:  }

3b. Create our service behavior

Once we have setup our instance provider, we need to incorporate that into a custom service behavior. Starting at line 12 you can see how we search for all endpoints in all channels and set their respective instance providers to our newly created provider.

   1:  public class WcfSvcServiceBehavior : IServiceBehavior

   2:  {

   3:      private readonly IUnityContainer container;

4:

   5:      public WcfSvcServiceBehavior(IUnityContainer container)

   6:      {

   7:          this.container = container;

   8:      }

9:

  10:      public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)

  11:      {

  12:          foreach (ChannelDispatcherBase cdb in serviceHostBase.ChannelDispatchers)

  13:          {

  14:              ChannelDispatcher cd = cdb as ChannelDispatcher;

  15:              if (cd != null)

  16:              {

  17:                  foreach (EndpointDispatcher ed in cd.Endpoints)

  18:                  {

  19:                      ed.DispatchRuntime.InstanceProvider = new WcfSvcInstanceProvider(this.container, serviceDescription.ServiceType);

  20:                  }

  21:              }

  22:          }

  23:      }

24:

  25:      public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters)

  26:      {

  27:      }

28:

  29:      public void Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)

  30:      {

  31:      }

  32:  }

3c. Create our service host

Here we are creating our own service host and overriding the OnOpening() method to add our custom service behavior to the ServiceDescription behaviors collection.

   1:  public class WcfSvcServiceHost : ServiceHost

   2:  {

   3:      private IUnityContainer unityContainer;

4:

   5:      public WcfSvcServiceHost(IUnityContainer unityContainer, Type serviceType, params Uri[] baseAddresses)

   6:          : base(serviceType, baseAddresses)

   7:      {

   8:          this.unityContainer = unityContainer;

   9:      }

10:

  11:      protected override void OnOpening()

  12:      {

  13:          base.OnOpening();

14:

  15:          if (this.Description.Behaviors.Find<WcfSvcServiceBehavior>() == null)

  16:          {

  17:              this.Description.Behaviors.Add(new WcfSvcServiceBehavior(this.unityContainer));

  18:          }

  19:      }

  20:  }

3d. Create our service host factory

Now we create our service host factory to instantiate our service host. This is also where we are defining our concrete implementation of the IRepository interface to be of type SqlRepository. This concrete type will always be used when the service is instantiated with the no-args constructor.

   1:  public class WcfSvcServiceHostFactory : ServiceHostFactory

   2:  {

   3:      protected override ServiceHost CreateServiceHost(Type serviceType, Uri[] baseAddresses)

   4:      {

   5:          UnityContainer unityContainer = new UnityContainer();

6:

   7:          unityContainer.RegisterType<IRepository, SqlRepository>();

8:

   9:          return new WcfSvcServiceHost(unityContainer, serviceType, baseAddresses);

  10:      }

  11:  }

4. Configure the service to use our service host factory

Since we are hosting the service in IIS, we simply need to add one line of code to the .svc file to use our service host factory

<%@ ServiceHost Language="C#"
        Service="UserService"
        CodeBehind="UserService.svc.cs" 
        Factory="WcfSvcServiceHostFactory"
%>

You should now be able to successfully run your "unit test ready" WCF service.

Now you can just include your service in your unit test project and create your tests like this:

   1:  [TestClass]

   2:  public class UserServiceTests

   3:  {

   4:      UnityContainer unityContainer = new UnityContainer();

5:

   6:      public UserServiceTests()

   7:      {

   8:          unityContainer.RegisterType<IRepository, TestRepository>();

   9:      }

10:

  11:      [TestMethod]

  12:      public void GetMockedUsers()

  13:      {

  14:          UserService usr_svc = new UserService(unityContainer.Resolve<IRepository>());

15:

  16:          List<User> testuserdata = usr_svc.GetUsers();

17:

  18:          Assert.IsTrue(MockDatafromXmlFile(), testuserdata));

  19:      }

  20:  }

First we are telling Unity to register the TestRepository class as the concrete implementation of the IRepository interface in the test class constructor. TestRepository is simply our class that returns data from an XML file that contains a list of users.

Then in our test we simply pass in the the IRepository interface to the service constructor and test away!

Publisher/Subscriber... practical benefits from event-driven patterns

2009-05-22T23:00:41-04:00:00

Events are a critical component in Object Oriented programming. Whether they originate from user interaction or code logic, events are at the heart of what makes your application dynamic. Thanks to the advancement in both Java and .Net over the years, the event-driven paradigm has become possible on the web with the advent of JSF (Java Server Faces) and ASP.NET. Both of these technologies support the event-driven model allowing developers to take adantage of the "publisher/subscriber" pattern.

There are generally two types of events in Java and .NET; low-level events and semantic events.

Low-level events typically involve OS (GUI) type events such as Mouseclicks (onMouseClick, onMouseDown, etc) or keyboard actions (onKeyPress, onKeyDown, etc) whereas Semantic events are programmatic and involve the developer to create their own events, subsequently creating listeners to take custom actions based on those events. This article is geared toward utilizing semantic events.

What's the benefit of coding for semantic events?

That's a good question... let's take a typical application scenario and see how we can use events to develop a "real-world" solution.

Let's suppose we have an website that allows new users to register themselves (the event publisher). There are certain actions that need to happen when a new user has successfully completed the registration form (the event subscribers):

The database needs to be updated with the user's information.
The website owner needs to be notified that a user has registered and will need to approve the user before they can actually use the site.
The new user will need to be sent a "welcome to our site" type message.
The site will need to set a cookie in the user's browser so they will be "recognized" the next time they visit the site.

There are several ways to architect a suitable coding solution to meet these requirements, however by utilizing a publisher/subscriber design pattern we can create a scalable solution that will be flexible enough to handle any new actions that may be required at a later time. This is accomplished by firing an event when the user has registered. This will send out a notification to all subscribers of the "new user registration" event by way of a "callback" method. Each callback method would then be executed to perform their own specific tasks related to the new user registration. With this design in place, it becomes very easy to add new actions that may be required in the future by simply registering new callback methods to the "new user registration" event.

Java + .Net Demo

Let's walk through a simple "Team Roster" demo to see the publisher/subscriber pattern in action. Here are the requirements for our application:

The application must be able to add new players to a team roster.
When a new player is added, we need to notify the coaching staff and the media
The application also must allow for new entities to be able to subscribe to new player notifications.

When reviewing the Java and C# code below you will notice that the code is very similar (same total lines of code in fact). One large difference is in the way the callback methods are handled. Java uses a single interface that all subscribing classes implement whereas .Net utilizes "Delegates."

NOTE: Delegates are similar to a "type-safe" function pointer in C/C++.

The "Team" class is considered the publisher in our demo. It contains the logic to actually "add" the player to the roster and then raises the event to notify the subscribers. The two listener classes (CoachListener and MediaListener) are then added to the event notfications. The "AddPlayerEvent" object is the actual class that is passed to the callback methods (with the new playername value).

C#:

   1:  using System;

2:

   3:  namespace TeamRoster{

4:

   5:      class AddPlayerEventArgs : EventArgs{ //create Event object

   6:          public string PlayerName { get; set; }

   7:      }

   8:      class CoachListener{

   9:          // subscribe callback method "NotifyCoachingStaff" to AddPlayerEvent (event)

  10:          // using delegate "AddPlayerHandler"

  11:          public void Subscribe(Team team){

  12:              team.AddPlayerEvent += new Team.AddPlayerHandler(NotifyCoachingStaff);

  13:          }

  14:          // create "Coach" Listener callback method

  15:          private void NotifyCoachingStaff(Team team, AddPlayerEventArgs e){

  16:              System.Console.WriteLine("To Coaching Staff: ({0}) was added to the team", e.PlayerName);

  17:          }

  18:      }

  19:      class MediaListener{

  20:          // subscribe callback method "NotifyMedia" to AddPlayerEvent (event)

  21:          // using delegate "AddPlayerHandler"

  22:          public void Subscribe(Team team){

  23:              team.AddPlayerEvent += new Team.AddPlayerHandler(NotifyMedia);

  24:          }

  25:          // create "Media" Listener callback method

  26:          private void NotifyMedia(Team team, AddPlayerEventArgs e){

  27:              System.Console.WriteLine("To Media Outlet: ({0}) was added to the team", e.PlayerName);

  28:          }

  29:      }

  30:      //publisher

  31:      class Team{

  32:          // delegate will hold a type-safe "pointer" to the callback

  33:          // "Listener" callback methods

  34:          public delegate void AddPlayerHandler(Team team, AddPlayerEventArgs e);

35:

  36:          public event AddPlayerHandler AddPlayerEvent; // event that callback methods will subscribe to

37:

  38:          public void AddPlayer(string playername){ // method to add new player to roster

  39:              if (AddPlayerEvent != null){

  40:                  AddPlayerEventArgs e = new AddPlayerEventArgs();

  41:                  e.PlayerName = playername;

  42:                  System.Console.WriteLine("\nNew player added to the Roster, notifying all subscribers...");

  43:                  AddPlayerEvent(this, e); // call method to notify subscribers of new player

  44:              }

  45:          }

  46:      }

  47:      //main class

  48:      class AddTeamPlayer{

  49:          static void Main(){

50:

  51:              Team team = new Team();

  52:              CoachListener coachlistener = new CoachListener();

  53:              MediaListener medialistener = new MediaListener();

54:

  55:              coachlistener.Subscribe(team); // subscribe to event

  56:              medialistener.Subscribe(team); // subscribe to event

57:

  58:              Console.Write("-Team Roster-\n");

59:

  60:              team.AddPlayer("Memori"); // add player to roster

  61:              team.AddPlayer("Elias");

  62:              team.AddPlayer("Mikayli");

  63:              team.AddPlayer("Myranda");

  64:              team.AddPlayer("Elo");

65:

  66:              Console.ReadLine();

  67:          }

  68:      }

  69:  }

Java:

 1 package TeamRoster;
 2 
 3 import java.util.*;
 4 
 5 class AddPlayerEvent extends EventObject { // Create event object
 6 	private String playername;
 7 	public String getPlayerName() { // getter method to return playername
 8 		return this.playername;
 9 	}
10 	// event constructor to set instance property
11 	public AddPlayerEvent(Object source, String playername) {
12 		super(source);
13 		this.playername = playername;
14 	}
15 }
16 // All listener classes will implement this interface
17 interface PlayerListener {
18 	void addPlayer(AddPlayerEvent addplayerevent);
19 }
20 // publisher
21 class Team {
22 	// method to add new player to roster
23 	public void AddPlayer(String playername) {
24 		System.out.println("\nNew player added to the Roster, notify all subscribers...");
25 		// call method to notify subscribers of new player
26 		OnAddPlayer(playername);
27 	}
28 	// method to notify all subscribers when a new player has been added
29 	// to the roster
30 	private void OnAddPlayer(String playername) {
31 		for (int i = 0, size = subscribers.size(); i < size; i++)
32 			((PlayerListener) subscribers.get(i)).addPlayer(new AddPlayerEvent(this, playername));
33 	}
34 	// type-safe ArrayList container to hold subscribers to the event
35 	List<PlayerListener> subscribers = new ArrayList<PlayerListener>();
36 	// method to add new subscribers to the ArrayList
37 	public void addPlayerListener(PlayerListener plistener) {
38 		subscribers.add(plistener);
39 	}
40 }
41 // main class
42 class AddTeamPlayer {
43 	public static void main(String[] args) {
44 		Team team = new Team();
45 		// create "Coach" PlayerListener callback class/method (Anonymous class)
46 		// approach
47 		team.addPlayerListener(new PlayerListener() {
48 			public void addPlayer(AddPlayerEvent e) {
49 				System.out.println("To Coaching Staff: (" + e.getPlayerName() + ") was added to the team");
50 			}
51 		});
52 		// create "Media" PlayerListener callback class/method (Inner class)
53 		// approach
54 		class MediaListener implements PlayerListener {
55 			public void addPlayer(AddPlayerEvent e) {
56 				System.out.println("To Media Outlet: (" + e.getPlayerName() + ") was added to the team");
57 			}
58 		}
59 		team.addPlayerListener(new MediaListener());
60 
61 		System.out.print("-Team Roster-\n");
62 
63 		team.AddPlayer("Memori"); // add player to roster
64 		team.AddPlayer("Elias");
65 		team.AddPlayer("Mikayli");
66 		team.AddPlayer("Myranda");
67 		team.AddPlayer("Elo");
68 	}
69 }

Here is the Console output from the .Net code:

Here is the Console output from the Java code: