Stefan Sedich's Blog : XML

Enhanced XMLSiteMapProvider with support for dynamic nodes.

stefan.sedich — Thu, 14 Aug 2008 11:43:00 GMT

Hello All,

This might be a long one so bear with me here this might bore you :).

I have have had the need to be able to add dynamic nodes to my sitemap, I am using a sitemap xml file. My first solution, was to create a custom sitemap provider, which would parse the XML and if it detected the node I had to insert my dynamic nodes into, it would do this and then continue.

Fine I thought but not good enough. I wanted a generic solution that could be reused and that would be easy to use. I came up with the idea of extending the sitemap XML file to contain some new nodes. Then create a custom parser that would make use of this. The idea in the end was to add two new elements to the sitemap, the elements being <dynamicNode> and <dynamicNodes>, the idea was that they would call a static method on a class that would either return 1 node or a collection. These would then be injected into the sitemap when it is created.

The beauty here was that you could add dynamic nodes to our sitemap, one other side effect was that you could now nest dynamic nodes in static nodes, and also nest static nodes in either a dynamic node, or a dynamic nodes collection. If you look at the sample project supplied you will see this works quite well. One thing to note is that any static nodes added to either a dynamic node or dynamic nodes collection. It will be added at the end. Which I think is expected behaviour, well for me anyway.

- The new sitemap file -

Here is an example of what the sitemap file will now look like. Say we have 3 static nodes, and within the static products node, we need to get products from our database, and add them as children. You could create an easy site map file like so:

Here you can see that we have added some static nodes, and within our products node, we have added a dynamicnodes, node. You can see that this calls the static method GetProducts on the MenuHelper class. This method will return a collection of nodes which will be inserted into our static nodes children. And dynamic insertion of child nodes is now possible :)... You are also able to have a dynamic node, which is a single root node, plus you can nest until your heart is content, which you will see in the sample.

-- MenuHelper --

In this class we would have a static GetProducts method, this would return a list of XX objects. These objects are helpers, they allow us to create a collection of sitemap nodes, so that they can be used in the provider to build up the sitemap. The node has the default properties (key,url,title,description) and you can add custom attributes too. The method would look like so, you could imagine this would use the database to get products and build up the list.

public static List<EnhancedXMLSiteMapProvider.EnhancedSiteMapNode> GetProducts() {
            return new List<EnhancedXMLSiteMapProvider.EnhancedSiteMapNode>() {
                  new EnhancedXMLSiteMapProvider.EnhancedSiteMapNode() {
                       Key="Product1.aspx",
                       Url="Product1.aspx",
                       Title="Product 1"
                   }
             };
}

-- Web.Config Configuration --

You need to configure the provider in the web.config. In the sample project this is done as so:

<siteMap defaultProvider="EnhancedXMLSiteMapProvider">
            <providers>
                <add name="EnhancedXMLSiteMapProvider" type="EnhancedXMLSiteMapProviderSample.EnhancedXMLSiteMapProvider, EnhancedXMLSiteMapProviderSample"
                siteMapFile="~/Web.sitemap"
cacheDuration="15"/>
            </providers>
</siteMap>

I am basically setting it as the default provider, I am pointing it to the xml sitemap file, and setting the cache duration (this defaults to 5 if not set). Once this is done you are ready to run. One thing to note is that the provider also puts a dependancy on the xml file, so that once changed it invalidates the sitemap. And also after the time duration.

One issue is that any dynamic data does not invalidate the cache, you are able to set a cacheKey on the provider which is used for caching. Then you can use code to remove the item. So you backend could remove the cache item when it needs the menu to change.

-- The Provider --

I am not going to go into full detail on the provider and show all the code, it is all included in the sample project so just have a look. Basically the main workings, just parses the XML file, depending on the node type will do different things. If it encounters a dynamicNode or dynamicNodes element it will grab the type and method attributes, and use reflection to call these methods and continue parsing the data.

I have tested this with many levels/combinations of nodes and I have not had any issues yet, mind you I know this needs neatening up and it is only the efforts of a days work. I will post updates as I go and any bug fixes to this. But at the moment I am happy with where it is.

-- Final Word --

The sample project is supplied below, have a play and let me know what you think. Also this is the first time I have ever used the site map provider, so if I have just reinvented the wheel please give me a gentle slap and let me know :).

Sample Project Files
------------------------------------------------------------
EnhancedXMLSiteMapProviderSample.zip

Cheers
Stefan

A Templated ASP.NET RSS Feed Reader Control

stefan.sedich — Tue, 18 Mar 2008 13:28:00 GMT

Update 20070330:

By popular demand (well a couple people) I have included a sample project with everything needed to get started using this control.

Basically just a sample web project, click here to get the zipped archive. You might notice things are done a little different, I include the System.ServiceModel.Syndication namespace on my page so that I can case the Container.DataItem to a SyndicationItem and access its properties that way, stops using Eval, but each to their own.

Hope that makes it easier for some, will be including full source in future too :).

Project Files:
TemplatedRSSFeedReader.zip

Thanks
Stefan

Update 20070319:

Today I attended the Heros Happen event in Perth, and I learnt something very very cool, you see how I wrote my own classes and code to load the syndicated feed in, then used LINQ to XML to load that into my classes. During Dave Glovers presentation on WCF he had a sample in there that was building an RSS feed, and I could see he was using some classes to do so. What I then noticed is these classes are new in .NET 3.5 and will make creation of this control 100 times easier plug give us full support of the RSS 2.0 spec and allow us to access all feed proprties :) :) and will mean *removing* code and making things much simpler.

Firstly we need to add a reference to the System.ServiceModel.Web assembley, this is where the magic is. Then add a using System.ServiceModel.Syndication; to the RSSReader.cs class, we then have access to these helper classes which allow us to easily read and create RSS 2.0 and ATOM 1.0 feeds, as I am only supporting RSS I will only use the RSS formatter. To read our feed we need to do the below:

Firslty read the feed into an XMLReader:

XmlReader reader = XmlReader.Create("http://weblogs.asp.net/stefansedich/rss.aspx");

Then create an instance of the RSS20FeedFormatter and then make this read the data from the xmlreader:

Rss20FeedFormatter feedFormatter = new Rss20FeedFormatter();
feedFormatter.ReadFrom(reader);

We now can get access to the feed by using feedFormatter.Feed, this gives us an instance of a SyndicationFeed class which gives us access to all items and properties of our feed. The only difference now is that as some properties are a little different accessing them is different.So instead of feed.Title you use feed.Title.Text instead. The good thing with this is, 1. We have removed the need to do this manually and 2. We have all properties that belong to an RSS feed.

The updated RSSReader class is below with the code changes. You can now remove the Feed and FeedItem classes we created earlier as they are needed no more. It just goes to show we learn something new every day.....

Code:

/// <summary>

/// An RSS Feed reader server control, it will basically aggregate rss feeds and display the content

/// </summary>

