Last time, I walked through putting together a Family History Web service using Visual Web Developer 2005 Express Edition. To complete the circle, in this installment I'll show you a client application I built as a front end to the Web service. Before getting into the application itself, I want to report that since my last entry I've updated my development environment to use the latest beta release of the Microsoft Visual Studio Express Editions. If you haven't yet made the move yourself, I urge you do so at your earliest opportunity. Because the update introduces some breaking changes with earlier beta releases, this will likely inflict some pain if you've already built some applications. But for me, at least, the pain is far outweighed by the gain in bug fixes and features improvements, one of which I am pleased to highlight in this post. But I hold that for a bit later.

The client application for my Family History Web service is a Windows Forms application. As you may recall, the Web service exposes two methods; a search method and an update method. This provides the bare bones functionality I need to start gathering information about my ancestors. I thus started by creating a new Windows Application in Microsoft Visual C# 2005 Express Edition. Next, I added a connection to the Family History Web service as a data source.

All versions of Visual Studio provide an easy-to-use wizard for configuring a Web service as a data source for an application. I've described how to use the wizard in previous entries; you simply select the Data | Add New Data Source menu item. This launches a wizard that lets you choose from a Database, Web service or custom object as a data source. After selecting Web Service as my data source type, I clicked Next to open the Add Web Reference dialog.

One of the great benefits of Visual Studio 2005 is that you don't need to run Internet Information Services (IIS) on your development machine to build and test Web-based applications. Along with all that goodness, however, in certain circumstances you may have a minor problem when you go to write a client for a Web service. If you are building the client in a separate solution, as I am in this case, and haven't deployed the Web service to a publicly available address, which I have not, you won't be able to browse to the Web service using the page provided in the Add Web Reference dialog. To solve this, all I had to do was open the Family History Web service in Visual Web Developer 2005 Express Edition and run the application in debug mode. (And it's worth noting that I kept the Web service running while I built the client application to provide an end-to-end development environment.)

In the Web service summary page, I just copied the Url to the asmx page and copied it in to the URL text box of the Add Web Reference. I clicked Go and the wizard did the rest.

Alright, I've held you in suspense long enough and now I'll tell you about one of the great things in the latest release of Visual Studio 2005. If you did read my earlier entry about using the Google Web service, you may remember the problem I had with getting the wizard to properly display the data types exposed by a Web service. This was the result of a bug in earlier releases of Microsoft Visual Studio 2005 wherein in the subsystem responsible for generating the Web service proxy classes did not properly translate the schema exposed in the Web services contract (WSDL) into public properties. That meant that the data types did not appear correctly in the Data Sources window, which in turn meant that you could not take advantage of drag-and-drop databinding. Eventually I found a workaround for the problem and got everything working correctly, but only after a lot of frustration and cursing of the Microsoft Beta Gods.

To my great delight, after I successfully added a reference to the Family History Web service, I opened the Data Sources window and found that the data type was exposed in all its glory.

I quickly set about taking advantage of the tools provided in the Data Sources window: I updated associated controls for the BirthDate and DeathDate fields to use a DateTimePicker, and I changed the ID field to use a Label control

This made building the user interface very simple. I started by adding a SplitContainer control on the form and changing its orientation property to Horizontal. The modest design goal of my application was to provide a search capability on the top half of the form (using the FindPerson Web method exposed by the Web service) and using the bottom half of the form to add or update family member data (using the UpdatePerson Web method of the Web service). So, in the top panel of the SplitContainer I added to TextBox controls and a Button control to enable searching. To build the bottom half, in the Data Sources window I first changed the associated control for the top-level Person class to Details and then dragged it onto the form surface. Visual Studio drew all the necessary controls on the form and created the BindingSource and BindingNavigator components for handling the chore of binding the Web service data to the controls on the form. I rearranged the controls and added two Button controls to allow users to add new family members and update existing family members, respectively.

When a user executes a search using the top half of the form, the Web service returns an array of Person objects. The code below is from the private searchPersons method, which is called from the search button's click event handler. This shows the code that creates a new instance of the Web service proxy class, calls the FindPerson Web method using the first and last names input into the user interface. The array of Person objects returned from the Web service is bound to the controls on the form by assigning the array to the DataSource property of the BindingSource control.

Visual C#

localhost.FamilyHistory ws = new localhost.FamilyHistory();
localhost.Person[] persons = ws.FindPerson(firstNameSearch.Text, lastNameSearch.Text);

// Bind results to UI
personBindingSource.DataSource = persons;

Visual Basic

Dim ws As localhost.FamilyHistory = New localhost.FamilyHistory()
Dim persons() As localhost.Person = ws.FindPerson(firstNameSearch.Text, lastNameSearch.Text)

' Bind results to UI
personBindingSource.DataSource = persons

By default, the data for the first person in the array is displayed in the bottom half of the form. The BindingNavigator component allows users to navigate through the list of returned family members. Using a similar pattern to the search operation, the click event handlers for the new and update buttons call a private method called submitPerson. The new button differs from the update button only in that clear the value of the id field for the person. When the Web service receives an UpdatePerson message where the person id value is empty, this indicates this is a new record; otherwise, the person data is treated as an update to an existing record.

Visual C#

// Load data in Person object
localhost.Person person = new localhost.Person();
person.FirstName = firstNameTextBox.Text;
person.MiddleName = middleNameTextBox.Text;
person.LastName = lastNameTextBox.Text;
person.BirthDate = birthDateDateTimePicker.Value.ToShortDateString();
person.BirthLocation = birthLocationTextBox.Text;
person.DeathDate = deathDateDateTimePicker.Value.ToShortDateString();
person.DeathLocation = deathLocationTextBox.Text;
if (personId.Text != string.Empty)
{
     person.ID = Convert.ToInt32(personId.Text);
}

// Send update to Web service

Visual Basic

' Load data in Person object
Dim person As localhost.Person = New localhost.Person()
person.FirstName = firstNameTextBox.Text
person.MiddleName = middleNameTextBox.Text
person.LastName = lastNameTextBox.Text
person.BirthDate = birthDateDateTimePicker.Value.ToShortDateString()
person.BirthLocation = birthLocationTextBox.Text
person.DeathDate = deathDateDateTimePicker.Value.ToShortDateString()
person.DeathLocation = deathLocationTextBox.Text
If (personId.Text <> String.Empty) Then
  person.ID = Convert.ToInt32(personId.Text)
End If

' Send update to Web service
Dim ws As localhost.FamilyHistory = New localhost.FamilyHistory()
personId.Text = ws.UpdatePerson(person).ToString()
localhost.FamilyHistory ws = new localhost.FamilyHistory();
personId.Text = ws.UpdatePerson(person).ToString();

The return value from the UpdatePerson Web method is the id of the new or updated person record. This value is displayed back to the form.

Finally, I wanted to point out a special application setting that gets created when you add a connection to a Web service. Visual Studio 2005 automatically names the settings, and sets its value to the Url of the Web reference.

Application settings get stored in the application's configuration file, allowing you to update settings without having to recompile an application. Here's a snippet of the app.config file for the application.

When the application is compiled, this file appears in the output directory as <appName>.exe.config.

To appreciate the beauty of this, I looked at the code for the proxy class that Visual Studio 2005 automatically generated for the Web service. You may not see the proxy class because it is hidden by default. To view the file, titled Reference.cs, but clicking the Show All Files button in the Solution Explorer toolbar and then expand Web References | localhost | Reference.map as shown below.

