Getting Weather Data from the Web

Aside from the aforementioned private members, the WeatherInfo class also contains several private methods. One such method, called _getWebWeather(), gets the weather feed from the remote host and returns a string containing the feed's contents:

private string _getWebWeather()
{
    string xmlStr = String.Empty;
    return xmlStr;
}

According to the SDK, the URL to retrieve the weather feed looks like the following:

http://xoap.weather.com/weather/local/[locID]?cc=*&prod=xoap&par=[partID]&key=[lic]

The information contained in brackets is the location ID, partner ID, and license key. Using the String.Format() method, you can format the URL to contain your own settings information:

string baseUrl =
    "http://xoap.weather.com/weather/local/{0}?cc=*&prod=xoap&par={1}&key={2}";

string url = String.Format(baseUrl, _settings.LocationId, _settings.PartnerId,
    _settings.LicenseKey);

This is primarily where the _settings object is used. The resulting string returned from String.Format() is complete with the required information that the Weather.com guidelines dictate.

The next operation in _getWebWeather() makes a request to the remote host and retrieves the weather feed:

using (WebClient client = new WebClient())
{
    //Read the results
    try
    {
        using (StreamReader reader = new StreamReader(client.OpenRead(url)))
        {
            xmlStr = reader.ReadToEnd();
        }
    }
    catch (WebException exception)
    {
        xmlStr = _writeErrorDoc(exception);
    }
}

At the beginning of this code, a WebClient object is created. If you'll remember from Chapter 5, you used an HttpWebRequest object to retrieve data from the remote host. You could do the same for this widget, but as you can see from the previous code, WebClient uses a much simpler interface.

To read the remote server's response, use the OpenRead() method. This method returns a Stream object that you can read with a StreamReader class. The StreamReader class's ReadToEnd() method reads the stream and returns it as a string to xmlStr. If for some reason this operation fails (most likely as a result of not finding the remote host), an error document is created by the _writeErrorDoc()and used in place of the weather feed.

At this point in the method, you have some XML data to use: the weather feed or the error document. The next few processes in the method perform an XSL transformation on the XML data. Transforming the data at the server is advantageous for several reasons. For one, it greatly simplifies the client-side code. The data sent to the client is already in HTML, so it is easily added to the page. A server-side transformation also makes the client work less. The data is complete when it reaches the client; no other data manipulation, other than placing in the page, is required.

XSL transformations in .NET closely resemble the transformations provided by MSXML covered in Chapter 4. The first step in a transformation is to create the objects involved:

XslTransform xslt = new XslTransform();
XmlDocument xml = new XmlDocument();
using (StringWriter stringWriter = new StringWriter()) {

Transformations in .NET include an XslTransform object, an XmlDocument object, and a StringWriter object, which contains the resulting transformed data. The next step in the transformation process is to load the XML data into the XmlDocument object and the XSL document into the XslTransform object:

xml.LoadXml(xmlStr);
xslt.Load(_path + "/weather.xslt");

The LoadXml() method of the XmlDocument class resembles the loadXML() method in the MSXML library. It accepts a string argument representing the XML data. The XSL document is loaded into the XslTransform object via the Load() method. This method takes one argument: a string containing the path to the XSL document.

The final step is to perform the transformation and retrieve the resulting data from the StringWriter:

xslt.Transform(xml, null, stringWriter, null);
xmlStr = stringWriter.ToString();

The Transform() method has several overloads. Overloaded methods are methods of the same name that perform the same function, but which accept different arguments. This particular overload accepts the XML document in the first position, an argument list (or parameter list) to pass to the XSLT processor in the second position, the StringWriter to serve as output in the third position, and an XmlResolver to handle any XML namespaces in the last position. Once the transformation is complete, you can use the ToString() method to obtain the transformed data from the StringWriter.

The final step in _getWebWeather() is to cache the data. This is done with a StreamWriter, which writes the data in UTF-8 encoding:

using (StreamWriter writer = new StreamWriter(_cachedFile))
{
    writer.Write(xmlStr);
}

The StreamWriter class constructor accepts a string argument containing the path to the file to write to. The StreamWriter writes the contents of xmlStr to the file and is promptly closed and disposed of when the using block exits.

The completed code of _getWebWeather() is as follows:

private string _getWebWeather()
{
    //Just to keep things clean, an unformatted URL:
    string baseUrl =
        "http://xoap.weather.com/weather/local/{0}?cc=*&prod=xoap&par={1}&key={2}";

    //Now format the url with the needed information
    string url = String.Format(baseUrl, _settings.LocationId, _settings.PartnerId,
            _settings.LicenseKey);

    //String that the weather feed will be written to
    string xmlStr = String.Empty;

    //Use a web client. It's less coding than an HttpWebRequest.
    using (WebClient client = new WebClient())
    {
        //Read the results
        try
        {
            using (StreamReader reader = new StreamReader(client.OpenRead(url)))
            {
                xmlStr = reader.ReadToEnd();
            }
        }
        catch (WebException exception)
        {
            xmlStr = _writeErrorDoc(exception);
        }
    }

    XslTransform xslt = new XslTransform();
    XmlDocument xml = new XmlDocument();

    using (StringWriter sringWriter = new StringWriter())
    {
        xml.LoadXml(xmlStr);
        xslt.Load(_path + "/weather.xslt");
        xslt.Transform(xml,null,sringWriter,null);
        xmlStr = sringWriter.ToString();
    }

    //Write the cached file
    using (StreamWriter writer = new StreamWriter(_cachedFile))
    {
        writer.Write(xmlStr);
    }

    //Finally, return the feed data.
    return xmlStr;
}

Reading Cached Weather Data

Another private method of the WeatherInfo class is the _getCachedWeather() method. As its name suggests, its function is to retrieve the data from the cached feed. Like the previously discussed method, _getCachedWeather() also returns a string:

private string _getCachedWeather()
{
    string str = String.Empty;

    //Open and read the cached weather feed.
    using (StreamReader reader = new StreamReader(_cachedFile))
    {
        str = reader.ReadToEnd();
    }

    //Return the contents
    return str;
}

First, the variable str is created and initialized as an empty string; this variable will contain the contents of the cached file when it is read. Next, a StreamReader object is created and opens the cached weather feed, the contents of which are read via the ReadToEnd() method and stored in str. Finally, _getCachedWeather() exits and returns the str value.

The _getWebWeather() and _getCachedWeather() methods are the primary workhorses of the application. However, as you've probably already noted, they're private members. In other words, there is no way to access them externally when you create an instance of this class. A public method, GetWeather(), provides makeshift access to these private methods.

Writing the Error Document

One final method of the WeatherInfo class need mentioning: _writeErrorDoc(). As stated before, this method writes a simple error document in XML to be used in the event the remote host cannot be contacted. It accepts one argument, a WebException instance:

private string _writeErrorDoc(WebException exception)
{
    XmlDocument xml = new XmlDocument();
    xml.LoadXml("<errorDoc />");

    XmlElement alertElement = xml.CreateElement("alert");
    alertElement.InnerText = "An Error Occurred!";

    XmlElement messageElement = xml.CreateElement("message");
    messageElement.InnerText = exception.Message;

    xml.DocumentElement.AppendChild(alertElement);
    xml.DocumentElement.AppendChild(messageElement);

    return xml.OuterXml;
}

In the first two lines of code, an XmlDocument object is created and loaded with a simple XML document (only the root element). The error document contains only two elements: <alert/> and <message/>. The DOM methods in .NET resemble the DOM methods in Internet Explorer and Firefox. The first element, <alert/>, is created with the CreateElement() method. Using the InnerText property, it receives its text node. The same procedure is used to create the <message/> element. This element will house the message from the WebException object.

When all elements are created and populated with their needed data, they are appended to the document via the AppendChild() method, and the serialized XML data, output by the OuterXml property, is returned.

To finish off the class, two accessors grant access to the _settings and _cachedFile private members:

public Settings Settings
{
    get
    {
        return _settings;
    }
}

public string CachedFile
{
    get
    {
        return _cachedFile;
    }
}

This will ensure that you can access this data outside of the class, as necessary.