Create a new Windows application named "DefinePad."

Add a new class to the project. This will hold the actual WebRequest code. Call it GoogleClient.

Add a reference to the System.Web DLL, as you will need access to some of its functionality later.

In the GoogleClient.vb file, add Imports statements to make the coding a little briefer:

Imports System.IO
Imports System.Net
Imports System.Web
Imports System.Collections.Generic

The main function in GoogleClient will be a Define function that returns an array of strings. Each string will be one definition returned by Google:

Public Function Define(ByVal word As String) As String()
    Dim req As HttpWebRequest = Nothing
    Dim resp As HttpWebResponse
    Dim query As String
    Dim result As New List(Of String)

    query = "http://www.google.com/search?q=define%3A" & _
      HttpUtility.UrlEncode(word)

    Try
        req = DirectCast(WebRequest.Create(query), HttpWebRequest)
        With req
            .Method = "GET"
            resp = req.GetResponse
            If resp.StatusCode = HttpStatusCode.OK Then
                ParseResponse(resp.GetResponseStream, result)
            Else
                MessageBox.Show("Error calling definition service")
            End If
        End With
    Catch ex As Exception

    End Try

    Return result.ToArray()

End Function

The first task is to guarantee that no invalid characters appear in the query string when you send the request, such as a space, an accented character, or other non-ASCII characters. The System.Web.HttpUtility class has a number of handy shared methods for encoding strings, including the UrlEncode method. This replaces characters with a safe representation of the character that looks like %value, where the value is the Unicode code for the character. For example, in the definition of the query variable above, the %3A is actually the colon character (":"), which has been encoded. Any time you retrieve a URL based on user input, encode it because there is no guarantee the resulting URL is safe to send.

Once the query is ready, you create the WebRequest. As the URL is for an HTTP resource, an HttpWebRequest is created. While the default method for WebRequest is a GET, it's still good practice to set it. You'll create the ParseResponse method shortly to process the stream returned from the server.

One other piece of code worth mentioning is the return value for this method, and how it is created. In order to return arrays of a specific type (rather than return actual collections from a method), you must either know the actual size to initialize the array or use the List generic type or the older ArrayList. These classes behave like the Visual Basic 6.0 Collection class, which enables you to add items, and grows as needed. They also have a handy method that enables you to convert the array into an array of any type; you can see this in the return statement. The ArrayList requires you to do a bit more work. If you want to use an ArrayList for this method, then you must identify the type of array you'd like to return. The resulting return statement would look like this using an ArrayList:

Return result.ToArray(GetType(String))

The ProcessRequest method parses the stream returned from the server and converts it into an array of items. Note that this is slightly simplified; in a real application, you would likely want to return an array of objects, where each object provides access to the definition and the URL of the site providing it:

Private Sub ParseResponse (ByVal input As System.IO.Stream, _
  ByRef output As List(Of String))
        'definitions are in a block beginning with <p>Definitions for...
        'then are marked with <li> tags
        'yes, I should use Regular Expressions for this
        'this format will also likely change in the future.
        Dim reader As New StreamReader(input)
        Dim work As String = reader.ReadToEnd
        Dim blockStart As String = "<p>Definitions of"
        Dim pos As Integer = work.IndexOf(blockStart)
        Dim posEnd As Integer
        Dim temp As String

    Do
        pos = work.IndexOf("<li>", pos + 1)
        If pos > 0 Then
            posEnd = work.IndexOf("<br>", pos)
            temp = work.Substring(pos + 4, posEnd - pos - 4)
            output.Add(ParseDefinition(temp))
            pos = posEnd + 1
        End If
    Loop While pos > 0

End Sub

The code is fairly simple, using the time-honored tradition of screen scraping — processing the HTML of a page to find the section you need and then removing the HTML to produce the result.

The last part of the GoogleClient class is the ParseDefinition method that cleans up the definition, removing the link and other HTML tags:

Private Function ParseDefinition(ByVal input As String) As String
    Dim result As String = ""
        Dim lineBreak As Integer

        lineBreak = input.IndexOf("<br>")
        If lineBreak > 0 Then
            result = input.Substring(0, input.IndexOf("<br>"))
        Else

result = input
        End If
        Return result.Trim
End Function

Now, with the class in hand, you can create a client to use it. In this case, you'll create a simple text editor that adds the capability to retrieve definitions for words. Go back to the Form created for the application and add controls as shown in Figure 31-2.

Figure 31.2. Figure 31-2

The user interface for DefinePad is simple: a TextBox and a ContextMenuStrip.

The only code in the Form is for the Opening event of the ContextMenuStrip. Here, you add the definitions to the menu. Add the following code to the handler for the Opening event:

Private Sub DefinitionMenu_Opening(ByVal sender As Object, _
  ByVal e As System.ComponentModel.CancelEventArgs) _
  Handles DefinitionMenu.Opening
    Dim svc As New GoogleClient

Dim definitions() As String
    Dim definitionCount As Integer

    DefinitionMenu.Items.Clear()

    Try
        'define the currently selected word
        If TextField.SelectionLength > 0 Then
            definitions = svc.Define(TextField.SelectedText)

            'build context menu of returned definitions
            definitionCount = definitions.Length
            If definitionCount > 6 Then
                definitionCount = 6
            ElseIf definitionCount = 0 Then
                'we can't do any more, so exit
                Dim item As New ToolStripButton
                item.Text = "Sorry, no definitions available"
                DefinitionMenu.Items.Add(item)
                Exit Sub
            End If

            For i As Integer = 1 To definitionCount
                Dim item As New ToolStripButton
                item.Text = definitions(i)
                DefinitionMenu.Items.Add(item)
            Next
        End If

    Catch ex As Exception
        MessageBox.Show(ex.Message, "Error getting definitions", _
            MessageBoxButtons.OK, MessageBoxIcon.Error)

    End Try
End Sub

The bulk of the code in this event is to limit the number of items displayed in the menu. The actual functional part of the routine is the call to the Define method of the GoogleClient. If you trace through the code as you run, you'll see the WebRequest generated, the call made, and the resulting response stream parsed into the individual items as desired. Finally, you can use the returned list to create a set of menu items (that don't actually do anything), and display the "menu." Clicking on any definition closes the menu.

To test the application, run it. Type or copy some text into the text box, select a word, and right-click on it. After a brief pause, you should see the definitions for the word (Figure 31-3 shows definitions of "protocol").

Create a new Windows Service application called "MiniServer." The server won't do much on its own, but it will host an HttpListener.

From the Components section of the toolbox, add a BackgroundWorker component and call it BackgroundWork. The other properties can remain at their defaults. This BackgroundWorker will be used to process HTTP requests on a background thread, simplifying the handling of the threads.

Switch to Code view for the service. Add the Imports statements you need to the top of the file. In addition, add a reference to the System.Web DLL:

Imports System.Net
Imports System.IO
Imports System.Web
Imports System.Text

Add the private members to the class. In addition, add a constant to identify the port number the service will use for listening. Select a port that currently isn't in use. The example uses 9090:

Private listener As New HttpListener()
Private theService As String

Private Const PORT As Integer = 9090

In the OnStart method, set up the list of prefixes to which the server will respond. This can be as simple as adding a port address to the URL, or it can include specific vroots. The sample provides examples of each:

Protected Overrides Sub OnStart(ByVal args() As String)
    Dim machineName As String

    machineName = System.Environment.MachineName
    theService = HttpUtility.UrlEncode(Me.ServiceName)

    Me.EventLog.WriteEntry("Service Name: " & Me.ServiceName)

    With listener
        .Prefixes.Add(String.Format("http://{0}:{1}/", _
          "localhost", PORT.ToString))
        .Prefixes.Add(String.Format("http://{0}:{1}/", _
          machineName, PORT.ToString))
        .Prefixes.Add(String.Format("http://{0}/{1}/", _
          "localhost", theService))
        .Prefixes.Add(String.Format("http://{0}/{1}/", _
          machineName, theService))
        .Start()
    End With
    'start up the background thread
    Me.BackgroundWork.RunWorkerAsync()

End Sub

In this case, the server will respond to a prefix in any of the formats (the sample computer is called Tantalus):

http://localhost:9090/
http://tantalus:9090/
http://localhost/sampleservice/
http://tantalus/sampleservice/

If you already have a web server listening on port 80, such as IIS, then you shouldn't include the last two prefixes. As only a single application can listen to each port, this service will not be able to start if the other service is already monitoring port 80.

After initializing the Prefixes collection, calling the Start method binds the listener to the appropriate ports and vroots and starts it accepting requests. However, we don't want to actually receive the requests in the OnStart handler. Remember that the service doesn't actually start until after this method has completed, so having a lot of processing in the OnStart will actually prevent the service from completing. Therefore, we use another feature of Visual Basic 2008, the BackgroundWorker component, to handle the requests. Call its RunWorkerAsync to start the background task (in our case, the HttpListener).

The OnStop method serves to shut down the HttpListener:

Protected Overrides Sub OnStop()
    With listener
        .Stop()
        .Close()
    End With
End Sub

The background task performed by the BackgroundWorker component can be any process that you don't want to interfere with the normal application's processing. If this were a Windows Forms application, having a long-running loop or other process running might prevent the application from drawing, or responding to, the user's requests. Beyond that, we can do anything we want in the background task, with one exception: because a Windows Forms application works in a single foreground task, one can't directly access the controls on the form from the background task. Instead, if the background task must change properties on the controls, then it should fire events. The controls can then subscribe to those events, where you can access the properties. This Windows Service has no such user interface, so that problem is avoided.

The actual work you want the BackgroundWorker to perform is in the DoWork event handler:

Private Sub BackgroundWork_DoWork(ByVal sender As System.Object, _
  ByVal e As System.ComponentModel.DoWorkEventArgs) Handles