In Reference.cs I found the Web Service URL application setting is accessed in the constructor of the proxy to establish the Url for the target Web service.

Visual C#

Visual Basic

Me.Url = FamilyHistoryClient.Settings.
    Default.FamilyHistoryClient_localhost_Family_x0020_History

While the auto-named property setting name is a bit unwieldy, this represents a big improvement on past implementations of Visual Studio 2005 Web service tools that hard-coded the Web reference Url in the proxy class. This made it difficult to use configuration settings to control the location of Web service endpoints at runtime. Of course, this will make it much easier for me to deploy my client application once I've found a home for the Family History Web service.

Building on my last installment, in this article I'll show you how to extend our basic RSS user control to work with more than one content feed. Combining syndicated content from various sources, known most simply as aggregation, widens the breadth of information available on your web site and lets you relate information in uniquely relevant ways for users.

One interesting background item I'd like to mention is Kent Sharkey's MSDN article E Pluriblog Unum: Merging RSS Feeds, which demonstrates some nifty techniques for merging RSS feeds into a single file. While the article is based on version 1.1 of the .NET Framework, you can use the source code that accompanies the article to jump start your own projects. I didn't do that myself, but I did borrow some of the ideas about how to approach aggregating syndicated content into a comprehensive view.

The first thing I considered was how to manage a list of individual feeds. While you can use a number of different techniques for tracking a list of source feeds, such as an Outline Processor Markup Language (OPML) file, I decided to take advantage of SQL Server 2005 Express Edition and the enhanced ASP.NET 2.0 data binding model to implement a basic RSS feed manager. Besides the ease of use ASP.NET 2.0 provides for accessing data, my main reason for choosing this method is that it sets the stage for leveraging the personalization services available using the Web Parts framework. After all, the ultimate goal of this type of application is to allow individual users to choose their own list of feeds. But let's not get ahead of ourselves; my goal in this article is to show how to manage the feed list itself.

In a fresh Visual Studio Web Developer Express project, I added a new SQL Database. I created a single table in the database and named it feeds. Using the integrated table designer, I configured three columns in the table: an identity column and two string-based columns for storing the title and location of the feed.

(click image to zoom)

Next, I added a new Web User Control to the project. From the Toolbox, I dragged a SqlDataSource control to the design surface of the Web User Control. This control is the cornerstone of the enhanced data access model in ASP.NET 2.0. It provides a direct connection between user interface controls and an ADO.NET managed provider (such as the SQL database I use in this application). From the smart tag menu, I selected "Configure Data Source..." to launch the data source configuration wizard.

(click image to zoom)

I followed the steps in the wizard to create a new connection string for the database, making sure that I selected the option to save the connection string information to the application configuration file. The wizard provides a page for building the default SQL SELECT statement. You can enter a custom SQL statement or stored procedure, or do what I did and work with the available table in the database to build the query statement directly.

Once you select a table, the available columns appear in the Columns list. As you select individual columns, the text of the SELECT statement displayed on the page gets updated accordingly. The next page in the wizard allows you to test the query. That wasn't much help in this case because I didn't have any data in the database.

After completing the wizard, I went back to the Toolbox and added a GridView control to the Web User Control page. The smart tag menu for the GridView control immediately appeared and I used the "Choose Data Source" dropdown menu to set the DataSourceID property to the SqlDataSource control.

(click image to zoom)

Next, I selected the "Edit Columns" item from the smart tag menu to edit the GridView's columns. I used the editor to make the identity column (feedId) invisible and updated the header text for the title and url columns so they would look better when displayed on the web page.

I also updated the appearance of the GridView using the Auto Format editor (accessible from the smart tag menu). I then moved over to the Properties window for the GridView control. To allow users to update or delete an item directly inside the list, I changed the AutoGenerateDeleteButton and AutoGenerateEditButton properties to true. This automatically altered the appearance of the GridView in the designer. As shown below, Edit and Delete links now appeared on the left side of the grid.

(click image to zoom)

The ADO.NET 2.0 object model is very simple, with the SqlDataSource control responsible for executing CRUD operations against a data source on behalf of its bound server controls. In this case, the SqlDataSource control is responsible for executing not only the SELECT statement to retrieve the data, but also the DELETE and UPDATE commands. Using the Properties window for the SqlDataSource control, I opened the Command and Property Editor for the DeleteQuery property and typed in the necessary SQL statement to perform a delete.

Notice that the parameter I used is written out as @original_feedId. The SqlDataSource control has another property titled OldValuesParameterFormatString that specifies how an input parameter ought to appear in a query. The default for this property is original_{0}, where {0} is a placeholder for the actual value of the parameter. Also note that I changed the Parameter source value to Control and the ControlID value to point to the GridView control. I followed the same procedure to add an UPDATE SQL statement in the UpdateQuery property of the SqlDataSource control.

Well, all that is well and good. However, I found that the GridView does not provide an easy way to add new records to a database. You can solve this problem in a number of different ways (including creative use of the footer template of the GridView). My solution was to use the DetailsView control. Like the GridView, this is another versatile tool for data access. It lets you navigate over a set of data, displaying one record at a time, update or delete the current record, or add a new record. You can also use this control in conjunction with a GridView to implement a classic master/detail representation of data. In that scenario, the GridView simply displays a list of selectable items, which when selected appear in detail in the DetailsView control. The flexibility of these controls gives you a lot of choices in providing the best user interface for your Web pages. For my purposes, I liked the idea of providing direct edit and delete in the GridView, while using the DetailsView for adding new records.

(click image to zoom)

After adding a DetailsView control directly beneath the GridView, I set its DataSourceID property to the SqlDataSource control and made sure that only its AutoGenerateInsertButton property was set to true. To boost performance, I changed the EnabledViewState property to false. With that done, I added the necessary SQL text for performing a database INSERT in the InsertQuery property of the SqlDataSource control.

The only difference between the configuration of the InsertQuery property and the other query-related properties of the SqlDataSource control was that the ControlID for InsertQuery was set to the DetailsView control (rather than the GridView).

Remarkably, I implemented all the logic for managing the feed list without having to write a single line of code. Of course, downloading and merging the feeds is another matter, but it is certainly worth pausing here to marvel at the power and simplicity of the ASP.NET 2.0 data binding architecture.

In order to display the aggregated RSS 2.0 feeds, the first hurdle is implementing a common data format. Because I only needed to display a few standard data items (item, description and link), I decided to use a strongly-typed DataSet to store the data gathered from each feed. The main advantage of this approach is that I could easily bind the resulting data to a user interface control. After adding a new DataSet to the project, I opened it in the designer and created a single DataTable with four columns (see below).

(click image to zoom)

In addition to the three basic item attributes, I also included a column called Feed to store the name of the source RSS feed so I could display this information on the Web page.

Next, I added two private methods to the FeedManager control's code file. The first method, MergeRssFeeds, is called from the control's Load event handler. The first line of code creates a class-level instance of the strongly-typed AggregateRSS dataset used to hold the data extracted from the RSS feeds. The code then iterates through the rows of the GridView control, which represent each of the configured RSS feeds. Within the For loop, the code calls a second method, AddRssFeed, passing in the name of the RSS Feed and the URL address of the RSS feed.

Visual Basic

