ASP.Net RssToolkit Version 2.0

shahpiyush — Sat, 16 Jun 2007 06:28:00 GMT

I have been part of the team working on the latest version ASPNET RssToolkit, originally created by Dmitry Robsman. We enhanced this awesome Toolkit and have just released version 2.0 of the Toolkit. Please check out Codeplex to download this toolkit.

Here are some of the changes in this version –

Consume and publish Atom/Rdf/Opml feeds.
Strongly typed classes, close to Rss specification.
Feeds Aggregation using OPML. The outlines in OPML can have Rss/Atom/Rdf.
Rss Schema validation during aggregation.
Download Manager can be used to download any Url and return a Stream. It also has inbuilt caching mechanism.
Added support for Extensions and Enclosures.
Added Visual Studio Testing Framework Unit Tests.
Rearranged Namespaces to closely match the features.

Here is how to use the RssToolkit. I have taken excerpts from ScottGu’s review on the original RssToolkit.

Consuming Feeds using RssToolkit -

A. Using RssDataSource – This webcontrol gives you the ability to databind to an Rss/Atom/Rdf/Opml feed. It inherits from DataSourceControl to give itself the ability serve as a data source to data-bound controls. Here are the steps you can take to use RssDataSource in your page or user control –

1. Add the RssDataSource and RssHyperLink to the Toolbox in Visual Studio.

2. In your Web form, drop the RssDataSource.

3. Click the control and “Configure Data Source”

4. It ask you for the feed Url. The RssDataSourceConfigForm.cs is used in this case.

You can provide RSS/ATOM/RDF/OPML and RssDataSource will automatically identify the feed type and provide Databinding capability.

As you can see below, I’m actually providing an Atom feed URL to the RssDataSource.

5. You can then bind a control like Gridview to this DataSource.

6. I will “Edit Columns” on the GridView and have 2 columns, as shown –

7. You can also specify the number of items you want to be returned back. I will go in the code behind and change that to 5

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default2.aspx.cs" Inherits="Default2" %>

<%@ Register Assembly="RssToolkit" Namespace="RssToolkit.Web.WebControls" TagPrefix="cc1" %>

<title>Consuming Google News using RssToolkit</title>

</head>

<body>

Google News (Atom Format)

<div>

<cc1:rssdatasource id="RssDataSource1" runat="server" maxitems="5" url="http://news.google.com/?output=atom"></cc1:rssdatasource>

</div>

<asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="False" DataSourceID="RssDataSource1">

<asp:HyperLinkField DataNavigateUrlFields="link" DataTextField="link" HeaderText="Link"/>

<asp:BoundField DataField="title" HeaderText="Title" SortExpression="title" />

</Columns>

</asp:GridView>

</form>

</body>

</html>

8. Compile and View the page in browser –

B. Consume using RssDocument.cs – RssDocument.cs class can be used from your code if you want to consume/publish or manipulate feeds. It provides various overloads for Loading a feed –

· Load - takes 3 overloads System.Uri, Xml string and XmlReader. You can provide Rss/Atom/Rdf/Opml type of formats for these 3 overloads and it will automatically identify the base feed type and construct the class.

· SelectItems – this method returns IEnumerable which gives the ability to iterate over the collection. It is also used internally to provide data binding capability to RssDataSource.

· ToXml – this method which returns an Xml as a string, provides the capability of publishing the feed into Rss/Atom/Rdf/Opml formats. The input parameter (DocumentType enum) suggests the format of Xml returned by this method.

· ToDataSet – this method returns the feed as a DataSet.

Here is how to use the RssDocument –

void Page_Load(object sender, EventArgs e)

{

RssToolkit.Rss.RssDocument rss = RssToolkit.Rss.RssDocument.Load(new System.Uri("http://rss.msnbc.msn.com/id/3032091/device/rss/rss.xml"));

Image1.ImageUrl = rss.Channel.Image.Url;

GridView1.DataSource = rss.SelectItems();

GridView1.DataBind();

}

C. Consume using Custom Generated Class and RssDl.exe – Let’s say you want to consume a feed which has some extensions that is not specified in the Rss specification such as Media Rss by Yahoo.
An example of Media Rss tags are -
<media:player url="http://youtube.com/?v=dMH0bHeiRNg" />
<media:thumbnail url="http://sjc-static6.sjc.youtube.com/vi/dMH0bHeiRNg/2.jpg" width="120" height="90" />
<media:title>Evolution of Dance</media:title>
<media:category label="Tags">Dancing comedy</media:category>
<media:credit>judsonlaipply</media:credit>

You can still get strong typing for these extensions by generating a custom class using the RssDl.exe

Usage – RssDl.exe “URL” “ClassName.cs”

E.g.

RssDl.exe “http://youtube.com/rss/global/top_favorites.rss” “YouTube.cs”

RssDl.exe “http://news.google.com/?output=rss” “GoogleNews.vb”

As shown below I created a custom class for YouTube’s Top favorites feed, which has Media Rss tags.

If you open the newly created class “YouTube.cs” you will see the extensions as Strongly typed properties inside the class.

[XmlElement("player", Namespace="http://search.yahoo.com/mrss/")]

public YoutubePlayer Player {

get {

return _player;

}

set {

_player = value;

}

[XmlElement("thumbnail", Namespace="http://search.yahoo.com/mrss/")]

public YoutubeThumbnail Thumbnail {

get {

return _thumbnail;

}

set {

_thumbnail = value;

}

[XmlElement("category", Namespace="http://search.yahoo.com/mrss/")]

public YoutubeCategory Category {

get {

return _category;

}

set {

_category = value;

}

[XmlElement("credit", Namespace="http://search.yahoo.com/mrss/")]

public string Credit {

get {

return _credit;

}

set {

_credit = value;

}

You will have to embed this class in your application or put in App_Code folder of your website. You can then use the class just like RssDocument.cs.

<title>Youtube Media Rss</title>

void Page_Load(object sender, EventArgs e)

{

YoutubeRss rss = YoutubeRss.Load();

DataList1.DataSource = rss.Channel.Items;

DataList1.DataBind();

}

</script>

</head>

<body>

You Tube Top Favories(Media Rss)

<asp:DataList ID="DataList1" runat="server" RepeatColumns="3" GridLines="both">

<asp:Image ID="Image1" runat="Server" ImageUrl='<%# Eval("Thumbnail.Url") %>' /><br />

<asp:HyperLink ID="HyperLink1" NavigateUrl='<%# Eval("Player.Url") %>' Text='Link' runat="server" />

</ItemTemplate>

</asp:DataList>

</form>

</body>

</html>

Here is what the page looks like -

Aggregation –

RssToolkit provides Aggregation using Outline Processor Markup Language (OPML). Check out the OPML specification here. OPML is used for creating a list of feeds known as Outlines to be shared or aggregated. Here is what an OPML format looks like –

<?xml version="1.0" encoding="iso-8859-1"?>

<head>

<title>List of Feeds News Feeds</title>

<ownerName>Webmaster</ownerName>

<ownerEmail>owner@msdn.com</ownerEmail>

</head>

<body>

outline text='BBC News’ description='Updated every minute of every day - FOR PERSONAL USE ONLY' htmlUrl='http://news.bbc.co.uk/go/click/rss/0.91/public/-/1/hi/default.stm' language='unknown' title='BBC News' type='rss' version='RSS' xmlUrl='http://news.bbc.co.uk/rss/newsonline_uk_edition/front_page/rss091.xml'/>

</body>

</opml>

As seen above the Outline has the information of the feeds to be aggregated, XmlUrl provides the Url of the Feed.

To aggregate Feeds using RssToolkit you need to provide the location of the OPML file or proved the OPML Xml. You can use the Load method in the RssDocument.cs Class for Aggregation. As shown before the Load of RssDocument has 3 overloads –

public static RssDocument Load(string xml);

public static RssDocument Load(Uri url);

public static RssDocument Load(XmlReader reader);

Example -

RssDocument rssAggregatedFeed = RssDocument.Load (new System.Uri("http://static2.podcatch.com/blogs/gems/opml/mySubscriptions.opml"));

Publishing your Feeds

RssHyperLink – This WebControl can be used for publishing your Feed. You can point this tool to the feed location and it automatically generates link tag -

This tag enables Feed Autodiscovery in browsers. It enables the in IE and FireFox. To publish the feeds using RssToolkit, you can use one of the mechanisms below –

A. Using ASP.Net Buildprovider mechanism – RssToolkit uses ASP.Net BuildProvider class to automatically detect certain files created or modified in the filesystem. It automatically generates code and compiles the code for any files with extension *.rss or *.rssdl. RssToolkit then uses RssDocument.cs class and De-serializes the feed. It also builds an HttpHandler, which you can then inherit from to publish your feed.

In the samples provided. The App_Code folder has Sample5.Rss

<?xml version="1.0" encoding="utf-8"?>

<title>Sample Channel</title>

<description>Channel For Scenario5 in ASP.NET RSS Toolkit samples.</description>

<webMaster>webmaster@email.com</webMaster>

<item>

</item>

<item>

</item>

</channel>

</rss>

When the file is created or modified RssToolkit automatically generates code and compiles it based on the schema of this file. It pre-fixes all the files with “Sample5”. So like RssDocument there will be Sample5Rss, RssChannel will have Sample5Channel and so on. It also creates a default HttpHanlder called Sample5HtppHandlerBase which inherits from RssHttpHandlerBase. You can create a custom *.ashx HttpHandler which inherits from Sample5HttpHandlerBase and you can publish the Sample5.rss

<%@ WebHandler Language="C#" Class="RssHyperLinkFromCustomClass" %>

using System;

using System.Collections.Generic;

using System.Web;

using RssToolkit.Rss;

public class RssHyperLinkFromCustomClass: Sample5HttpHandlerBase

{

protected override void PopulateRss(string rssName, string userName)

{

Rss.Channel = new Sample5Channel();

Rss.Channel.Items = new List<Sample5Item>();

if (!string.IsNullOrEmpty(rssName))

{

Rss.Channel.Title += " '" + rssName + "'";

}

if (!string.IsNullOrEmpty(userName))

{

Rss.Channel.Title += " (generated for " + userName + ")";

}

Rss.Channel.Link = "~/scenario6.aspx";

Rss.Channel.Description = "Channel For Scenario6 in ASP.NET RSS Toolkit samples.";

Rss.Channel.Ttl = "10";

Rss.Channel.User = userName;

Sample5Item item = new Sample5Item();

item.Title = "CodeGeneratedClass";

item.Description = "Consuming RSS feed programmatically using strongly typed classes";

item.Link = "~/CodeGeneratedClass.aspx";

Rss.Channel.Items.Add(item);

item = new Sample5Item();

item.Title = "ObjectDataSource";

item.Description = "Consuming RSS feed using ObjectDataSource";

item.Link = "~/ObjectDataSource.aspx";

Rss.Channel.Items.Add(item);

}

You can use RssHyperLink to point to this Custom HttpHandler –

<cc1:RssHyperLink ID="Rsshyperlink4" runat="server" IncludeUserName="True" NavigateUrl="~/RssHyperLinkFromCustomClass.ashx">RSS</cc1:RssHyperLink>

When clicked on the link the output shown will be –

B. Using RssDocument class – RssDocument.cs has a method ToXml(), which can be used to serialize and publish the RssDocument class.

public string ToXml(DocumentType outputType);

It takes DocumentType enum which has the following values –

public enum DocumentType

    Unknown,

    Rss,

    Opml,

    Atom,

Rdf

}

So to publish your feed as an ATOM from RssDocument, you can do the following inside an ASP.Net Module or an HttpHandler –

string inputXml = rssDocument.ToXml(DocumentType.Atom); // Publish as Atom

XmlDocument document = new XmlDocument();
document.LoadXml(inputXml);

context.Response.ContentType = "text/xml";

// save XML into response

document.Save(HttpContent.Current.Response.OutputStream);

In the samples provided with the Toolkit you can see 2 samples which publish your feed into various formats. The output is as shown

As seen in the above sample, the output feed is picked up from the querystring “outputtype”. You can provide “rss”, “rdf”, “atom” and “opml” for the respective feeds.

Strongly typed classes –

The toolkit provides strong typing to the Rss Classes.

e.g.

void Page_Load(object sender, EventArgs e)

{

RssToolkit.Rss.RssDocument rss = RssToolkit.Rss.RssDocument.Load(new System.Uri("http://rss.msnbc.msn.com/id/3032091/device/rss/rss.xml"));

Image1.ImageUrl = rss.Channel.Image.Url;

GridView1.DataSource = rss.SelectItems();

GridView1.DataBind();

}

Caching of Feeds –

DownloadManager.cs class is used to get information of the feed. The feed is cached locally to the disk. The location and time of the caching is configurable. You can use the keys in the web.config to change the values –

</appSettings>

You can download the ASP.Net RSSToolkit here.

You can Discuss or Post issues on Codeplex.

Special Thanks to Dmitry Robsman, Marc Brooks and Jon Gallant.

Creating Widgets using Javascript Simple Syndication - JSS

shahpiyush — Sat, 05 May 2007 09:04:00 GMT

Web syndication is a way to make content of your website or application available for others to use. Rss/Atom/Rdf are specifications, which websites use for this purpose. However to consume such formats in your website, you need to know a little programming as these feeds are in Xml and they have a certain specification. Let’s say you want to show top 10 latest news items from Google news in the bottom right corner of your website. You will need to write code to read the feed off the Google website, parse the Xml and then format it into Html.

This is fine if you have the ability, but with Web 2.0, widgets, badges, AJAX, etc. Simplicity, refactoring, ease of use is what consumers are looking for. People want readymade plug and play components, which they can just plug into their website and it works, instead of diving into programming, rummaging through specifications, poking around with formatting, etc.

JSS can help in that regards. JSS is not a syndication specification, its an easy way to use the available syndication formats. All the consumer needs to do for using your syndication is to embed some lines of readymade Javascript code you provide them, which they can plug into their website to automatically display your content.

Below is a sample of what the consumer would need to put in the website –

By embedding the above line of code in your website it will render something like below

The options I have in the above URL are –

· Feed Url – The url which contains the Feed the consumer would like to display.

· Count – number of items to display

· ShowTitle – Whether to show the title of the feed.

· Table Parameters – You can specify the columns you would like to see, if style is table.

· Style – It takes 4 styles

o Bullets

o Dropdown

o Table – You can specify the columns in the tableparameters querystring

o Definition lists

A code implementation of JSS provided below.

Piyush Shah's Blog : RDF

ASP.Net RssToolkit Version 2.0

Creating Widgets using Javascript Simple Syndication - JSS