ASP.

NET RSS Toolkit

3/26/2006 Update (version 1.0.0.1)
• Added MaxItems property to RssDataSource to limit the number of items
returned.
• Added automatic generation of <link> tags from RssHyperLink control, to light
up the RSS toolbar icon in IE7. For more information please see
http://blogs.msdn.com/rssteam/articles/PublishersGuide.aspx
• Added protected Context property (of type HttpContext) to RssHttpHandlerBase
class, to allow access to the HTTP request while generating a feed.
• Added generation of LoadChannel(string url) method in RssCodeGenerator so
that one strongly typed channel class can be used to consume different channels.
• Fixed problem expanding app relative (~/…) links containing query string when
generating RSS feeds.

Summary
The RSS toolkit includes support for consuming as well as publishing RSS feeds in
ASP.NET applications. Features include:
• RSS Data Source control to consume feeds in ASP.NET applications
o Works with ASP.NET data bound controls
o Implements schema to generate columns at design time
o Supports auto-generation of columns at runtime (via
ICustomTypeDescriptor implementation)
• Caching of downloaded feeds both in-memory and on-disk (persisted across
process restarts)
• Generation of strongly typed classes for RSS feeds (including strongly typed
channel, items, image, handler) based on a RSS URL (the toolkit recognizes RSS
and RDF feeds) or a file containing RSS definition. Allows programmatically
download (and create) RSS channels using strongly-typed classes. The toolkit
includes:
o Stand-alone command line RSS compiler
o Build provider for .rssdl file (containing the list of feed URLs)
o Build provider for .rss file (containing RSS XML)
• Support for generation of RSS feeds in ASP.NET application including:
o RSS HTTP handler (strongly typed HTTP handlers are generated
automatically by the build providers) to generate the feed.
o RSS Hyper Link control (that can point to RSS HTTP handler) to create
RSS links
o Optional secure encoding of user name into query string to allow
generation of personalized feeds
• Set of classes for programmatic consumption and generation of RSS feed in a
late-bound way, without using strongly types generated classes
The toolkit is packaged as an assembly (DLL) that can be either placed in GAC or in
‘bin’ directory of a web application. It is also usable from client (including WinForms)
applications.

RSS Toolkit works in Medium Trust (RssToolkit.dll Assembly either in GAC or in ‘bin’)
with the following caveats:
• If the ASP.NET application consumes RSS feeds, the trust level must be
configured to allow outbound HTTP requests.
• To take advantage of disk caching, there must be a directory (configurable via
AppSettings["rssTempDir"]) where the trust level policy would allow write
access. However, disk caching is optional.

Complete sources are included in the package.

This is v1.0 so of course there could be bugs…

Package Contents
bin/
binaries including RssToolkit.dll Assembly and Rssdl.exe command line
compiler.

sources/
build.bat to build the binaries. Note: if binaries are re-built then web.config file
(and reference directive in pages) in the sample applications need to be updated to
change the PublicKeyToken in the assembly reference.

sources/toolkit/
sources for RssToolkit.dll

sources/rssdl/
sources for Rssdl.exe, the command line RSS compiler

samples/
sample ASP.NET application both consuming and publishing RSS feeds
Scenario walkthroughs
The sample places RssToolkit.dll in GAC (one way to install it into GAC is to run
“gacutil –i RssToolkit.dll”. The toolkit assembly can also be placed into ‘bin’ directory.

To add RSS controls to the VS toolbox, select ‘Choose Items…’ and ‘Browse…’ to
RssToolkit.dll.

‘Samples’ directory contains the pages described in the scenarios below.

Scenario 1 -- Consuming RSS feed using RssDataSource control

• Add DataList control to the page, select ‘New Data Source’ and choose
‘RssDataSource’.
• Type in the URL of the RSS feed in the RSS Data Source configuration dialog
• Edit DataList template:
o Remove all existing fields
o Add HyperLink
o Data bind ‘Text’ to ‘title’ and ‘NavigateURL’ to ‘link’

Generating strongly typed classes to consume feeds

This can be accomplished in two ways:
• Using Rssdl.exe command line utility and placing the resuling source file into
app_code, for example:
rssdl http://rss.msnbc.msn.com/id/3032091/device/rss/rss.xml Msnbc.cs
• By placing .rssdl containing the link to the feed(s) into app_code directly:
<rssdl>
<rss name="Msnbc" url="http://rss.msnbc.msn.com/id/3032091/device/rss/rss.xml/" />
</rssdl>
The samples contain a pre-generated sources file for the feed.

Scenario 2 -- Consuming RSS feed using ObjectDataSource control

• Add DataList control to the page, select ‘New Data Source’ and choose
‘ObjectDataSource’.
• Pick the strongly typed Channel as the business object and ‘LoadChannelItems’ as
Select Method
• Edit DataList template:
a. Remove all existing fields
b. Add HyperLink
c. Data bind ‘Text’ to ‘title’ and ‘NavigateURL’ to ‘link’
Scenario 3 -- Consuming RSS feed programmatically using strongly
typed classes
• Add a GridView to the page without selecting a data source
• Load channel using strongly typed class and data bind programmatically:
MyChannel c = MyChannel.LoadChannel();
GridView1.DataSource = c.Items;
GridView1.DataBind();

Scenario 4 -- Consuming RSS feed programmatically using late

bound classes
• Add a GridView to the page without selecting a data source
• Load channel using late bound channel class and data bind programmatically:
GenericRssChannel c;
c = GenericRssChannel.LoadChannel("http://myserver/myrss");
GridView1.DataSource = c.SelectItems();
GridView1.DataBind();

Scenario 5 – Publishing RSS feed using strongly typed classes

• Place channel schema file (.rss) into app_code directory
• Create HTTP handler (.ashx) derived from the auto-generated strongly typed
HTTP handler – override PopulateItems method:
public class MyHandler : MyChannelHttpHandlerBase {
protected override void PopulateChannel(string channelName,
string userName) {
Channel.Items.Add(new MyChannelItem(...));
...
}
}
• On the page publishing RSS feed place RssHyperLink control and configure it:
o Point NavigateUrl to the .ashx handler
o Specify ChannelName property to be passed to the handler – useful when
a single handler produces multiple channels
o Set IncludeUserName to true, to create a secure personalized link with the
encoded user name.
Note that RSS properties that are URLs can be entered as app-relative links (~/…) – they
will be automatically converted to fully qualified URLs when RSS XML is generated.

Scenario 6 – Publishing RSS feed using late bound classes

• Create HTTP handler (.ashx) derived from GenericRssHttpHandlerBase –
override PopulateItems method:
public class MyHandler : GenericRssHttpHandlerBase {
protected override void PopulateChannel(string channelName,
string userName) {
Channel["title"] = "...";
Channel["link"] = "~/...";
Channel["description"] = "...";
GenericRssElement item = new GenericRssElement();
item["title"] = "Scenario1";
 item["description"] = "Consuming RSS feed using RssDataSource";
item["link"] = "~/scenario1.aspx";
Channel.Items.Add(item);
...
}
}
• On the page publishing RSS feed place RssHyperLink control and configure it to
make NavigateUrl to point to the .ashx handler

---