Private Sub MergeRssFeeds()
    RssData = New AggregatedRSS
    If Me.GridView1.Rows.Count > 0 Then
        For i As Integer = 0 To Me.GridView1.Rows.Count - 1
            AddRssFeed(Me.GridView1.Rows(i).Cells(2).Text, _
                Me.GridView1.Rows(i).Cells(3).Text)
        Next i
    End If
    Me.Repeater1.DataSource = RssData
    Me.Repeater1.DataBind()
End Sub 

Visual C#

private void MergeRssFeeds()
{
    RssData = new AggregatedRSS();
    try
    {
        if (this.GridView1.Rows.Count > 0)
        {
            for (int i = 0; i < this.GridView1.Rows.Count; i++)
            {
                AddRssFeed(this.GridView1.Rows[i].Cells[2].Text,
                this.GridView1.Rows[i].Cells[3].Text);
            }
        }
        this.Repeater1.DataSource = RssData;
        this.Repeater1.DataBind();
    }
    catch (WebException wx)
    {
        Literal1.Text = String.Format(
        "<h3>Error</h3><p>A Web exception occurred while merging the" + 
        " RSS feeds.<br/>Make sure you have a valid connection to the " + 
        "internet.</p><p><em>{0}<em></p>", wx.Message);
        Literal1.Visible = true;
    }
}

At the end of the loop, the code sets the DataSource property of the Repeater control to the populated DataSet and then calls the DataBind method of the Repeater to bind the data to the control.

The helper method AddRssFeed performs most of the heavy lifting in this application. The code first fetches the RSS feed using the WebRequest class and loads the data into an XmlTextReader. The code then sets up a While loop to iterate over the XML stream. To make the code easier to explain, I've included the first few lines of code below.

Visual Basic

Private Sub AddRssFeed(ByVal feedTitle As String, ByVal feedUrl As String)
    Dim rssReader As XmlTextReader = Nothing
    Dim itemCount As Integer = 0

    Try
        Dim rssFeed As WebRequest = WebRequest.Create(feedUrl)
        rssReader = New XmlTextReader(rssFeed.GetResponse().GetResponseStream())
        While rssReader.Read
            [see detail below]
        End While
    Finally
        If Not rssReader Is Nothing Then rssReader.Close()
    End Try
End Sub 
 

Visual C#

private void AddRssFeed(string feedTitle, string feedUrl)
{
    XmlTextReader rssReader = null;
    int itemCount = 0;

    try
    {
        WebRequest rssFeed = WebRequest.Create(feedUrl);
        rssReader = 
            new xmlTextReader(rssFeed.GetResponse().GetResponseStream());
        while (rssReader.Read())
        {
             [See the detail below]
        }
    }
    finally
    {
        if (itemReader != null) itemReader.Close();
    }
}

Inside the outside While loop, the code looks for elements named "item". This indicates that an RSS feed item is the current node. When this happens, the code creates a new RssItemRow to store the item data and then creates a new XmlReader object using the ReadSubTree method of the parent XmlReader. This reader (called itemReader) holds the current RSS item data. The code calls the Read method of the inner XmlReader to find each of the data items of interest. When found, the code stores the data value in the appropriate cell of the RssItemRow. At the end of the inside While loop, the code calls the strongly-typed AddRssItemRow method of the DataTable to add the row to the DataSet.

Visual Basic

While rssReader.Read
    If rssReader.IsStartElement And ("item" = rssReader.LocalName) Then
        Dim itemReader As XmlReader = Nothing
        Try
            Dim newRow As AggregatedRSS.RssItemRow = RssData.RssItem.NewRssItemRow()
            itemReader = rssReader.ReadSubtree()
            newRow.Feed = feedTitle
            While itemReader.Read
                If itemReader.IsStartElement Then
                    If ("title" = itemReader.LocalName) Then
                        newRow.Title = itemReader.ReadString
                    ElseIf ("description" = itemReader.LocalName) Then
                        Dim newDescription As String = itemReader.ReadString
                        ' Truncate description to 100 characters
                        If newDescription.Length > 100 Then
                            newDescription = newDescription.Substring(0, 100) + " ..."
                        End If
                            newRow.Description = newDescription
                        ElseIf ("link" = itemReader.LocalName) Then
                            newRow.Link = itemReader.ReadString
                        End If
                    End If
            End While
            RssData.RssItem.AddRssItemRow(newRow)
            itemCount = itemCount + 1
        Finally
            If Not itemReader Is Nothing Then itemReader.Close()
        End Try
    End If
    ' Add only the first five items from each feed
    If itemCount >= 5 Then Exit While
End While

Visual C#

while (rssReader.Read())
{
    if ((rssReader.IsStartElement()) && ("item" == rssReader.LocalName))
    {
        XmlReader itemReader = null;
         try
         {
        AggregatedRSS.RssItemRow newRow = RssData.RssItem.NewRssItemRow();
        itemReader = rssReader.ReadSubtree();
        newRow.Feed = feedTitle;
        while (itemReader.Read())
        {
            if (itemReader.IsStartElement())
            {
            if ("title" == itemReader.LocalName)
                newRow.Title = itemReader.ReadString();
            else if ("description" == itemReader.LocalName)
            {
                string newDescription = itemReader.ReadString();
                //Truncate description to 100 characters
                if (newDescription.Length > 100)
                    newDescription = newDescription.Substring(0, 100) + 
                        " ...";
                newRow.Description = newDescription;
            }
            else if ("link" == itemReader.LocalName)
                newRow.Link = itemReader.ReadString();
            }
        }
        RssData.RssItem.AddRssItemRow(newRow);
        itemCount++;
         }
        finally
        {
            if (itemReader != null) itemReader.Close();
        }
        // Add up to 5 of the items returns (this can be set in a 
        // configuration file)
        if (itemCount >= 5) break;
    }
}

That's all the code I need to implement the RSS aggregation. As you can see, the hairiest part of the application was setting up the XmlReader and iterating through them to extract the necessary feed data. But once that task was accomplished, ASP.NET's superior data binding capabilities made building this application very easy.

(click image to zoom)

Looking ahead, the next step in the evolution of this project is to separate out the feed manager and feed display components into separate controls and to add personalization services ASP.NET 2.0 Web Parts framework. Until next time.

In my next two entries I’m going to review a family history Web service I’ve built using Visual Web Developer 2005 Express Edition. In this entry, I’ll start with a look at the Web service. In a following article, I’ll show you a client application I’ve built for my sister and cousins to use for collecting data about our shared ancestors (sorry, but Mom still won’t go near a computer).

To begin, I fired up Visual Web Developer 2005 Express Edition and created a new ASP.NET Web site. A nice convenience of the latest version of ASP.NET is that you don’t need to install Internet Information Server (IIS) on your computer to build Web sites or Web services. Instead, you can run the application locally using the built-in Visual Web Developer Web Server. When you run a Web application, you’ll notice an icon appears in your task bar. If you double-click on the icon, a details dialog box similar to the one shown below appears. I really, really like this feature as it reduces the hassle of configuring your system to build Web applications to zero.

But I’m get a bit ahead of the game. Once I had my new Web service opened in the IDE, my first task was to create a store for my family data. When you create a new project, you’ll notice a folder titled "Data" in the list of project items. When I right-clicked the folder and selected "Add New Item..." from the context menu, this displayed the dialog shown below.

