Using Syndication Classes to Generate RSS Feeds
In the previous article
I discussed how to consume RSS feeds exposed by other web sites onto your site.
You may also want to expose your own site content as RSS or ATOM feed. The
syndication classes also allow you to accomplish this easily. This article shows
One of the advantage of using .NET syndication classes is that you need not
bother about the intricacies of the feed format (RSS, ATOM etc.). You build your
feed in a format neutral fashion and while serializing it decide which format to
be used viz. RSS or ATOM.
In order to expose your site content as a feed you need to perform the
- Create a SyndicationFeed object and specify its properties. These
properties are applicable to the feed as a whole.
- Create one or more SyndicationItem objects. Each instance represents a
single feed item. A feed item can also have one or more SyndicationPerson
and SyndicationLink associated with it.
- Once created add SyndicationItem to the SyndicationFeed
- Decide the feed format viz. RSS or ATOM
- Serialize the entire SyndicationFeed to the response stream
Let's put all the above steps to work by developing a simple web form. For
the sake of simplicity we will not focus on database interactions. We will
assume that your code has, by some means, access to the data to be exposed.
Begin by creating a new web site. Make sure to refer required assemblies as
mentioned in the previous
Create SyndicationFeed object
The first step to expose your content is to create a SyndicationFeed object
that represents your feed.
SyndicationFeed feed = new SyndicationFeed();
feed.Title = new TextSyndicationContent
("DotNetBips.com RSS Feed");
feed.Copyright = new TextSyndicationContent
("Copyright (C) 2008. All rights reserved.");
feed.Description = new TextSyndicationContent
("Rss Feed Generated Via .NET 3.5 Syndication Classes");
feed.Generator = "DotNetBips.com RSS Feed Generator";
SyndicationLink link = new SyndicationLink();
link.Title = "DotNetBips.com";
link.Uri = new Uri("http://www.dotnetbips.com");
The SyndicationFeed class has several properties. The Title property
specifies the title of the feed as it appears in any feed reader. The Title
property is of type TextSyndicationContent. The TextSyndicationContent class
represents any content that is in plain text format. The Copyright, Description
and Generator properties represent the copyright holder of the content,
description of the feed and name of the feed generator application respectively.
You can also add a URL to the feed provider with the help of SyndicationLink
class. Though the Links property of the SyndicationFeed is a collection property
in many cases you will have just one link in it.
The next step in to create one or more SyndicationItem instances. Normally
you will run a for loop against your database to fetch data of the individual
SyndicationItem item = new SyndicationItem();
item.Id = Guid.NewGuid().ToString();
item.Title = new TextSyndicationContent
("Sample feed item");
item.Summary = new TextSyndicationContent
item.Content = new TextSyndicationContent
("This is sample content");
Here, we created an instance of SyndicationItem class and set its Id, Title,
Summary and Content properties. The Id property is an indicator of a unique
identifier (generally a GUID or URL) for the current feed item. The Summary
property normally holds a small description of the item whereas the Content
property holds the entire content to be exposed.
Creating SyndicationLink and SyndicationPerson
Every feed item can have a collection of SyndicationLink objects (exposed as
Links property) and a collection of SyndicationPerson objects (exposed as
Authors property) associated with it.
SyndicationLink itemlink = new SyndicationLink();
itemlink.Title = "DotNetBips.com";
itemlink.Uri = new Uri("http://www.dotnetbips.com/"
+ item.Id.ToString() + ".aspx");
SyndicationPerson person = new SyndicationPerson();
person.Name = "Tom & Jerry";
person.Email = "firstname.lastname@example.org";
Adding feed items to the feed
Once you create one or more feed items you can then add them to the
List<SyndicationItem> items =
feed.Items = items;
Here, we created a generic List of SyndicationItem objects and added
individual SyndicationItem objects to it. Then Items property of the
SyndicationFeed class is set to the generic List we just created.
Serializing the feed
In the final step you need to serialize the feed to the response stream. Note
that nowhere in the above code you specified whether the feed will be an RSS
feed or ATOM feed. You will do that in this final step.
Response.ContentType = "text/xml";
XmlWriter rssWriter = XmlWriter.Create
Rss20FeedFormatter rssFormatter =
Here, we first clear the response buffer to ensure that our feed content
alone is serialized. Then we set ContentEncoding and ContentType properties to
appropriate MIME types.
The Rss20FeedFormatter class allows you to serialize a SyndicationFeed in RSS
format. If you want to expose your feed as an ATOM feed then you would have used
Atom10FeedFormatter class instead. The constructor of the Rss20FeedFormatter
class accepts an instance of XmlWriter class that wraps the stream to write. In
our case we pass the stream obtained from Response.Output property. The feed
content is serialized using WriteTo() method of the Rss20FeedFormatter class.
The XmlWriter is then closed and response is ended.
If you put all the above code in the Page_Load event handler of a web form
and view the web form in the browser you should see something like this: