One of my most used filters in both ImagerGallery and BeaverShop is one I named PagingAttribute which I thought I should show to you today.

Any ActionFilter need to inherit the ActionFilterAttribute and implement at least one of the following methods: OnActionExecuting, OnActionExecuted, OnResultExecuting or OnResultExecuted. They are all called during different stages of the execution of an action-method and can be used for various things. The one I’ll be using is OnActionExecuting since it is executed before the action so that I can pass extra arguments to the action.

The code is quite easy to understand. There is only one property to be set (except for the default property Order which is defined in ActionFilterAttribute) which is which field to be parsed. I check if the field is null or empty, if not ten I use a regular expression to see check if the selected field ends with “page” and a numerical value. The numerical value is then returned as a argument for the action called “pageNo”. This value is defaulted to 1 to make sure that we always get a number for our page (and not specifying anything should mean the first page). In my case I also want the field to be modified so it doesn’t contain the “page” part but that might not be suitable for everyone. If not, then you can easily remove that part by commenting the line looking like this: filterContext.ActionParameters[Field] = id;

using System;
using System.Text.RegularExpressions;
using System.Web;
using System.Web.Mvc;

namespace BeaverShopMvc.Attributes
{
    /// <summary>
    /// An ActionFilter to parse a page number from a field value
    /// </summary>
    public class PagingAttribute : ActionFilterAttribute
    {
        /// <summary>
        /// The name of the field to parse
        /// </summary>
        public string Field { get; set; }

        // A compiled regular expression to speed things up
        private static Regex _pageRegex = new Regex("page(?<PageNo>\\d+)$", RegexOptions.CultureInvariant | RegexOptions.Compiled);

        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            string id = filterContext.ActionParameters[Field] as string;
            Int32 pageNo = 1;

            // We never need an ending / so remove it
            id = id.TrimEnd('/');

            // Check so that the field isn't empty and while at it also that it
            // contains "page"
            if (!string.IsNullOrEmpty(id) && id.ToLowerInvariant().Contains("page"))
            {
                Match match = _pageRegex.Match(id);
                if (match.Success)
                {
                    pageNo = Convert.ToInt32(match.Groups["PageNo"].Value);
                    if (id.Contains("/"))
                        id = id.Substring(0, id.LastIndexOf('/'));
                    else
                        id = string.Empty;
                }
            }

            filterContext.ActionParameters["pageNo"] = pageNo;
            // The line below replaces the old field value with a
            // new one without the "page" part
            filterContext.ActionParameters[Field] = id;

            base.OnActionExecuting(filterContext);
        }
    }
}

Using the attribute is really simple and the great thing about this is that it is easily reusable on any actions you need it to. Below is a little sample of it in action.

        [Paging(Field = "id")]
        public ActionResult ListProducts(string id, Int32 pageNo)
        {
            return View();
        }

I have a few more filters that I really like as well (AkismetValidatorAttribute for example) that I might share some other day. I’m still learning a lot about working with MVC and will keep you posted with what other interesting things I can find.

/// <summary>
///  Datatypes used by the EXIF specification
/// </summary>
public enum ExifDataTypes
{
	UnsignedByte = 1,
	AsciiString = 2,
	UnsignedShort = 3,
	UnsignedLong = 4,
	UnsignedRational = 5,
	SignedByte = 6,
	Undefined = 7,
	SignedShort = 8,
	SignedLong = 9,
	SignedRational = 10,
	SingleFloat = 11,
	DoubleFloat = 12
}

What useful comments could added to this? When compiling I’m getting twelve warnings about this code not being documented though I do have a hard time finding out what I should write about each option since I feel that the names are quite self explanatory. Just adding a dummy comment to each line would get rid of the warnings but also clutter up my code which isn’t really helping me. I could also tell the compiler to ignore all warnings of this type (“/nowarn 1591″ when compiling) though there might be other places in my code where I want to know that I missed a comment.

So no luck just yet. There is however a third method to use. Going back to C there has been a way to communicate with the compiler from your code using directives called “pragmas”. C# have it as well though the standard compiler (csc.exe) only understands two commands, warning and checksum. For my problem, warning was the one I could use.

The code below has a pragma added that tells the compiler not to raise warnings with id 1591 (missing comments) from line 6 to line 19.

/// <summary>
///  Datatypes used by the EXIF specification
/// </summary>
public enum ExifDataTypes
{
#pragma warning disable 1591
	UnsignedByte = 1,
	AsciiString = 2,
	UnsignedShort = 3,
	UnsignedLong = 4,
	UnsignedRational = 5,
	SignedByte = 6,
	Undefined = 7,
	SignedShort = 8,
	SignedLong = 9,
	SignedRational = 10,
	SingleFloat = 11,
	DoubleFloat = 12
#pragma warning restore 1591
}

It still gives me lots of warnings (still have some huge enums for the EXIF class that needs this) but now I have a chance of finding the real warnings and still document the parts of my code that really needs documenting.

First of all I just want to state that I’m not a believer in all the SEO crap thats out there. I simply believe that if you have a great site that people visit and link to it will rank higher in search engines. A great site though will incorporate lots of things that “SEO experts” are chattering about like validating markup, good titles and things like that but that doesn’t mean it is those parts that put it high in the searchresults.

When working on a new version the CMS I use for CrazyBeaver Softwares website I ran into a really disturbing problem with how ASP.Net handles metadata. Look at the sample below.

<head runat="server">
    <title>My website</title>
    <meta name="keywords" content="" />
</head>

It looks alright doesn’t it? Well if you browse to that page you’ll see that the generated source is different.

<head>
    <title>My website</title>
    <meta name="keywords" />
</head>

Where did my content go? Just because it is empty doesn’t mean it can be removed just like that. If you pay a quick visit to www.w3.org and look at the xhtml specification you’ll see that the content attribute is a REQUIRED attribute of the meta element and therefore shouldn’t be removed. Now I hear you say that it shouldn’t matter since it didn’t convey any information anyway and while that is true the removal of that attribute also made sure that the page won’t generate valid html. Sure, it’s a very small error and won’t stop anything that doesn’t require a strict DTD validation to display the page (and no browsers do that since they wouldn’t be able to browse large parts of the web) but start out small and soon you won’t even bother to close tags properly since the page doesn’t validate anyway.

So, this is a behavior of ASP.Net that we need to work around somehow. There are a few choices here. You could simply loop through the HtmlMeta controls during Page_Load and check if they have empty content. It would look something like this.

protected void Page_Load(object sender, EventArgs e)
{
    if (!Page.IsPostBack)
    {
        Control[] headerControls = new Control[Page.Header.Controls.Count];
        Page.Header.Controls.CopyTo(headerControls, 0);

        foreach (Control control in headerControls)
        {
            HtmlMeta meta = control as HtmlMeta;

            if (meta == null)
                continue;

            if (string.IsNullOrEmpty(meta.Content))
            {
                Page.Header.Controls.Remove(control);
                break;
            }
        }
    }
}

Does this look as a good enough solution for you? It will do the work needed for most parts (it won’t remove a completely empty meta for some reason though so a <meta name=”" content=”" />will still fail your validation..) but it isn’t the nicest solution since you’ll need to loop through all controls in your header for every pageview that isn’t a postback. Also, maybe you want to specify an empty content for some reason since you have some other piece of code or application that relies on them being there. So what would be a nicer solution? Well writing an adapter of course! In ASP.Net 2.0 they introduced a cool thing called control adapters which basicly let you override the rendering of an existing webcontrol. In this case we will use it to force the HtmlMeta control to always render a content attribute.

using System.Web.UI;
using System.Web.UI.Adapters;
using System.Web.UI.HtmlControls;

namespace CrazyBeavers.Web.UI.Adapters
{
    public class HtmlMetaAdapter : ControlAdapter
    {
        private static string[] _i8nAttributes = new string[] { "lang", "xml:lang", "dir" };

        protected override void Render(HtmlTextWriter writer)
        {
            HtmlMeta meta = this.Control as HtmlMeta;

            writer.WriteBeginTag("meta");

            if (!string.IsNullOrEmpty(meta.HttpEquiv))
                writer.WriteAttribute("http-equiv", meta.HttpEquiv);

            if (!string.IsNullOrEmpty(meta.Scheme))
                writer.WriteAttribute("scheme", meta.Scheme);

            if (!string.IsNullOrEmpty(meta.Name))
                writer.WriteAttribute("name", meta.Name);

            foreach (string attr in meta.Attributes.Keys)
                foreach (string i18n in _i8nAttributes)
                    if (attr.Equals(i18n, System.StringComparison.InvariantCultureIgnoreCase))
                        writer.WriteAttribute(i18n, meta.Attributes[i18n]);

            writer.WriteAttribute("content", meta.Content);

            writer.Write(HtmlTextWriter.SelfClosingTagEnd);
        }
    }
}

Just drop that piece of code in your App_Code or compile it as an assembly and put it in the Bin-folder on your site. There is still one step that needs to be completed for this to work though. All control adapters needs to be referenced via an browser-file in App_Browsers aswell (which is a really cool thing since you can set conditions and use adapters on certain controls for certain browsers, but more on that some other time). Below is a short sample of my Default.browser-file, it doesn’t use any extra features of the browser-file and just say that I want to use my adapter everywhere.

<browsers>
  <browser refID="Default">
    <controladapters>
      <adapter controlType="System.Web.UI.HtmlControls.HtmlMeta"
               adapterType="CrazyBeavers.Web.UI.Adapters.HtmlMetaAdapter" />
    </controladapters>
  </browser>
</browsers>

There you go, now all your MetaCotrol should always render properly for you even though you don’t put any data at all in them. Feel free to comment on this article if you have other solutions or ideas on how to work around this problem.

• BeaverSFV 1.1 – 167
• CrazyBeavers YouTube Downloader 1.01 – 6
• CrazyBeavers Calendar Class 1.1 – 143
• CrazyBeavers RSS Class 1.3 – 188
• CrazyBeavers Upload Class 1.2 – 233
• CrazyBeavers Chat 1.3 – 123
• Imager Gallery 5.5 Prerelease – 1276
• CrazyBeavers Upload 2.4 – 207
• CrazyBeavers ZIP 1.0 Prerelease 3 – 69
• Imager Resizer 2.4 – 957

Looking at this it seems quite clear that Imager Gallery and Imager Resizer would be the best candidates for downloaded products. These stats are just for the past few months though but if they’ve had similar numbers since they were released during 2004-2005 it would give quite a lot of downloads. Lets elaborate a bit further though, most of my old ASP and ISAPI/COM applications are listed on HotScripts and Aspin aswell, lets look at their popularity there to the calculation.

• CrazyBeavers Calendar Class 1.1 – 5 565 views on HotScripts with 3 votes (4.33 average)
• CrazyBeavers RSS Class 1.3 – 2 175 views on HotScripts with 2 votes (5.00 average)
• Imager Gallery 5.5 Prerelease – 22 271 views on HotScripts with 74 votes (4.39 average)
• CrazyBeavers Upload 2.4 – 3 415 views on HotScripts with 15 votes (4.20 average)
• CrazyBeavers ZIP 1.0 Prerelease 3 – 651 views on HotScripts with 2 votes (5.00 average) – Listed under CGI & Perl though, wasn’t allowed in the ASP category
• Imager Resizer 2.4 – 6 246 views on HotScripts with 176 votes (4.78 average)

• Imager Gallery 5.5 Prerelease – 26 940 views on Aspin with 9 votes (5 stars)
• CrazyBeavers 2.4 – 6 147 views on Aspin with 1 votes (5 stars)
• Imager Resizer 2.4 – 17 325 views on Aspin with 37 votes (5 stars)

Now thats some numbers, over 22 000 views of Imager Gallery on HotScripts and almost 27 000 on Aspin. If we go a bit crazy and assume that a third the of people (probably it would be closer to a quarter of the people but that isn’t as fun to count with) also downloaded the script we would have 16 000 downloads of Imager Gallery there! If we then add the numbers we would have 17 000 assumed downloads which is quite a lot. Still, Imager Gallery is only the second most downloaded of my products. The true winner, and the only product which I know for sure how many times it has been downloaded, is CrazyBeavers Winamp Controller. Counting in at 25 239 downloads since January 27th, 2005 its by far the most downloaded product I ever created and one of the few that I don’t use myself!

This article was just a little ego boost for myself but it feels so damn good that people actually seem to appreciate my work enough to download it over 20 000 times!

This article describes how to setup IIS6 on Windows 2003 to allow it to execute ISAPI and CGI extensions. For this example I’m using my own ISAPI application called Imager Resizer (which also was the reason that I wrote this article from the beginning).

First of all you need to locate your IIS Manager, if you don’t have it as a desktop icon as I have you will find it under Start->Settings->Control Panel->Administrative Tools->Internet Information Services and open it up.

When the IIS Manager opens up you first click on “Web service Extensions” node in the tree view on your left. This brings up a list with the currently known ISAPI/CGI extensions on your server. At the top of the list you’ll see “All Unknown CGI Extensions” and “All Unknown ISAPI Extensions”, by default both these are prohibited and I would recommend that they stay that way. If you are running a ton of different ISAPI or CGI extensions or is just a very lazy person that doesn’t care to much about security you can allow unknown extensions to execute but remember that if someone manage to put an ISAPI or CGI extension on your server without you knowing (a flawed upload script or whatever) they can do almost anything with it. If you decide to allow all unknown extensions you can skip to the last part of the article now.

To add a new extension to the list you can either go via the Action menu and selecting “Add a new Web service extension” or you can right click in the list (not on an item though!) and select the same thing.

This dialog is quite self explanatory but I’ll describe it anyway. Here you assign a name to identify the extension, in my case I chose “Imager Resizer” for the name. Then I click the “Add” button to browse to the required files (only Imager.dll in my case) and then finally I check the checkbox with the label “Set extension status to Allowed” so I don’t have to enable it manually afterwards. After that, I simply click OK and the dialog vanishes. Now Imager Resizer will be visible in the extension list (since I took the screenshots from my production server Imager Resizer was already in the list though) and it’s status is set to Allowed.