You can use XML or an ordinary text file as your data source for a Web application. As you can see, I chose a database – I named it, and then clicked the Add button. This created a brand new SQL Server Express database file for me in the project. Another great feature of Visual Studio 2005 in all its flavors is that you get built-in database support, without the muss or fuss of using an external program. Think of it as a one-stop shop. And Visual Web Developer 2005 Express Edition provides a wickedly simple designer for defining tables, views, stored procedures and other types of database objects. I created a new table named "person" and defined columns for the various attributes I want to record in my family history database.

With the skeleton of my database laid out, I moved to the Service.cs code file in my Web services application. Here I started by adding an attribute to the class definition.

Visual C#

[WebService(Namespace = "uri:family:geneology",Name = "Family History", 
                Description = "Web service for gathering family history data." )]

Visual Basic

<WebService(Namespace:="uri:family:geneology", Name:="Family History", _ 
                Description:="Web service for gathering family history data.")>

The WebServiceAttribute class (you can leave out "Attribute" in your code as I did) lets you give the Web service a unique internet identity using the namespace attribute. I also gave the Web service a name and a description.

Then I renamed the stub "Hello World" Web method to "FindPerson" and updated its WebMethodAttribute declaration to describe the task I intend for the Web method. In this case, the FindPerson method returns a list of people stored in my family history database based on some search criteria. After thinking a bit about how to return search results, I decided against using a DataSet (which is possible but not really a good idea if you want your Web service to get along well with non-.NET clients) and chose to model a Person object after the contents of my database and use that as my return type.

I added a class named "Person" to my project and defined a number of public properties that deliberately map to the columns in the person table of the database. Of course, I am not solely bound to mapping the attributes of the table data to the properties of the class; I will probably extend the class some more with behaviors as this application takes on more heft later on. Next, to make the class truly useful, I added a SerializableAttribute to the class declaration.

Visual C#

[Serializable()]
public class Person {
...
}

Visual Basic

<Serializable()> _
Public Class Person
...
End Class

This signals to the ASP.NET runtime that the class and all of its properties can be serialized (that is, converted to XML) either as an input to one of my Web methods or as a return value.

Returning to the Web method, I updated the method signature to return an array of Person objects (families do have members with the same first and last names, after all). I also added another Web method called "UpdatePerson" for adding a new person to my database or for updating an existing person. Again, I took advantage of the underlying serialization capabilities of ASP.NET by declaring a single input parameter of type Person.

Following good coding practice, I factored out the actual nuts and bolts work of querying and updating the database to three private helper methods in the Service.cs file. If you look over the code in the "SearchPerson", "AddPerson" and "UpdatePerson" methods you will find the application uses stored procedures to perform work against the database. Again, the database tools provided in Visual Studio Web Developer 2005 Express made this chore virtually painless.

That completes the tour of this application. Next time, I’ll show you the client application I’m going to use to manage querying and data entry for the Web service. In the meantime, I encourage you to download Visual Web Developer 2005 Express Edition and explore this Web service application for yourself.

You probably already know about Apple's iTunes application and that it allows you to play and organize your music collection, as well as buy individual songs from their online store. What you probably don't know is that all the information you store using iTunes is stored as XML; that allows you to display your music library in different formats. Like a web page, for example.

So, to give you a flavor for how you might use the iTunes data in your own applications, in this article I'll use some of the new ASP.NET controls available in Visual Web Developer 2005 Express to display my iTunes library on a Web page.

If you want to use your own library and you don't already have iTunes installed, visit http://www.apple.com/itunes to download the free iTunes application. Using my own library, I began by creating a new ASP.NET Web site. Next, I used the Web Site | Add Existing Item menu command to add my iTunes music library file.

As pictured above, the default iTunes directory is located in the My Music folder. The XML file is named iTunes Music Library.xml. After adding the file to my Web site project, I changed the name to something simpler: iTunes.xml.

ASP.NET 2.0 introduces a new XmlDataSource control that is a special type of data source control for consuming XML data. In Visual Web Developer 2005 Express, you'll find this control located in the Data section of the Toolbox. After dragging an XmlDataSource control onto the Web form, I used the Configure Data Source dialog box to point the control to my iTunes data file.

Before moving on, take a moment to look at the other options available in the Configure Data Source dialog. You can specify a transformation file that updates the structure of the XML file. You may wonder why this might be necessary. But as I discovered myself shortly after performing this step, you will often find circumstances where it's necessary to change the source XML to make it a usable data source. For now, however, I only set the DataFile property of the XmlDataSource property.

<asp:XmlDataSource ID="XmlDataSource1" runat="server" DataFile="~/iTunes.xml">
</asp:XmlDataSource>

Also, if you peek at the source code for the default Web form at this point, you'll find code similar to that shown above. This highlights the fact that you can easily add code directly to ASP.NET Web forms to configure controls. The Visual Studio designers simply provide an easy-to-use alternative to hand coding while reducing the guesswork.

The XmlDataSource by itself only takes you halfway toward displaying XML data on a web page: You also need a control for displaying that data. Because the XmlDataSource control supports declarative databinding to XML files, you can use it to bind hierarchical data to controls that are specially designed for traversing this type of data, like a TreeView or Menu. You can also use the XmlDataSource for binding XML data to list controls like the GridView, DropDownList or DataList controls.

On the design surface of the Default Web form, I added a TreeView control on the line below the XmlDataSource control. Next, I set the DataSource property of the TreeView to the instance of the XmlDataSource control. Again, leveraging the designer support in Visual Studio 2005, I accomplished this easily using the Smart Tag menu provided with the TreeView control.

At design time, the TreeView control displays the data as it will appear when you run the Web page. The following graphic shows what the data from my iTunes XML file looked like at this point.

Hmmmm …. that's not very useful, is it? It's time to take a look at the iTunes XML file. Below is a snippet from my file.

<dict>
        <key>35</key>
        <dict>
            <key>Track ID</key><integer>35</integer>
            <key>Name</key><string>Gula Gula</string>
            <key>Artist</key><string>Jan Garbarek</string>
            <key>Composer</key><string>Mari Boine Persen, arr Jan Garbarek</string>
            <key>Album</key><string>I Took Up The Runes</string>
            <key>Genre</key><string>Jazz</string>
            <key>Kind</key><string>AAC audio file</string>
            <key>Size</key><integer>5892093</integer>
            <key>Total Time</key><integer>363578</integer>
            <key>Disc Number</key><integer>1</integer>
            <key>Disc Count</key><integer>1</integer>
            <key>Track Number</key><integer>1</integer>
            <key>Track Count</key><integer>10</integer>
            <key>Year</key><integer>1990</integer>
            <key>Date Modified</key><date>2005-06-06T04:11:43Z</date>
            <key>Date Added</key><date>2005-06-06T04:11:18Z</date>
            <key>Bit Rate</key><integer>128</integer>
            <key>Sample Rate</key><integer>44100</integer>
            <key>Track Type</key><string>File</string>
            <key>Location</key><string>file://localhost/C:/Documents%20and%20Settings/User1/
                My%20Documents/My%20Music/iTunes/iTunes%20Music/Jan%20Garbarek/I%20Took%20Up
                %20The%20Runes/01%20Gula%20Gula.m4a/</string>
            <key>File Folder Count</key><integer>4</integer>
            <key>Library Folder Count</key><integer>1</integer>
        </dict>
. . . 
</dict> 

Even old hands with XML may find this a peculiar structure. Rather than employing a traditional hierarchical tree structure, the key/value pairs represent something more akin to a serialized dictionary object. The key/value pairs are composed so that the first element is the key and the next is the value. To transform this data into a structure that the ASP.NET controls can use, I added an XSLT File to the Web site project and named the file iTunes.xsl. I had a number of choices in how to execute the transformation – for example, deciding which of the various properties of each song I wanted to use – but the basic approach you need in any case is that the properties of interest much appear in the transformed XML structure as attributes. In terms of limiting the data I wanted to display, I choose to use only three properties of each song: the name of the song, the artist, and the album.

The XSL for performing the transformation required that I create a new node named track for each song, and add an attribute named value that stores the name of the song. The transformation then creates two child-nodes for each track node called artist and album, respectively. Again, to represent the data associated with each of these items, I used an attribute named value.

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" 
  version="1.0"
  encoding="iso-8859-1" 
  indent="yes" />

  <xsl:template match="/">
    <xsl:element name="library">
      <xsl:attribute name="value">
        <xsl:value-of select="'My iTunes Library'" />
      </xsl:attribute>
      <xsl:apply-templates select="plist/dict/dict/dict"/>
    </xsl:element>
  </xsl:template>

  <xsl:template match="plist/dict/dict/dict">
    <xsl:element name="track">
      <xsl:attribute name="value">
        <xsl:value-of select="key[.='Name']/following-sibling::node()[1]"/>
      </xsl:attribute>
      <xsl:call-template name="artist" />
      <xsl:call-template name="album" />
    </xsl:element>
  </xsl:template>

  <xsl:template name="artist">
    <xsl:element name="artist">
      <xsl:attribute name="value">
        <xsl:value-of select="key[.='Artist']/following-sibling::node()[1]"/>
      </xsl:attribute>
    </xsl:element>
  </xsl:template>

  <xsl:template name="album">
    <xsl:element name="album">
      <xsl:attribute name="value">
        <xsl:value-of select="key[.='Album']/following-sibling::node()[1]"/>
      </xsl:attribute>
    </xsl:element>
  </xsl:template>
  
</xsl:stylesheet> 