BackgroundWork.DoWork
    Dim context As HttpListenerContext
    Dim path As String
    Dim defaultPage As String

    'this is where we actually process requests
    While listener.IsListening
        context = listener.GetContext
        path = context.Request.Url.AbsolutePath.ToLower

        'strip out the serviceName if you're using the URL format:
        'http://server/servicename/path
        If path.StartsWith("/" & theService.ToLower) Then
            path = path.Substring(theService.Length + 1)
        End If
        Me.EventLog.WriteEntry("Received request for " & path)


        Select Case path
            Case "/"
                'this would probably be a resource
                defaultPage = "Available pages<ul>" & _
                    "<li><a href='/time'>Current server time</a></li>" & _
                    "<li><a href='/date'>Current date</a></li>" & _
                    "<li><a href='/random'>Random number</a></li></ul>"
                SendPage(context.Response, defaultPage)
            Case "/time"
                SendPage(context.Response, DateTime.Now.ToLongTimeString)
            Case "/date"
                SendPage(context.Response, DateTime.Now.ToLongDateString)

Case "/random"
                SendPage(context.Response, New Random().Next.ToString)
            Case Else
                'if we don't understand the request, send a 404
                context.Response.StatusCode = 404
        End Select

    End While
End Sub

The background task performs its work in a loop as long as the HttpListener is actively listening. Every developer knows that performing a set of tasks in a (relatively) tight loop is dangerous, possibly leading to computer or application lockup. However, the BackgroundWorker performs this on another thread, leaving our application responsive.

For this application, we first get access to the context for the listener. The context groups together one client's set of communication with our listener. Similar to the HttpContext in ASP.NET, the HttpListenerContext provides access to the HttpListenerRequest and HttpListenerResponse objects, so the first step in handling a request should always be to get this context. Next, the code uses a very simple means of determining the request URL. In a more full-featured implementation, this could be more complex, separating any query values from the path requested, etc. For this sample, the listener only responds to three main paths, '/time', '/date', and '/random', to receive the current (server) time or date, or a random Integer value. If the user requests anything else, then we return a 404.

The SendPage subroutine simply writes out a basic HTML page and the value determined:

Private Sub SendPage(ByVal response As HttpListenerResponse, _
  ByVal message As String)
    Dim sb As New StringBuilder

    'build string
    With sb
        .Append("<html><body>")
        .AppendFormat("<h3>{0}</h3>", message)
        .Append("</body></html>")
    End With

    Me.EventLog.WriteEntry(sb.ToString)

    'set up content headers
    With response
        .ContentType = "text/html"
        .ContentEncoding = Encoding.UTF8
        .ContentLength64 = sb.ToString.Length
        Me.EventLog.WriteEntry(sb.ToString.Length.ToString)

        Try
            Using writer As New StreamWriter(.OutputStream)
                With writer
                    .Write(sb.ToString)
                    .Flush()
                End With
            End Using

Catch ex As Exception
            Me.EventLog.WriteEntry(ex.Message, EventLogEntryType.Error)
        Finally
            'close the response to end
            .Close()
        End Try
    End With
End Sub

It is hoped that there aren't any surprises in this code. Using a StringBuilder, a response is built. Then the content is written back to the browser (see Figure 31-8) using a StreamWriter that is created on top of the Response.OutputStream. Remember to close the Response, or the request will never close until it times out.

Figure 31.8. Figure 31-8

Before you can test your Windows Service, however, it must be installed. Right-click on the designer and select Add Installer (see Figure 31-9). This adds a new file to the project called ProjectInstaller.vb, and adds two components to the file: ServiceInstaller1 and ServiceProcessInstaller1. You can either keep these names or change them. In addition, set the properties as shown in the following table:

Most of these properties only affect the display values for the Windows Service. However, the Account property of the ServiceProcessInstaller deserves special mention. Windows Services run on behalf of the user. Therefore, they can actually run under another user account. By setting the Account property to LocalSystem, you are setting the resulting Windows Service to run under the local system account. This account has a lot of access to the system, so you may want to instead use an account with more limited system rights; however, you would have to create this account separately.

Figure 31.9. Figure 31-9

Build the Windows service. Unfortunately, if you attempt to run the service directly from Visual Basic, you will get an error message (see Figure 31-10).

Figure 31.10. Figure 31-10

A Windows Service can only run if it has been installed into the system, and this task is performed using a command-line utility, InstallUtil.exe. Open the Visual Studio command prompt and navigate to the directory where you have built MiniServer.exe. Run installutil miniserver.exe. It is hoped that you'll be greeted with a success message (see Figure 31-11).

Figure 31.11. Figure 31-11

Finally, you can start your new service. Open the Services application from Start

Figure 31.12. Figure 31-12

Figure 31.13. Figure 31-13

Just to confirm that all of the prefixes work, you can also request one of the values using the vroot, rather than using the port (see Figure 31-14).

Figure 31.14. Figure 31-14

The HttpListener adds yet another powerful way for your applications to communicate. It gives you the ability to extend the reach of your applications out to Web browser clients, without requiring the additional administrative and management overhead of IIS to your deployment.