Example 2. Calling HTTP Web Services From C#

The listing below shows an example of invoking a web serivce over HTTP from within a C# program. Note that the GetResponse() method has been written to be generic and can be used to access any of the NetworkedPlanet web service operations. A complete working program based on this example code can be found in the examples/CS directory of your installation.

private void ProcessRequest(string serviceApplicationUrl, string topicmapName, string searchString)
{
  // First construct the URL. We start with the path to the application
  // directory provided by the user. Expand this by adding the operation
  // ASPX page address (with a slash separator if needed).
  string requestUrl = serviceApplicationUrl;
  if (!requestUrl.EndsWith("/")) 
  {
    requestUrl += "/";
  }
  requestUrl += "GetTopicsByName.aspx";

  Hashtable parameters = new Hashtable();
  parameters["topicmap"] = topicmapName;
  parameters["name"] = searchString;

  XmlDocument responseDoc = new XmlDocument();

  try 
  {
    HttpStatusCode statusCode = GetResponse(requestUrl, parameters, responseDoc);
    if (statusCode == HttpStatusCode.OK) 
    {
      System.Console.WriteLine("Search request was processed successfully. Results follow.");
    } 
    else 
    {
      System.Console.WriteLine("Search request failed: " + statusCode.ToString() + ". Details follow.");
    }
    XmlTextWriter writer = new XmlTextWriter(System.Console.Out);
    writer.Formatting = Formatting.Indented;
    responseDoc.WriteTo(writer);
  } 
  catch (System.Net.WebException webex) 
  {
    System.Console.Error.WriteLine("Error encountered in sending request. Please check the service application URL and try again.");
    System.Console.Error.WriteLine("  Error detail: " + webex.Message);
  }
}

/// <summary>
/// Attempts to contact a NetworkedPlanet webservice, passing in the specified parameters.
/// </summary>
/// <param name="requestUrl">The URL of the service to contact</param>
/// <param name="parameters">The parameters to pass to the service.</param>
/// <param name="responseDoc">The response XML received from the web service</param>
/// <returns>The HTTP status code of the response</returns>
/// <exception cref="System.Net.WebException">Raised if the service could not be reached.</exception>
/// <remarks>The <c>parameters</c> hashtable must use string keys and the value for each key must be either
/// a string or an IList of string.</remarks>
private HttpStatusCode GetResponse(string requestUrl, Hashtable parameters, XmlDocument responseDoc)
{
  // Construct the request XML
  XmlDocument requestDoc = new XmlDocument();
  XmlElement requestEl = requestDoc.CreateElement("request");
  requestDoc.AppendChild(requestEl);
  // Parameters should be either strings or lists of strings
  foreach(string key in parameters.Keys) 
  {
    if (parameters[key] is string) 
    {
      XmlElement param = requestDoc.CreateElement("param");
      param.SetAttribute("name", key);
      param.InnerXml = parameters[key] as string;
      requestEl.AppendChild(param);
    } 
    else if (parameters[key] is IList)
    {
      // If the parameter is a list of strings, write a separate
      // param element for each item in the list.
      foreach(string item in (parameters[key] as IList)) 
      {
        XmlElement param = requestDoc.CreateElement("param");
        param.SetAttribute("name", "key");
        param.InnerXml = item;
        requestEl.AppendChild(param);
      }
    }
  }

  // Perform an ASCII encoding of the request xml
  ASCIIEncoding encoding = new ASCIIEncoding();
  byte[] encodedBody = encoding.GetBytes(requestDoc.OuterXml);

  // Construct the request object
  HttpWebRequest webRequest = HttpWebRequest.Create(requestUrl) as HttpWebRequest;
  webRequest.ContentType = "text/xml";
  webRequest.ContentLength = encodedBody.Length;
  webRequest.Method = "POST";
  Stream bodyStream = webRequest.GetRequestStream();
  bodyStream.Write(encodedBody, 0, encodedBody.Length);
  bodyStream.Close();

  HttpWebResponse webResponse = null;
  try 
  {
    webResponse = webRequest.GetResponse() as HttpWebResponse;
  } 
  catch (System.Net.WebException webEx)
  {
    webResponse = webEx.Response as HttpWebResponse;
  }
  // NOTE: this will throw an exception out to the caller if the
  // response is not an XML document.
  responseDoc.Load(webResponse.GetResponseStream());
  return webResponse.StatusCode;
}

Example 3. Calling HTTP Web Services From VB.NET

    ' Contains the logic for issuing a search request and processing
    ' the results.
    Sub DoRequest(ByVal serviceUrl As String, ByVal topicmapName As String, ByVal searchString As String)
        Dim requestUrl As String
        requestUrl = serviceUrl
        If Not (requestUrl.EndsWith("/")) Then
            requestUrl = requestUrl + "/"
        End If
        requestUrl = requestUrl + "GetTopicsByName.aspx"
        System.Console.WriteLine(requestUrl)
        Dim params As New Hashtable
        params("topicmap") = topicmapName
        params("name") = searchString

        Dim responseDoc As New Xml.XmlDocument
        Dim responseCode As HttpStatusCode
        Try
            responseCode = GetResponse(requestUrl, params, responseDoc)
            If (responseCode.Equals(HttpStatusCode.OK)) Then
                System.Console.WriteLine("Search process successfully. Results follow:")
            Else
                System.Console.WriteLine("Search request failed. Error details follow:")
            End If
            Dim writer As XmlTextWriter
            writer = New XmlTextWriter(System.Console.Out)
            writer.Formatting = Formatting.Indented
        responseDoc.WriteTo(writer)
        Catch ex As WebException
            System.Console.Error.WriteLine("Error processing request: " + ex.Message)
            System.Console.Error.WriteLine("  Please check the service URL and try again.")
        End Try
    End Sub

    ' Performs the "heavy lifing" of the application. This function posts 
    ' a set of parameters (defined in the params Hashtable) to the
    ' URL specified by requestUrl and parses the response into
    ' responseDoc. Because all of the NetworkedPlanet web service
    ' operations use the same request format, this method can
    ' be reused to invoke any of the operations we support.
    ' The keys in the params Hashtable must be strings and the
    ' values must be either strings or ILists of strings.
    Function GetResponse(ByVal requestUrl As String, ByVal params As Hashtable, ByVal responseDoc As XmlDocument) As HttpStatusCode

        Dim requestDoc As XmlDocument
        Dim requestEl As XmlElement
        Dim paramEl As XmlElement
        Dim key As String
        requestDoc = New XmlDocument
        requestEl = requestDoc.CreateElement("request")
        requestDoc.AppendChild(requestEl)
        For Each key In params.Keys
            If (TypeOf params(key) Is IList) Then
                ' Extract each item in the list in turn add add
                ' a separate param element for it
                Dim paramValue As String
                For Each paramValue In params(key)
                    paramEl = requestDoc.CreateElement("param")
                    paramEl.SetAttribute("name", key)
                    paramEl.InnerXml = paramValue
                    requestEl.AppendChild(paramEl)
                Next
            Else
                ' Create a single param element for the item value
                paramEl = requestDoc.CreateElement("param")
                paramEl.SetAttribute("name", key)
                paramEl.InnerXml = params(key)
                requestEl.AppendChild(paramEl)
            End If
        Next
        System.Console.WriteLine(requestDoc.OuterXml)

        Dim encodedBody As Byte()
        Dim asciiEncoding As New ASCIIEncoding
        encodedBody = asciiEncoding.GetBytes(requestDoc.OuterXml)

        Dim httpRequest As HttpWebRequest
        httpRequest = HttpWebRequest.Create(requestUrl)
        httpRequest.Method = "POST"
        httpRequest.ContentLength = encodedBody.Length
        httpRequest.ContentType = "text/xml"
        Dim requestStream As Stream
        requestStream = httpRequest.GetRequestStream()
        requestStream.Write(encodedBody, 0, encodedBody.Length)
        requestStream.Close()

        Dim httpResponse As HttpWebResponse
        Try
            httpResponse = httpRequest.GetResponse()
        Catch ex As WebException
            httpResponse = ex.Response
        End Try

        If httpResponse.ContentType = "text/xml" Then
            Dim reader As New XmlTextReader(httpResponse.GetResponseStream())
            responseDoc.Load(reader)
        Else
            ' We shouldn't get non XML content return from NetworkedPlanet
            ' requests, but this handles the case that the server returns s
            ' some default error page (e.g. if access is denied) by embedding
            ' the response text inside a wrapper element
            responseDoc.AppendChild(responseDoc.CreateElement("NonXmlResponse"))
            Dim rdr As New StreamReader(httpResponse.GetResponseStream())
            responseDoc.InnerText = rdr.ReadToEnd()
            rdr.Close()
        End If
        Return httpResponse.StatusCode

    End Function

Example 4. Calling HTTP Web Services From Javascript

The following example shows the use of the XmlHttpRequest object provided by some browsers. There are a number of cross-browser libraries that help you avoid browser issues in using Javascript.

 /**
  * Construct and post the request and handle the response
  */
function DoSearch()
{
  // Assumes that our page has three text fields for providing the request parameters
  oServiceUrl = document.getElementById("serviceUrl")
  oTopicmap = document.getElementById("topicmap")
  oSearchString = document.getElementById("searchString")
  // A placeholder element on our page for progress / result messages
  oMessage = document.getElementById("message");
  szRequestUrl = oServiceUrl.value
  if (szRequestUrl.charAt(szRequestUrl.length - 1) != "/") {
    szRequestUrl = szRequestUrl + "/"
  }
  szRequestUrl = szRequestUrl + "GetTopicsByName.aspx"
  szRequestBody = "<request><param name='topicmap'>" + oTopicmap.value + 
    "</param><param name='name'>" + oSearchString.value + "</param></request>"
  oMessage.innerText = "Sending request. Please wait...";
  oMessage.className = "pending";
  DoPost(szRequestUrl, szRequestBody);
}

/**
 * Posts the specified content to the specified URL using 
 * the global asynchronous request object 'req'. When the
 * request status changes, the ProcessRequestChange function
 * will be invoked
 */
function DoPost(url, content)
{
  if (window.XMLHttpRequest) {
    req = new XMLHttpRequest();
    req.onreadystatechange = ProcessRequestChange;
    req.open("POST", url, true);
    req.send(content);
  } else if (window.ActiveXObject) {
    req = new ActiveXObject("Microsoft.XMLHTTP");
    if (req) {
      req.onreadystatechange = ProcessRequestChange;
      req.open("POST", url, true);
      req.send(content);
    }
  }
}

function ProcessRequestChange()
{
  if (req.readyState == 4) {
    if (req.status == 200) {
      // Handle successful response.
      // Response XML can be found in req.responseXML
    } else {
      // Handle error reponse.
      // Error XML document can be found in req.responseXML
    }
  }
}