The intricacies of XSL and XPath are beyond the scope of this article (if you want to learn more about these topics, a good place to start is http://www.w3schools.com/default.asp).

Returning to the Configure Data Source dialog box for the XmlDataSource control, I set the TransformFile property to the XSL stylesheet. As shown below, the updated schema improved the data displayed in the TreeView control, but I still had some work to do in order to get the correct data.

Next, I opened the TreeView DataBindings Editor using the Smart Tag menu for the TreeView control. I added each of the nodes in the available data bindings list and then set the TextField property of each of the bindings to display the value XML attribute created during the XSL transformation.

After closing the TreeView DataBindings Editor, I returned to the Smart Tag menu for the TreeView control. I selected the Auto Format menu item and used the Auto Format dialog box to choose a more stylish scheme for my list.

As a final touch, I used the old-fashioned Properties window to change the ExpandDepth property of the TreeView control so it only showed songs beneath the main library node.

This example has only scratched the surface of what you can do with your iTunes music data and ASP.NET 2.0. In fact, with this nudge I'm hopeful you may be inspired to find even more creative ways to show off your great taste in music to the rest of world. Consider, for example, using this example to build on Bill Evjen's fine article on how to extend the Personal Web Site Starter Kit (http://msdn.microsoft.com/coding4fun/webcoder/extendpws/default.aspx).

Quite a few years ago, I came to the practical conclusion that I don't know everything there is to know about the world. Sure, it's presumptuous to even start from a place that requires such a conclusion. But such arrogance is a failing of youth, and I know better now. In fact, this reality is only magnified in the Internet age, as I find it virtually impossible to keep up-to-date with the non-stop flow of information, ideas, and opinions available on the web. Even within my modest scope of interests, I have a hard time staying current with the latest developments in Visual Basic, Visual C# and the .NET Framework.

So, over the course of my next few entries I'm going to explore different approaches to using something with which you're likely already familiar: RSS (a/k/a Really Simple Syndication) —a technology that greatly eases the burden of grappling with information overload.

As a quick primer, Wikpedia describes RSS as "short descriptions of web content together with links to the full versions of the content. This information is delivered as an XML file called an RSS feed, webfeed, RSS stream, or RSS channel. In addition to facilitating syndication, RSS allows a website's frequent readers to track updates on the site using a news aggregator." (For the full entry, see RSS on Wikpedia).

To get started, we'll look at a simple RSS feed reader you can build using Visual Web Developer 2005 Express Edition. I'm going to build a control that fetches an RSS feed from a site of interest and organizes that content for display on a web page. Of course, you could also build an RSS feed reader as a Windows application, or take advantage of any one of a number of free RSS client applications available (e.g., RSS Reader or SharpReader) if your aim is to aggregate content for your own personal consumption. Using syndicated content in a Web application has a different purpose, however, as it allows you to extend the content you create yourself and enrich the user experience of visitors to your site.

Before getting into the code, let's first take a look at a snippet of a typical RSS 2.0 file. In this example, the syndication provider is Microsoft's MSDN Web site, and I'm using the feed devoted to Visual Basic content.

<rss
  xmlns:msdn="http://msdn.microsoft.com/aboutmsdn/rss/"
  xmlns:dc="http://purl.org/dc/elements/1.1/"
  xmlns:msdndomain="http://msdn.microsoft.com/aboutmsdn/rss/domains"
  version="2.0">
  <channel>
    <title>MSDN: Visual Basic</title>
    <link>http://msdn.microsoft.com/vbasic/</link>
    <description>Recently Published Visual Basic Content</description>
    <language>en-us</language>
    <pubDate>Thu, 30 Jun 2005 13:01:02 GMT</pubDate>
    <lastBuildDate>Thu, 30 Jun 2005 13:01:02 GMT</lastBuildDate>
    <generator>MSDN RSS Service 1.1.0.0</generator>
    <ttl>1440</ttl>
    <item>
      <title>June CTP of Visual Studio 2005 Available to MSDN Subscribers</title>
      <description>The latest Community Technical Preview of Visual Studio 2005 is now 
                   available for download to MSDN subscribers.</description>
      <link>http://msdn.microsoft.com/subscriptions/</link>
      <category domain="msdndomain:ContentType">Announcement</category>
      <category domain="msdndomain:Subject">.NET development</category>
      <msdn:headlineImage>
        http://msdn.microsoft.com/msdn-online/shared/graphics/icons/article.gif
      </msdn:headlineImage>
      <msdn:contentType>Announcement</msdn:contentType>
      <msdn:simpleDate>Jun 27</msdn:simpleDate>
      <guid isPermaLink="false">Titan_1106</guid>
      <pubDate>Tue, 28 Jun 2005 02:00:13 GMT</pubDate>
    </item>
    <!-- more items follow -->
  </channel>
</rss> 

A typical feed file is loaded with information, some of which is not included uniformly by all syndication providers (MSDN's headline image, for example, is not standard). At the top of the XML structure is a single <channel> node that includes a title and description you can use to introduce the list of content items. The <channel> node contains many child <item> nodes representing each article of content (including the title of the article, a description, publication date and the link to the full article).

After creating a new Web Site in Visual Web Developer 2005 Express Edition, I added a Web User Control that I'll use to display this information.

(click image to zoom)

One of the features of ASP.NET 2.0 is that it supports both the code-behind model familiar to Visual Studio 2003 developers, and (something new) in-line code which allows you to write all your code within <script> tags in the .aspx or .ascx files. While using the in-line code approach doesn't make any difference in how the ASP.NET pages perform, I prefer the code-behind model and will use it throughout this example. You'll also notice that I'm using Visual Basic to write the code for this application.

Working in the designer, I added a Repeater control to the control. The Repeater is a data-bound control for displaying data using a custom layout. This is ideal for showing a list of content items from an RSS feed. As shown below, you can use the smart tag menu associated with the control to set the data source for the control at design. However, for this application I'll be setting the data source at runtime using the RSS feed.

(click image to zoom)

Switching to the code-behind file for the .ascx file (RSSList.ascx.vb), I added Imports statements for the namespaces containing the classes necessary to acquire the RSS feed and store it to a local resource that will bind to the Repeater.

Visual C#

using System.Data;
using System.Net;

Visual Basic

Imports System.Net
Imports System.Data

In addition to using the event handler for the control's Page Load event, I also added a private helper function called RefreshFeed. This gets the RSS data and returns it as a DataSet to the Page Load event handler. In the RefreshFeed function, the first line of code creates an instance of an HttpWebRequest object using the shared Create function of the WebRequest class.

Visual C#

HttpWebRequest rssFeed = (HttpWebRequest)WebRequest.Create(
    "http://msdn.microsoft.com/vbasic/rss.xml");

Visual Basic

Dim rssFeed As HttpWebRequest =_ 
DirectCast(WebRequest.Create("http://msdn.microsoft.com/vbasic/rss.xml"),_
           HttpWebRequest)

As an input argument to the Create function, the code passes the target URL of the RSS feed. The function returns an HttpWebRequest object, which is a special type of WebRequest object that supports additional properties and methods for interacting with servers using HTTP. In this case, my needs are very simple for HttpWebRequest; the code first gets the response from the server (GetResponse) and then, because the response is in XML format, the response stream (GetResponseStream) can be loaded directly into a DataSet using the ReadXml method overload that accepts a Stream as an input argument.

Visual C#

DataSet rssData = new DataSet();
rssData.ReadXml(rssFeed.GetResponse().GetResponseStream());

Visual Basic

Dim rssData As DataSet = New DataSet()
rssData.ReadXml(rssFeed.GetResponse().GetResponseStream())

The ReadXml method automatically infers the schema for the XML data. That means the <channel> and <items> nodes of the source XML data are represented in the DataSet as separate DataTables. In the Page Load event handler, after calling the RefereshFeed method to return a DataSet containing the RSS feed data, the code access the channel and items data in different ways. The second DataTable in the DataSet contains the channel information. To display the feed title and description, the code copies the first and only row from the DataTable into an Object array using the ItemArray property of the Row. Then, because I want to be sure I locate the correct data column, the code assigns the ordinal position of the title and description columns, respectively, to local variables of type Integer. Using these values, the code calls the GetValue method of the Object array to store the value associated with each column to the Friend field defined for the class (I'll use these values in the Repeater control).

Visual C#

object[] channelItems = rssData.Tables[1].Rows[0].ItemArray;
int titleColumn = rssData.Tables[1].Columns["title"].Ordinal;
int descriptionColumn = rssData.Tables[1].Columns["description"].Ordinal;
Title = channelItems.GetValue(titleColumn).ToString();
Description = channelItems.GetValue(descriptionColumn).ToString();

Visual Basic

Dim channelItems As Object() = rssData.Tables(1).Rows(0).ItemArray
Dim titleColumn As Integer = rssData.Tables(1).Columns("title").Ordinal
Dim descriptionColumn As Integer =
     rssData.Tables(1).Columns("description").Ordinal
Title = channelItems.GetValue(titleColumn).ToString()
Description = channelItems.GetValue(descriptionColumn).ToString()

Next, the code sets the DataSource property of the Repeater control to the DataTable in the DataSet holding the item content from the RSS feed. Finally, the code calls the DatBind method of the Repeater to bind the data source to the control.

Visual C#

Repeater1.DataSource = rssData.Tables(2)
Repeater1.DataBind() 

Visual Basic

Repeater1.DataSource = rssData.Tables(2)
Repeater1.DataBind() 

In the source view of the RssFeed.ascx control, I added templates for the Repeater control to display the data. In the <HeaderTemplate> the code begins a table with a header element that displays the channel title and description.

<HeaderTemplate>
   <table border=0 
          style="width: 240px; font-size: x-small; color: black; font-family: Verdana;">
       <thead>
           <tr style="font-weight: bold;">
               <td><%#Me.Title%></td>
           </tr>
           <tr style="font-style: italic;">
               <td><%#Me.Description%></td>
           </tr>
       </thead>
</HeaderTemplate> 

Similarly, in the <ItemTemplate> the code displays the title of a content item with its associated link, as well as the description of the item.

<ItemTemplate>
   <tr bgcolor="LightBlue">
       <td>
           <a target="article" style="text-decoration: none; color: black;"
            href=&amp;lt;%# DataBinder.Eval(Container.DataItem, "link") %&amp;gt;>
            <%# DataBinder.Eval(Container.DataItem, "title") %> </a>
        </td>
    </tr>
    <tr bgcolor="Ivory">
        <td style="color: CornFlowerBlue;">
           <%# DataBinder.Eval(Container.DataItem, "description") %>
        </td>
   </tr>
</ItemTemplate>

As a final and very necessary step, I added an OutputCache directive to at the top of the .ascx page to cache the output of the control for one hour.

<%@ OutputCache Duration="3600" VaryByParam="None" %>

(click image to zoom)

In future articles I'll dig deeper into the possibilities for using syndicated RSS feeds in a Web application. Until then, I encourage you to download the code and try it out for yourself.

While you can use the Amazon Web services for free, you first need to register with Amazon. Once you've registered, Amazon will email you a subscription identification code to include in the requests you send to the Web service. I'll show you how that works once we get into the code for the application.

Amazon recently released version 4.0 of its E-Commerce Web Services (ECS). Unfortunately, I discovered some problems using the ECS version, as documented here. So for this application, I used the previous 3.0 release of Amazon Web services.

The 3.0 release includes a downloadable software development kit. Before getting started on the application, I installed the SDK on my computer. The SDK provides all the information you need on using Amazon Web services to add content to Web sites, enable transactions, and upload products to Amazon.com. I don't need to add content to my Web site or use the more advanced features of the Amazon Web services. Not yet, anyway. I usually have modest objectives when I begin working with unfamiliar technology. A desktop application that uses one of the Web methods provided by the Amazon Web service is a good starting point. Once I get familiar with the Amazon Web services I can look forward to tackling more ambitious projects later on.

For this example, we'll use one of the new Visual Studio 2005 Express Editions. The Express Editions of Visual Studio 2005 are simplified, streamlined and lightweight versions of Visual Studio tailored for hobbyist, novice, and student developers. Beta 2 of the Express editions can be downloaded at http://msdn.microsoft.com/express. Any of the Visual Studio 2005 Express Editions allow you to build applications which consume Web services; I'm using Visual C# 2005 Express Edition in this example.

Prior versions of Visual Studio .NET made it very easy to incorporate a Web service in an application. Visual Studio 2005 is no different. The easiest and most direct method is to use the Add Web Reference dialog, accessible from either the Project menu or by right-clicking on the project in Solution Explorer. The Add Web Reference dialog lets you browse your local machine or external locations for available Web services. For the Amazon Web service, I copied in the path to the Web Services Description Language (WSDL) file from the “DTD, XSD and SOAP WSDL” page in the References section of the API Guide. A WSDL (pronounced “wiz-dull”) is an XML-based representation of all the information you need to use a particular Web service, including the locations (or endpoints) for sending messages, descriptions of the operations provided by the Web service and how they need to be formatted, and the types of data you can include in a message.

I then clicked the “Go” button and the wizard went off to find the WSDL file. After a second or two the wizard displayed a service description for the Amazon Web service. The wizard added a default Web reference name of  “com.amazon.soap”. I changed that to something simpler, “Amazon”. When I clicked the Add Reference button, Visual C# Express automatically translated the WSDL file into a class (contained in the hidden project file Reference.cs). This class serves as a proxy for interacting with the Web service using managed types without having to bother with the gory details of SOAP or XML serialization or how to invoke a Web service. Visual C# Express also outfits the class with asynchronous versions of all the Web methods it discovers in the WSDL. All this behind-the-scenes work frees you to concentrate on the details of working with the methods and data exposed by the Web service to do interesting things in your application.

To simplify my code, I added a using statement at the top of the Form1.cs file for the namespace containing the Amazon Web service proxy class.

Visual C#

using WSFun.Amazon;

Visual Basic

Imports WSFun.Amazon

To perform a keyword search of the Amazon product listing, you need to call the KeywordSearchRequest Web method. This method requires a KeywordRequest input parameter, so my first task was to create an instance of a KeywordRequest object and set its various properties.

Visual C#

KeywordRequest keywordReq = new KeywordRequest();
keywordReq.locale = "us";
keywordReq.type = "lite";
keywordReq.sort = "reviewrank";
keywordReq.mode = this.SearchMode;
keywordReq.keyword = this.searchText.Text;
keywordReq.tag = this.SubscriberID;
keywordReq.devtag = this.SubscriberID;

Visual Basic

Dim keywordReq As KeywordRequest = New KeywordRequest()
keywordReq.locale = "us"
keywordReq.type = "lite"
keywordReq.sort = "reviewrank"
keywordReq.mode = Me.SearchMode
keywordReq.keyword = Me.searchText.Text
keywordReq.tag = Me.SubscriberID
keywordReq.devtag = Me.SubscriberID

I used hard values for the type and sort properties; I could have added user controls to the form to manipulate those values at runtime (for example, to sort the results alphabetically or by their sales rank rather than the hard-coded customer review rank). The mode and keyword properties are dynamic. The mode property controls which product line to search. Here, I use the value specified in the selected radio button on the form: either Books, Music or DVDs. I added a common handler for each of the radio button's CheckedChanged event to update the private member SearchMode to the appropriate string value used in the request.

Visual C#

keywordReq.tag = this.SubscriberID;
keywordReq.devtag = this.SubscriberID;

Visual Basic

keywordReq.tag = Me.SubscriberID
keywordReq.devtag = Me.SubscriberID

In the final lines of this block of code, I set the credentials for the request using the subscription identifier I obtained from Amazon. For version 3.0 of the Amazon Web services, you need to add this value to both the tag and devtag properties of the KeywordRequest. I accessed the subscription identifier using a private property. This makes the code more manageable. I stored the actual subscriber id in the application's configuration file; this allows me to change the id without having to recompile the application. If you download the code accompanying this article, be sure to update the app.config file to use the subscriber identification you obtain from Amazon.

Next, I created an instance of the Web service proxy class and called the KeywordSearchRequest method, passing in the KeywordRequest object as an input parameter.

Visual C#

AmazonSearchService amazonWS = new AmazonSearchService();
ProductInfo productInfo = amazonWS.KeywordSearchRequest(keywordReq);

Visual Basic

Dim amazonWS As AmazonSearchService = New AmazonSearchService()
Dim productInfo As ProductInfo = amazonWS.KeywordSearchRequest(keywordReq)

The KeywordSearchRequest returns a ProductInfo object, which includes a Details property. This property is actually an array of Details objects representing the items that matched my search criteria. After first checking to make sure the Details property contains items, I add the Details array to the Items collection of the Listbox control on the form.

Visual C#

this.searchResults.Items.AddRange(productInfo.Details);

Visual Basic

Me.searchResults.Items.AddRange(productInfo.Details)

In order to correctly display the name of the item returned in my search, I used the cool new partial class feature of Visual Studio 2005 to extend the Details class that Visual C# created when I imported the WSDL file. To do this, I first created a new class file for the project and named it Details_2.cs. I included the new partial keyword in the class declaration and then added an override for the ToString method. The ToString method is inherited by every class from the .NET Framework's base Object class and is used by the Listbox control for displaying a value for listed items.

Visual C#

public override string ToString()
{
     return ProductName;
}

Visual Basic

Overrides Function ToString() As String
     Return ProductName
End FunctionFunction

This override uses the ProductName property of the Details object. This lets me display the product information in the list box.

I also added a new property to the partial class, called ItemImage. I used this property to return the image associated with a selected product item.

Visual C#

WebRequest webReq = WebRequest.Create(this.ImageUrlMedium);
WebResponse webResp = webReq.GetResponse();
_image = Image.FromStream(webResp.GetResponseStream());

Visual Basic

Dim webReq As WebRequest = WebRequest.Create(Me.ImageUrlMedium)
Dim webResp As WebResponse = webReq.GetResponse()
_image = Image.FromStream(webResp.GetResponseStream())

The code in the property's get method uses a System.Net.WebRequest object to return the image specified in the ImageUrlMedium property of the Details object. In the handler for the ListBox's SelectedIndexChanged event, I access this property to update the image displayed on the form.

Visual C#

this.itemPicture.Image = tempDetails.ItemImage;

Visual Basic

Me.itemPicture.Image = tempDetails.ItemImage

This completes the tour of this application. Download Visual C# 2005 Express Edition and explore this application for yourself. See http://msdn.microsoft.com/express.

If you're like me, you probably spend more time at Google than any other place on the Internet. It remains my first and usually best choice for Internet-based research. Did you know that Google also has a Web service? With the Google Web service, you can bring the power of the Google search engine to any .NET Framework-based application.

If you read my earlier post about the Amazon Web service, the following should be familiar to you. The Google Web service is free, and you can download their developer kit without being registered, but if you want to do anything meaningful you'll first need to register with Google. Google will email you a license key that lets you make up to 1,000 automated queries per day.

I doubt I'll ever have the need to make that many requests on any given day. Maybe you can think of a unique way to make use of all those requests. Google itself offers these suggestions for ways you can use their Web service.

• Auto-monitor the Web for new information on a subject
• Glean market research insights and trends over time
• Invent a catchy online game
• Create a novel UI for searching
• Add Google's spell-checking to an application

Since I use Google primarily for research, my goal for using the Google Web service was to build a simple desktop application for basic research. I wanted to emulate my typical use of Google on the Web: that is, have a form for inputting a query and executing a search, and places to list and show the results of my query.

For this example, we'll use one of the new Visual Studio 2005 Express Editions. The Express Editions of Visual Studio 2005 are simplified, streamlined and lightweight versions of Visual Studio tailored for hobbyist, novice, and student developers. Beta 2 of the Express editions can be downloaded at http://msdn.microsoft.com/express. Any of the Visual Studio 2005 Express Editions allow you to build applications which consume Web services; I'm using Visual C# 2005 Express Edition in this example.

Visual C# Express shares all of the great data access capabilities you'll also see in Visual Studio 2005. Working with the Google Web service API let me explore the Visual Studio Data Sources Window, which is a new tool window that displays objects in a project that you can use to create data bound forms. This includes data provided by Web services. With a Web service as a data source, it is virtually effortless to add data from the Web service to a form.

Now, usually all you should have to do to get to that place is add a Web reference to your project and Visual Studio takes care of discovering the data types. I expected that to be the case with the Google Web service. But instead I ran head first into a known problem. I should say it was not known to me when I first added a Web reference to the Google WSDL using the wizard in the Visual C# Express development environment. Nor was it known to me when I tried to figure out how to bind to data that was not appearing in the Data Sources Window accurately. The picture below illustrates what was wrong.

While the Web service appeared in the Data Sources Window and I could use it to query the service and get back a result, nothing I tried would let me display the data on a form. As you will see as I continue my story, the GoogleSearchResult type contains an array of ResultElements, and this is what I wanted to bind to on the form. But they didn't show up. After an hour (or two) of head scratching and then some old fashioned Google research, I found myself in the Visual Studio 2005 Beta 2 readme file. Under the Data Access section of the known issues, I found this item:

5.10.    Binding to Web services

Web services do not correctly display in the Data Sources Window for binding in Windows Applications.

To resolve this issue

Web service references are created with public fields instead of properties, and as a result do not yet work correctly at design time. As a work around, manually run the WSDL.exe tool to generate the correct web reference file. For more information, see the topic titled "How to: Run WSDL.exe to Prepare a Web Service to be used as a Data Source" in the Visual Studio help collection.

If you followed the link to the article you will note (perhaps with as much irony as I did) that the example Microsoft provides for correcting the problem is the Google API. At any rate this article had me back on track. The next picture shows what my Data Sources Window looked like after I added the manually generated Web reference file to my project.

Working in the Data Sources Window, you can view all the data types available from a Web service. This view represents what you'll see if you have a Windows form open in design mode. The icons next to each item in the tree represent the type of control you can create by dragging the element onto a form. You can change the control type using the drop-down arrow that appears when you select an item.

Anyway, the real beauty of this is that once you have your data ducks in a row you can begin building a data-bound user interface by dragging and dropping items from the Data Sources Window onto the form. Below is an early draft of my user interface. I built this in a matter of seconds by dragging items from the Data Sources Window onto the form. Visual Studio automatically created the necessary Data Connectors.

I ultimately decided to make this application have a browser-like look and feel. So in addition to a ToolStrip menu a status bar, I used a ListBox control at the top of my application to display the title of each search result. And then below that, I added a Web browser control to the form to display the associated Web page when a user selects an item from the list.

If you read through the documentation that comes with the Google developer kit, you'll find you have many different ways to submit a search query. You can apply language and country filters, for example, or search specific domains. You can also limit the search by date or file type. Basically, you have all the options available on the Google Advanced Search Web page. To experiment a bit with these possibilities, I added a ComboBox control to my application's ToolStrip to designate a language for a given search.

Behind the user interface elements, I leveraged the asynchronous processing capabilities of the Web service proxy class. The WSDL.exe tool automatically generates asynchronous versions of the Web methods it finds in the WSDL file. This lets you call a Web method on a separate thread to avoid locking up the application. Of course, you have other ways to boost performance. For example, I limited the number of results returned from the Google Web service to 10. But if I really want to make full use of the tool, asynchronous processing will help you to overcome performance bottlenecks.

To implement asynchronous processing, I added a BackgroundWorker component to the form and set up event handlers in the Form's constructor method.

backgroundWorker.DoWork +=new DoWorkEventHandler(backgroundWorker_DoWork);
backgroundWorker.ProgressChanged +=
    new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
backgroundWorker.RunWorkerCompleted +=
    new RunWorkerCompletedEventHandler(backgroundWorker_RunWorkerCompleted);

The code in my Search button's click event handler calls a helper method called StartSearch to begin the asynchronous Web service call using the BackgroundWorker. To pass the two user input values (the query text and the language selection) to the thread on which the BackgroundWorker runs, component executes the Web service call, I used a string array.

string[] searchCriteria = { this.queryText.Text, this._language };

And then passed the array as an argument to the RunWorkAsync method of the BackgroundWorker.

backgroundWorker.RunWorkerAsync(searchCriteria);

That invokes the method I delegated above called backgroundWorker_DoWork. This method executes on a separate thread. That's why I need to pass the values from the Windows form as input to this method (they aren't available to me from another thread). After first instantiating an instance of the Web service, the code reconstitutes the input argument (e.Argument) as a string array and then passes those values as parameters to the BeginGoogleSearch method of the Web service proxy class.

Google.GoogleSearchService googleWS = new Google.GoogleSearchService();
string[] searchCriteria = e.Argument as string[];
IAsyncResult asyncResult = googleWS.BegindoGoogleSearch(
  LicenseKey,
  searchCriteria[0], 0, 10, true,
  searchCriteria[1], true, "", "", "", null, null);

As I said before, BeginGoogleSearch is the first of the pair of asynchronous methods that the WSDL.exe tool created from the synchronous Web method. In the code that follows, I create WaitHandle that allows me to monitor the progress of the asynchronous Web service call. At intervals of 200 milliseconds I report the progress back to the main thread using the ReportProgress methods of the BackgroundWorker.

worker.ReportProgress(percentageComplete);

This causes the code in the delegate method for the ProgressChanged event to execute. In this case, the name of the delegate is backgroundWorker_ProgressChanged, which contains a single line of code to update the value of the ProgressBar control on the form.

this.progressBar.Value = e.ProgressPercentage;

When the asynchronous call completes, the code in BackgroundWorker's RunWorkerCompleted delegate method executes. This method is named backgroundWorker_RunWorker; it performs some basic error and cancellation checking and then, if all went well, it processes the results of the Web service call. In the first line of code below, the result is cast from the input argument into an instance of the GoogleSearchResult. The next line updates the DataSource property of the DataConnector to use the collection of ResultElements (this is what contains the results of the Google search) which are exposed as a property of the GoogleSearchResult object.

Google.GoogleSearchResult searchResponse = e.Result as Google.GoogleSearchResult;
resultElementDataConnector.DataSource = searchResponse.resultElements;

The DataSource for the ListBox is the DataConnector named resultElementDataConnector. The DisplayMember property of the ListBox is “title”, which maps to the title property of the ResultElement type, and the ValueMember property of the ListBox is set is similarly mapped to the “URL” property of the ResultElement.

Finally, the code in the handler for the ListBox's SelectedValueChanged event updates the Url property of the Web browser control, which causes the Web page associated with the search result to display on the form.

itemBrowser.Url = resultList.SelectedValue.ToString(); 

That completes the tour of this application. What started out for me as an exploration of how to leverage the Google search services in a Windows application became something of an odyssey. But it was a journey that had a happy conclusion and made me appreciate the powerful data binding capabilities of Visual Studio 2005 more deeply. I encourage you to download Visual C# Express and explore this application for yourself.