Now we’ve introduced Imager.dll to IIS and told it to allow it to execute, however there is one more condition that must be filled and it has been there since IIS5 and maybe even longer then that. Anyway, what you need to do is to set the “Execute permissions” for the folder that holds the extension to “Scripts and Executables”. This is done by locating the folder in the IIS Manager (under Web Sites->MySite for example), right clicking on it and then selecting properties. In the properties dialog you chose the “Virtual Directory”/”Home directory” tab and look at the bottom of it. The second combobox counting from the bottom is the “Execute permissions” (hopefully you were able to read that yourself though) and it is probably set to “Scripts only” to start with. Set it to “Scripts and Executables” and click OK.

Thats it, now you should be able to browse to your extension and see it in action. If using Imager Resizer you can use the /test action to verify that it works correctly by going to http://www.mysite.com/Imager.dll/test. It should then return a page looking something like this: http://www.kallesbildarkiv.se/cgi-bin/Imager.dll/test. Thats it for this article, hope I didn’t miss anything essential and that it will help a few people setting up Imager Resizer or any other ISAPI or CGI extensions.

Anyone remembered why I wrote this article the first time? Here is a quote from the original about why I wrote it.

Imagine a script that selects all nodes (XPath query was something like “//*”), not caring where in the document, then looping them thru looking at their names and guessing what they are and then adding them to four separate strings with some weird separator. After doing this, they split the strings into four arrays and started looping out the content. Oh please, it was horrible. No real sense of XML at all I’m afraid . I know there are better resources then that on the net, but I still felt I had to contribute with just one more.

Hopefully there are still people who need to learn this out there so I didn’t waste my time recovering it. Anyway, let’s get going

If you never heard of RSS earlier, you are either very ignorant to what happens on the web these days and/or you are stuck running Internet Explorer which lacks any built in support for it. It all comes down quite easy though. An RSS feed is an online news syndication in the XML format. The main idea is to have a standardized way to share news over the net. I for an instance offers my articles as an RSS feed so people easily will know when I’ve written something new. For those who want to dive deeper into RSS I would recommend “What Is RSS” over at XML.com.

I thought that it might also be a good idea to show a short RSS feed with only one news item in it so you know what source we are working with.

<?xml version="1.0" encoding="ISO-8859-1"?>
<rss version="2.0">
  <channel>
    <title>My company RSS Feed</title>
    <link>http://www.mysite.com/</link>
    <description>My company extends products using XML</description>
    <language>en-uk</language>
    <pubdate>Fri, 16 Apr 2006 15:15:00 +0200</pubdate>
    <item>
      <title>New company started</title>
      <link>http://www.mysite.com/news.asp?id=26</link>
      <comments>http://www.mysite.com/comments.asp?id=26</comments>
      <description>Here the description goes</description>
      <pubdate>Fri, 16 Feb 2006 00:00:00 +0200</pubdate>
</rss>

This is a quite minimal feed document. It could have any number of “item” nodes aswell as it could have way more descriptive tags both for the channel and for the items. This is not how the feed for my site looks. I’m using a nice tool that generates everything for me and puts in 10 or 15 extra tags that are far from necessary. I feel that it would be quite an overkill to start out with that and I doubt that more then 5% of the RSS readers out there actually cares about all those tags anyway.

Anyway, lets get going. For those who have read my previous tutorials, there isn’t anything really new here, for those who haven’t, I would recommend reading XML, XMLDom and ASP Part 1 and XML, XMLDom and ASP Part 2.

dim xmlDom, nodeCol, oNode, oChildNode
set xmlDom = Server.CreateObject("MSXML2.Domdocument.4.0")

call xmlDom.setProperty("ServerHTTPRequest", true)
xmlDom.async = false
call xmlDom.load("http://www.beaverblogg.com/?feed=rss2")

if not xmlDom.documentElement is nothing then
  set nodeCol = xmlDom.documentElement.selectNodes("channel/item")
  for each oNode in nodeCol
    Response.Write("<p>" & vbCrLf)
    set oChildNode = oNode.selectSingleNode("title")
    if not oChildNode is nothing then
      Response.Write("  <h1>" & oChildNode.text & "</h1>" & vbCrLf)
    end if
    set oChildNode = oNode.selectSingleNode("pubDate")
    if not oChildNode is nothing then
      Response.Write("  &raquo; " & oChildNode.text & "<br />" & vbCrLf)
    end if
    set oChildNode = oNode.selectSingleNode("description")
    if not oChildNode is nothing then
      Response.Write("  " & oChildNode.text & "<br />" & vbCrLf)
    end if
    set oChildNode = oNode.selectSingleNode("link")
    if not oChildNode is nothing then
      Response.Write("  <br />" & vbCrLf)
      Response.Write("  <a href=""" & oChildNode.text & """ target=""_blank"">")
      Response.Write("    Link to full article" & vbCrLf)
      Response.Write("  </a>" & vbCrLf)
    end if
    Response.Write("</p>" & vbCrLf)
  next
else
  Response.Write("<p>" & vbCrLf)
  Response.Write("  An error occured." & vbCrLf)
  Response.Write("</p>" & vbCrLf)
end if

So lets start examining the code then.

dim xmlDom, nodeCol, oNode, oChildNode
set xmlDom = Server.CreateObject("MSXML2.Domdocument.4.0")

call xmlDom.setProperty("ServerHTTPRequest", true)
xmlDom.async = false
call xmlDom.load("http://www.beaverblogg.com/?feed=rss2")

This part is very almost a carbon copy of the first lines in my second article, I just added nodeCol, oNode, oChildNode and i to the variable declaration and set the async property to false. The async property tells if the dom should proceed in asynchronous or synchronous mode. Since we don’t want it to continue to execute without being done with the HTTP request, we set it to false (synchronous mode).

if not xmlDom.documentElement is nothing then
 ...
else
  Response.Write("<p>" & vbCrLf)
  Response.Write("  An error occured." & vbCrLf)
  Response.Write("</p>" & vbCrLf)
end if

Next, we have a simple if statement to see if the document has a documentElement (root element, remember?). If not, we show a short error message.

  set nodeCol = xmlDom.documentElement.selectNodes("channel/item")
  for each oNode in nodeCol
    ...
  next

If the script got this far, we probably got our RSS feed without any problems. Now we call the selectNodes function to select all item nodes from the feed and put the collection in nodeCol. Then, we do a simple for-each loop to go through all the nodes in the collection.

    Response.Write("<p>" & vbCrLf)
    set oChildNode = oNode.selectSingleNode("title")
    if not oChildNode is nothing then
      Response.Write("  <h1>" & oChildNode.text & "</h1>" & vbCrLf)
    end if
    set oChildNode = oNode.selectSingleNode("pubDate")
    if not oChildNode is nothing then
      Response.Write("  &raquo; " & oChildNode.text & "<br />" & vbCrLf)
    end if
    set oChildNode = oNode.selectSingleNode("description")
    if not oChildNode is nothing then
      Response.Write("  " & oChildNode.text & "<br />" & vbCrLf)
    end if
    set oChildNode = oNode.selectSingleNode("link")
    if not oChildNode is nothing then
      Response.Write("  <br />" & vbCrLf)
      Response.Write("  <a href=""" & oChildNode.text & """ target=""_blank"">")
      Response.Write("    Link to full article" & vbCrLf)
      Response.Write("  </a>" & vbCrLf)
    end if
    Response.Write("</p>" & vbCrLf)

This might seem like a long chunk of code, but it’s quite repetive so I think you can handle it. First of all, we write some standard html markup. We encapsulate each item in a paragraph. Next, we try to select a childnode from the current node. Each item should have a title, a pubdate, a description and a link, but since people are lazy sometimes they leave one or several of them out so to make this as general as possible we make sure that the nodes exists to avoid a crash. Anyway, we try to selet any childnode named title and put it into the oChildNode variable. Then, if not oChildNode is nothing, we can ouput the text content of that node by using oChildNode.text. Again we are adding some markup to the code, this to make it easy to style it afterwards using CSS. We repeat the exact same thing for the other “supposed to be there” nodes and print them out accordingly. We even make a link out of the link node if it exists. And well, thats kinda it.

This post didn’t take long to write so I apologize if it contains any errors of some sort. If it do, then please tell me so I can correct them as fast as possible. It was quite fun though to join the stuff I’ve written about in the first to articles into this one and there will be more to come!

In my first article I showed how to parse an XML document using XMLDom and displaying the data. In this second tutorial I’ll show two different ways to retrieve an XML document from a remote server using ASP and ServerXMLHTTP.

XML is a great way to share information. However, if you want to be able to share it people will need to retrieve the data from you somehow (or you from them). For this purpose we have an object called XMLHTTP or, if used on a server, ServerXMLHTTP. Since both XMLDom and XMLHTTP are part of MSXML2 they can cooperate very nice. XMLDom can by auto use XMLHTTP to retrieve information and if you use XMLHTTP it can by auto return a XMLDom object with the retrieved XML data.

The easiest way to retrieve XML from an external site is to let the XMLDom handle it all. This requires the least amount of code and I would guess that it’s also a tiny bit more effective resource wise. Here is how to do it:

dim xmlDom
set xmlDom = Server.CreateObject("MSXML2.Domdocument.4.0")

call xmlDom.setProperty("ServerHTTPRequest", true)
call xmlDom.load("http://www.beaverblogg.com/?feed=rss2")

This code is really simple so I’ll describe it all in one chunk. First we declare the variable and create the xmlDom object. This is precisely as we did in the first article so far. Next we call the setProperty method to specify that it should use the “ServerHTTPRequest” feature. By specifying this we are able to pass an URL to the load method which we do on the next line. In this example it will load my RSS feed into the xmlDom.

This might seem like a great solution since it’s so simple, however it has some drawbacks. First of all, if the URL is unavaible, it will throw an error. Aswell as if the loaded data isn’t wellformed xml, it will throw an error. So to be sure that this code doesn’t throw an nasty error on your visitors you would have to extend it with some error handling.

dim xmlDom
set xmlDom = Server.CreateObject("MSXML2.Domdocument.4.0")

on error resume next

call xmlDom.setProperty("ServerHTTPRequest", true)
call xmlDom.load("http://www.beaverblogg.com/?feed=rss2")

if(Err <> 0) then
  Response.Write("An error occured when retrieving data from an external source.")
  Response.Write(Err.Description)
  Response.End
end if

on error goto 0

There we have it, some basic error handling to see if it loaded or not. I expect that people know at least some about error handling in ASP. If not, then write a comment about it and I make take it up a bit more in an later article.

The other way to go to retrieve external information is to manually create the ServerXMLHTTP object and making it browse to the URL and return it’s contents. This requires a bit more code, but it also has some other nice features. For example, it can post data to the remote server, it can retrieve other data then just xml like a binary file or a simple text document. I will start by creating the same example as I did previous in this article using ServerXMLHTTP.

dim xmlDom, xmlHttp
set xmlHttp = Server.CreateObject("Msxml2.ServerXMLHTTP.4.0")

call xmlHttp.Open("GET", "http://www.beaverblogg.com/?feed=rss2")
call xmlHttp.Send()

set xmlDom = xmlHttp.responseXML

This made for a whole extra line to the code if compared to the original earlier in this post. This one isn’t much harder to understand then the previous one. We declare the variables, we create the ServerXMLHTTP object and then we call the Open method of the xmlHttp object. This method takes two arguments, first one is a string which describes the HTTP method to use. GET is fine unless you need to post data which you mostly won’t do. The second argument is the URL to retrieve the data from and again we use my RSS feed. After that we call the Send method which will trigger the object to browse to our URL and fetch the data. The Send method takes one optional argument which is the data to send to the URL. When using GET as method this has no real function. Last in the script we retrieve an xmlDom from the responseXML property of xmlHttp.

That wasn’t to bad was it? Though it isn’t ever as simple as it seems. If you are browsing to a url that doesn’t return “text/xml” as content type the responseXML property will be empty so we will need to add some error handling to that as well. Also, if you take the URL as a dynamic parameter and it doesn’t contain a valid URL or the URL is unavaible it will throw an error. So lets add the same as in the previous example here aswell and add some stuff to it.

dim xmlDom, xmlHttp
set xmlHttp = Server.CreateObject("Msxml2.ServerXMLHTTP.4.0")

on error resume next

call xmlHttp.Open("GET", "http://www.beaverblogg.com/?feed=rss2")
call xmlHttp.Send()

if(Err <> 0) then
  Response.Write("An error occured when retrieving data from an external source.<br />")

  Response.Write(Err.Description)
  Response.End
end if

on error goto 0

if(xmlHttp.status <> 200) then
  Response.Write("The remote server returned an invalid statuscode: #8221; & _
                       xmlHttp.status & " " & xmlHttp.statusText)
  Response.End
end if

if xmlHttp.responseXML is nothing then
  Response.Write("The remote server didn't return xml content.")
  Response.End
end if

set xmlDom = xmlHttp.responseXML

I know, it’s a mess. But it covers all problems that can arise and provides specific error messages for the different ones. I have to admit, I never go this far in error handling but I still want to show what that can be done and what to look for.

if(Err <> 0) then
  Response.Write("An error occurred when retrieving data from an external source.")
  Response.End
end if

After calling the Send method it might be an good idea to check the error object. If something failed miserably it probably was here.

if(xmlHttp.status <> 200) then
  Response.Write("The remote server returned an invalid statuscode: " & _
                       xmlHttp.status & " " & xmlHttp.statusText)
  Response.End
end if

After that it can always be an good idea to have a look at the status property to see what HTTP response code it returned. It it wasn’t 200 (HTTP 200 OK) we don’t want the data. Other usual statuscodes are 404 (File not found) and 500 (Internal server error) so those who want it really nice can check for those aswell and output it to the user.

if xmlHttp.responseXML is nothing then
  Response.Write("The remote server didn't return xml content.")
  Response.End
end if

Last we check if there is a responseXML object avaible. If it isn’t, then the server returned an invalid response (and might be caught already but not for sure).

There we have it, two different approaches to retrieving XML from an external source. There is however one more thing I would like to talk about. In this article I’ve used the ServerXMLHTTP object. When asking my good friend Google about retrieving external data using ASP I found several articles telling the readers to create the “Microsoft.XMLHTTP” object or “MSXML2.XMLHTTP.4.0″. This will work on your ASP page, but it’s not a very good idea to use. They were created for use in a client environment, not to be executed by a server. They rely on winsock (or some other client side communication layer, can’t remember exactly which, sorry) instead of winhttp which is used for server applications. Being built as clientside objects they also use the current proxy settings from Internet Explorer which might not always be desirable. I will get back to these objects in a later article when I start to talk about Ajax development which works with these objects using clientside JavaScript.

I haven’t decided yet what to write about in Part 3 to be honest. It will be XML for sure, but I’m not sure if I will go for simple XSL stylesheets or creating new documents using xmlDom only. Tune in for my next article and we’ll see what it contains .

Here is a quite typical XML document. It contains a root element, a description tag and a collection of files.

<root>
  <description>Files attached to subject 1</description>
  <files>
    <file filename="beaver.jpg" size="12432" description="A picture of a beaver" />
    <file filename="beaver2.jpg" size="53174" description="Another picture of a beaver" />
    <file filename="beaverfarm.doc" size="162475&#8243; description="Secret plans of new beaver farm" />
  </files>
</root>

Thats the way I like to have my XML. As much as possible as attributes. Some people seem to prefer this type though:

<root>
  <description>Files attached to subject 1</description>
  <files>
    <file>
      <filename>beaver.jpg</filename>
      <size>12432</size>
      <description>A picture of a beaver</description>
    </file>
    <file>
      <filename>beaver2.jpg</filename>
      <size>53174</size>
      <description>Another picture of a beaver</description>
    </file>
    <file>
      <filename>beaverfarm.doc</filename>
      <size>162475</size>
      <description>Secret plans of new beaver farm</description>
    </file>
  </files>
</root>

This is easier to understand for a beginner maybe but it’s not as easy to work with as the first data.

Anyway, lets try to get some data out of this. Lets imagine that the XML data is avaible in a filed called Data.xml in the same folder as the script. I’ll concentrate on the first XML example to start with.

dim xmlDom, oNode, nodeCol
set xmlDom = Server.CreateObject("MSXML2.DOMDocument.4.0")
xmlDom.load(Server.Mappath("Data.xml"))
if(xmlDom.parseError <> 0) then

  Response.Write("Invalid XML loaded. " & xmlDom.parseError.reason)
  Response.End
end if

if xmlDom.documentElement is nothing then
  Response.Write("Invalid XML loaded. No root tag exists")
  Response.End
end if

set oNode = xmlDom.documentElement.selectSingleNode("description")
if not oNode is nothing then
  Response.Write("Description: " & oNode.text & "<br />")
end if

set nodeCol = xmlDom.documentElement.selectNodes("files/file")
for each oNode in nodeCol

  Response.Write("<span title=""")
  Response.Write(Server.HTMLEncode(oNode.getAttribute("description"))
  Response.Write(""">File: ")
  Response.Write(Server.HTMLEncode(oNode.getAttribute("filename")))
  Response.Write(" (")

  Response.Write(Server.HTMLEncode(oNode.getAttribute("size")))
  Response.Write(" bytes)</span><br />")
next

The output of this would look something like this:

Description: Files attached to subject 1
File: beaver.jpg (12432 bytes)
File: beaver2.jpg (53174 bytes)

File: beaverfarm.doc (162475 bytes)

Not to shabby if you ask me. Lets take a quick stroll through the code now.

dim xmlDom, oNode, nodeCol
set xmlDom = Server.CreateObject("MSXML2.DOMDocument.4.0")
xmlDom.load(Server.Mappath("Data.xml"))
if(xmlDom.parseError <> 0) then
  Response.Write("Invalid XML loaded. " & xmlDom.parseError.reason)
  Response.End
end if

This part kinda explains itself. Declare the variables we are going to use. Then create the XMLDom object. We expect the data to be in a file called Data.xml in the current folder so we use Server.Mappath to get the absolute path to it and then calls .load from the XMLDom to load the data.

Then to be sure that there was no problems with the loading we check that the parseError property of the XMLDom is 0. If it isn’t something is wrong with our XML data and we show an error and quit.

if xmlDom.documentElement is nothing then
  Response.Write("Invalid XML loaded. No root tag exists")
  Response.End
end if

set oNode = xmlDom.documentElement.selectSingleNode("description")
if not oNode is nothing then
  Response.Write("Description: " & oNode.text & "<br />")
end if

The second part might be a bit harder to understand. First, we check if xmlDom.documentElement is nothing. If it is we throw an error and end the execution of the script. The documentElement of a XML document is the root element. In our case, the tag. Every XML document needs one and only one root element. It can be named anything however so isn’t a mandatory name, I just like to use it. If xmlDom.documentElement is nothing then it’s most likely that Data.xml was just an empty file. The XMLDom could parse the data without problems since there wasn’t anything to parse so this is a good thing to look for.

Next we try to read out the description element by using a XPath query. The function used is called selectSingleNode() and will return one single node (just as it’s name says) from the specified XPath query. It is avaible on any node in the document and works with relative XPaths. My XPath query is very simple and states that I want the node called “description”. I call the procedure from the documentElement node so I don’t have to write “root/description” which is it’s real path. Calling xmlDom.selectSingleNode(“root/description”) would return the same result.

After selecting the node and puttings it’s reference in the oNode variable we make an if-statement to see if it returned an object. If oNode is nothing then there wasn’t any node called “description” at the specified place in the document. If it isn’t nothing, then we expect that we got the right now and print it out using it’s .text property.

set nodeCol = xmlDom.documentElement.selectNodes("files/file")
for each oNode in nodeCol
  Response.Write("<span title=""")
  Response.Write(Server.HTMLEncode(oNode.getAttribute("description"))
  Response.Write(""">File: ")
  Response.Write(Server.HTMLEncode(oNode.getAttribute("filename")))
  Response.Write(" (")
  Response.Write(Server.HTMLEncode(oNode.getAttribute("size")))
  Response.Write(" bytes)</span><br />")
next

Not much left now. Here we use another procedure called selectNodes(). Like selectSingleNode() this procedure is avaible on all nodes and uses an XPath query to specify which nodes that we want. The main difference is that selectNodes() returns a collection of nodes instead of a single one.

The XPath query this time specifies that we want all “file” nodes under “files”. Not to hard to understand this one either. We put the reference to the collection in the nodeCol variable.

Next we initiate a for-each loop to go through all the nodes in a simple manner. We write out some markup (HTML) to make it look good. First we create a tag with a title attribute in which we put the file description. Every node has a function called getAttribute() which takes one parameter with the attribute name. It returns an empty string if the attribute was not found and if it exists it returns the value. We make sure to HTMLEncode the value since we might not know what text is in the attribute and we don’t want anything that breaks our markup do we?

We end the opening tag and write out the filename. We also add a paranthesis with the filesize in bytes. All using the .getAttribute function. Then finallyl we close the tag and add a linebreak before the next file.

This is the way I like it to be done. If I got to shape the XML it would be as much as possible in the attributes and as few element nodes as possible. But since I don’t get to chose XML in all cases I still get suck with the second XML example some times. Here is how the code to produce the same output would look using that source data.

dim xmlDom, oNode, nodeCol
set xmlDom = Server.CreateObject("MSXML2.DOMDocument.4.0")
xmlDom.load(Server.Mappath("Data.xml"))
if(xmlDom.parseError <> 0) then
  Response.Write("Invalid XML loaded. " & xmlDom.parseError.reason)
  Response.End
end if

if xmlDom.documentElement is nothing then
  Response.Write("Invalid XML loaded. No root tag exists")
  Response.End
end if

set oNode = xmlDom.documentElement.selectSingleNode("description")
if not oNode is nothing then

  Response.Write("Description: " & oNode.text & "<br />")
end if

set nodeCol = xmlDom.documentElement.selectNodes("files/file")
for each oNode in nodeCol
  Response.Write("<span title=""")
  Response.Write(Server.HTMLEncode(oNode.selectSingleNode("description").text)
  Response.Write(""">File: ")
  Response.Write(Server.HTMLEncode(oNode.selectSingleNode("filename").text))
  Response.Write(" (")
  Response.Write(Server.HTMLEncode(oNode.selectSingleNode("size").text))
  Response.Write(" bytes)</span><br />")
next

Not much happened there until the last block. Now I have to use selectSingleNode() to get the subnodes (child nodes) and look at their text property to get the values out. This might not seem like a great problem but most people get tired of havings lots and lots of element nodes after some time.

XPath is a quite powerful query language. You can specify in quite detail what nodes you want. For example, if I only want files that are smaller then 100kb I could just change a bit in the script to this:

set nodeCol = xmlDom.documentElement.selectNodes("files/file[@size<102400]")

Adding [] after a node tells that I want to evalutate something. The @ before “size” denotes that I want to look at an attribute node. It’s quite easy to understand for most. If I would like to do this using the second example the query would look like this:

set nodeCol = xmlDom.documentElement.selectNodes("files/file[size<102400]")

This has been a brief introduction to working with the XMLDom in ASP aswell as making some simple XPath queries. It is also my first serious blogg post ever written so I hope someone finds it interessting. It was written in one evening without testing any of the code. Next time I’ll dig a bit deeper into XPath and show how you can retrieve XML data from an external websource using XMLHTTP.