public class RSSReader : CompositeControl, INamingContainer {

#region Properties

/// <summary>

/// The URL of the feed to display

/// </summary>

public string FeedURL {

get {

return ViewState["FeedURL"] != null ? ViewState["FeedURL"].ToString() : string.Empty;

}

set {

ViewState["FeedURL"] = value;

}

/// <summary>

/// The number of items to show from the feed, 10 is the default.

/// </summary>

public int FeedItemCount {

get {

return ViewState["FeedItemCount"] != null ? (int)ViewState["FeedItemCount"] : 10;

}

set {

ViewState["FeedItemCount"] = value;

}

/// <summary>

/// The header template for this control

/// </summary>

[TemplateContainer(typeof(RSSReaderDataItem)), PersistenceMode(PersistenceMode.InnerProperty)]

public ITemplate HeaderTemplate { get; set; }

/// <summary>

/// The footer template for this control

/// </summary>

[TemplateContainer(typeof(RSSReaderDataItem)), PersistenceMode(PersistenceMode.InnerProperty)]

public ITemplate FooterTemplate { get; set; }

/// <summary>

/// The item template for this control

/// </summary>

[TemplateContainer(typeof(RSSReaderDataItem)), PersistenceMode(PersistenceMode.InnerProperty)]

public ITemplate ItemTemplate { get; set; }

#endregion

#region Constructor

// Default constructor

public RSSReader() {

}

#endregion

#region Child Control Creation

/// <summary>

/// Creates child controls for this control, first create the header

/// based on template, then the items, then finally the footer.

/// </summary>

protected override void CreateChildControls() {

// Get our RSS feed data, this is returned as a collection

// of the RSSReaderDataItem controls.

SyndicationFeed feed = this.GetRSSData();

if (feed != null) {

// Create the header template, and add to the controls.

if (this.HeaderTemplate != null) {

// Create the dataitem control for the header

// and assign it the current feed as its dataitem.

RSSReaderDataItem header = new RSSReaderDataItem() {

DataItem = feed

};

// Instantiate template, add to controls and

// databind header.

this.HeaderTemplate.InstantiateIn(header);

this.Controls.Add(header);

header.DataBind();

}

if (this.ItemTemplate != null) {

foreach (SyndicationItem dataItem in feed.Items) {

// Create an item child control and

// assign the current feed item as its dataitem.

RSSReaderDataItem item = new RSSReaderDataItem() {

DataItem = dataItem

};

// Instantiate the item template, add to controls

// and databind the item.

this.ItemTemplate.InstantiateIn(item);

this.Controls.Add(item);

item.DataBind();

}

if (this.FooterTemplate != null) {

// Create the footer dataitem

// and assign it the current feed as its dataitem.

RSSReaderDataItem footer = new RSSReaderDataItem() {

DataItem = feed

};

// Instantiate the template, add to controls

// and databind the footer.

this.FooterTemplate.InstantiateIn(footer);

this.Controls.Add(footer);

footer.DataBind();

}

#endregion

#region RSS Data Retrieval

/// <summary>

/// Fetched the RSS data from the current RSS Feed

/// </summary>

/// <returns>A collection of RSSReaderDataItems</returns>

private SyndicationFeed GetRSSData() {

SyndicationFeed feed = null;

// Only do if we have a feed url specified.

if (!string.IsNullOrEmpty(this.FeedURL)) {

// Get the current feed and load into an XMLReader

using (XmlReader reader = XmlReader.Create(this.FeedURL)) {

Rss20FeedFormatter feedFormatter = new Rss20FeedFormatter();

// Read the contents of the XMLReader into the FeedFormatter

feedFormatter.ReadFrom(reader);

// Get the current feed.

feed = feedFormatter.Feed;

}

return feed;

}

#endregion

}

And you would change the controls template on the page a little to be able to read the properties:

<cc2:RSSReader ID="RSSReader2" runat="server" FeedURL="http://weblogs.asp.net/stefansedich/rss.aspx">
<HeaderTemplate>
            <div>
                  <b><%# Eval("Title.Text") %></b>
                  <br /><br />
       </HeaderTemplate>
       <ItemTemplate>
            <%# Eval("Title.Text") %>
            <br /><br />
            <%# Eval("Summary.Text") %>
            <hr />
        </ItemTemplate>
        <FooterTemplate>
             </div>
         </FooterTemplate>
</cc2:RSSReader>

Thanks
Stefan

---------------------------------------------------------------------------------------------------------------------------------------------------------------------

Hello All,

Bored again tonight thought I would have a play and write a Templated RSS feed reader control, using .NET 3.5. I created a control that you can control with templates, you just set the FeedURL, the FeedItemCount, Header and Footer templates if needed and the ItemTemplate and you are set. This post could get quite lengthy and will have lots of code examples. I kind of assume you know about templated controls in asp.net and do not go much into the details of their workings.

Loading an RSS Feed:

Thought I would make this a little better than just loading the feed in the control. So I ended up creating a Feed class and a FeedItem class, as the names suggest one is the feed and the other represents a feed item. In the Feed class there is a LoadFeed method, this takes the url and limit, then uses LINQ to XML to load the feed. If a limit > 0 is provided it will also limit the number of items in the feed. The code for the classes are below:

/// <summary>
    /// Represents an RSS Feed
    /// </summary>
    public class Feed {

        #region Properties

        /// <summary>
        /// The title of the feed
        /// </summary>
        public string Title { get; set; }

        /// <summary>
        /// A link to the site that hosts the feed
        /// </summary>
        public string Link { get; set; }

        /// <summary>
        /// A description of the feed
        /// </summary>
        public string Description { get; set; }

        /// <summary>
        /// The items that are contained within this feed
        /// </summary>
        public IEnumerable<FeedItem> Items { get; set; }

        #endregion

        #region Feed Loading

        /// <summary>
        /// Given a feed URL, loads that feed.
        /// </summary>
        /// <param name="feedURL"></param>
        public void LoadFeed(string feedURL, int limit) {

            // Load the feed from the URL we have set
            // as a property on this control.
            XDocument rssFeed = XDocument.Load(feedURL);

            // Get the channel element.
            var channel = rssFeed.Descendants("channel").First();

            // Set the main feed values.
            this.Title = channel.Element("title").Value;
            this.Description = channel.Element("description").Value;
            this.Link = channel.Element("link").Value;

            // Process all the feed items and add them to the
            // main feed class.
            this.Items = (from item in rssFeed.Descendants("item")
                          select new FeedItem {
                              Title = item.Element("title").Value,
                              Description = item.Element("description").Value,
                              Link = item.Element("link").Value
                          });

            if (limit > 0) {
                // If the limit is > 0 then limit the
                // number of items in our feed.
                this.Items = this.Items.Take(limit);
            }

        }

        #endregion

    }

The feed class just has the feeds main properties and a collection of items, the LINQ to XML takes care of loading the items and relevant properties.

/// <summary>
    /// Represents an RSS item
    /// </summary>
    public class FeedItem {

        /// <summary>
        /// The title of the item
        /// </summary>
        public string Title { get; set; }

        /// <summary>
        /// The items description
        /// </summary>
        public string Description { get; set; }

        /// <summary>
        /// A link to the item
        /// </summary>
        public string Link { get; set; }

    }

The feeditem class just holds the properties for an item in our feed. One thing to note here is I did not implement all the properties according to RSS spec. I may do this at a future time thought and will update this post then.

The RSS Reader Control:

The control is where all the magic happens, basically to create a new templated control you need to create a control and add the template properties, in my case HeaderTemplate, FooterTemplate and ItemTemplate. All these template properties are an RSSReaderDataItem, this class internally just has a DataItem property which will either be the feed or the actual feed item incase of the ItemTemplate.

Basically my RSSReader control inherits from the CompositieControl class and then I override the CreateChildControls method, in here I get the RSS feed data and then begin to create the controls. First I create an instance of the header control and load the current HeaderTemplate into it, I set the dataitem to be the feed and then bind it. The same thing is done for the footer but using the FooterTemplate.

For each item in our feed I do the same thing just create an item, load the ItemTemplate, then set the DataItem to the current FeedItem, and databind. The controls code is listed below:

/// <summary>
    /// An RSS Feed reader server control, it will basically aggregate rss feeds and display the content
    /// </summary>
    public class RSSReader : CompositeControl, INamingContainer {

        #region Properties

        /// <summary>
        /// The URL of the feed to display
        /// </summary>
        public string FeedURL {
            get {
                return ViewState["FeedURL"] != null ? ViewState["FeedURL"].ToString() : string.Empty;
            }
            set {
                ViewState["FeedURL"] = value;
            }
        }

        /// <summary>
        /// The number of items to show from the feed, 10 is the default.
        /// </summary>
        public int FeedItemCount {
            get {
                return ViewState["FeedItemCount"] != null ? (int)ViewState["FeedItemCount"] : 10;
            }
            set {
                ViewState["FeedItemCount"] = value;
            }
        }

        /// <summary>
        /// The header template for this control
        /// </summary>
        [TemplateContainer(typeof(RSSReaderDataItem)), PersistenceMode(PersistenceMode.InnerProperty)]
        public ITemplate HeaderTemplate { get; set; }

        /// <summary>
        /// The footer template for this control
        /// </summary>
        [TemplateContainer(typeof(RSSReaderDataItem)), PersistenceMode(PersistenceMode.InnerProperty)]
        public ITemplate FooterTemplate { get; set; }

        /// <summary>
        /// The item template for this control
        /// </summary>
        [TemplateContainer(typeof(RSSReaderDataItem)), PersistenceMode(PersistenceMode.InnerProperty)]
        public ITemplate ItemTemplate { get; set; }

        #endregion

        #region Constructor

        // Default constructor
        public RSSReader() {

        }

        #endregion

        #region Child Control Creation

        /// <summary>
        /// Creates child controls for this control, first create the header
        /// based on template, then the items, then finally the footer.
        /// </summary>
        protected override void CreateChildControls() {

            // Get our RSS feed data, this is returned as a collection
            // of the RSSReaderDataItem controls.
            Feed feed = this.GetRSSData();

            if (feed != null) {

                // Create the header template, and add to the controls.
                if (this.HeaderTemplate != null) {

                    // Create the dataitem control for the header
                    // and assign it the current feed as its dataitem.
                    RSSReaderDataItem header = new RSSReaderDataItem() {
                        DataItem = feed
                    };

                    // Instantiate template, add to controls and
                    // databind header.
                    this.HeaderTemplate.InstantiateIn(header);
                    this.Controls.Add(header);
                    header.DataBind();

                }

                if (this.ItemTemplate != null) {
                    foreach (FeedItem dataItem in feed.Items) {

                        // Create an item child control and
                        // assign the current feed item as its dataitem.
                        RSSReaderDataItem item = new RSSReaderDataItem() {
                            DataItem = dataItem
                        };

                        // Instantiate the item template, add to controls
                        // and databind the item.
                        this.ItemTemplate.InstantiateIn(item);
                        this.Controls.Add(item);
                        item.DataBind();

                    }
                }

                if (this.FooterTemplate != null) {

                    // Create the footer dataitem
                    // and assign it the current feed as its dataitem.
                    RSSReaderDataItem footer = new RSSReaderDataItem() {
                        DataItem = feed
                    };

                    // Instantiate the template, add to controls
                    // and databind the footer.
                    this.FooterTemplate.InstantiateIn(footer);
                    this.Controls.Add(footer);
                    footer.DataBind();

                }

            }

        }

        #endregion

        #region RSS Data Retrieval

        /// <summary>
        /// Fetched the RSS data from the current RSS Feed
        /// </summary>
        /// <returns>A collection of RSSReaderDataItems</returns>
        private Feed GetRSSData() {
            Feed feed = new Feed();

            // Only do if we have a feed url specified.
            if (!string.IsNullOrEmpty(this.FeedURL)) {
                // Load the feed.
                feed.LoadFeed(this.FeedURL, this.FeedItemCount);
            }

            return feed;
        }

        #endregion

    }

Also the code for the RSSFeedDataItem is below, this is the control that is used for our Templates, it just contains the DataItem.

    /// <summary>
    /// This is the item control template.
    /// </summary>
    public class RSSReaderDataItem : Control, INamingContainer {

        #region Properties

        /// <summary>
        /// The RSS data item.
        /// </summary>
        public object DataItem { get; set; }

        #endregion

        #region Constructor

        /// <summary>
        /// Default, initialize properties.
        /// </summary>
        public RSSReaderDataItem() {
            this.DataItem = null;
        }

        #endregion

    }

Using the control:

Just drop the control on your page and set your templates, and in there you will have access to your feed properties, I am using Eval("NAME") to get the values.

For the header and footer you can get access to the feeds main properties plus items, so you could even show the count of items etc. In the ItemTemplate you only have access to the current feed item, so you can display any of the normal feed item properties.

    <cc2:RSSReader ID="RSSReader2" runat="server" FeedURL="http://weblogs.asp.net/stefansedich/rss.aspx">
            <HeaderTemplate>
                <div>
                    <b><%# Eval("Title") %></b>
                    <br /><br />
            </HeaderTemplate>
            <ItemTemplate>
                <%# Eval("Title") %>
                <br /><br />
                <%# Eval("Description") %>
                <hr />
            </ItemTemplate>
            <FooterTemplate>
                </div>
            </FooterTemplate>
    </cc2:RSSReader>

The End:

The control still has some things that could be done, but I will leave that up to the reader. It would be nice to implement the full RSS spec and use all properties, this could probably be done easier using a 3rd party library for the RSS loading. And even add the ability to add more filtering support to filter by date or even category.

The control shows how easy it is to make templated controls that let you modify the output very easily. This not only makes reuse of your controls better but it lets you fully customise the way your control renders. If you need a primer on templated controls maybe start with this link.

If you would like source code for this just email me and I will send you a copy of a sample project for you to use.

Thanks
Stefan

I Think I Love LINQ

stefan.sedich — Mon, 24 Dec 2007 02:51:00 GMT

I am beggining to really like to ease of using LINQ, On a project I am working on now I am storing configuration in an XML file like so:

<sites>
    <site id="1" sitename="foo">
       <domains>
          <domain url="www.foo.com" />
       </domains>
       <settings>
          <setting key="foo" value="foo" />
       </settings>
    </site>
</sites>

My original solution to load this involded looping over the nodes looping over the domains and settings and loading this into my Site object. Time consuming to write and looked messy. And then LINQ to XML steps in. My code to parse this XML file into my collection of Site objects now becomes:

Me.Sites = (From site In document.Descendants("site") _
                        Select New Site With { _
                        .ID = site.Attribute("id").Value, _
                        .SiteName = site.Attribute("sitename").Value, _
                        .Domains = (From domain In site.Elements("domains").Descendants("domain") _
                                    Select domain) _
                                    .ToDictionary(Function(domain) domain.Attribute("url").Value, Function(domain) domain.Attribute("url").Value), _
                        .Settings = (From setting In site.Elements("settings").Descendants("setting") _
                                    Select setting) _
                                    .ToDictionary(Function(setting) setting.Attribute("key").Value, Function(setting) setting.Attribute("value").Value) _
                        }).ToList()

The speed of this is actually pretty fast and I tested with some large XML files and was happy with the performance. And I dont think life can get easier....

Cheers

Stefan