Create RSS and Atom feeds using custom ASP.Net MVC Action Results and the Microsoft Syndication classes

There are many ways to create RSS and Atom feeds, in this post I’m going to show one way of creating a re-usable solution that utilises the Syndication classes from the System.ServiceModel.Web assembly.

To make good use of the ASP.Net MVC framework I am going to show a nice way of creating custom action result methods to return the feeds without the need for creating any views.

As this is quite a detailed overview with a fair amount of code – you can download a working solution here.

The first thing to do is create the custom ActionResult methods to return our feeds.

You will need to add a project reference to the System.ServiceModel.Web assembly.

RssActionResult

 

  1. using System.ServiceModel.Syndication;
  2. using System.Web.Mvc;
  3. using System.Xml;
  4. namespace SyndicationTest
  5. {
  6.     /// <summary>
  7.     /// Returns an RSS feed to the resonse stream.
  8.     /// </summary>
  9.     public class RssActionResult : ActionResult
  10.     {
  11.         SyndicationFeed feed;
  13.         /// <summary>
  14.         /// Default constructor.
  15.         /// </summary>
  16.         public RssActionResult() { }
  18.         /// <summary>
  19.         /// Constructor to set up the action result feed.
  20.         /// </summary>
  21.         /// <param name="feed">Accepts a <see cref="SyndicationFeed"/>.</param>
  22.         public RssActionResult(SyndicationFeed feed)
  23.         {
  24.             this.feed = feed;
  25.         }
  27.         /// <summary>
  28.         /// Executes the call to the ActionResult method and returns the created feed to the output response.
  29.         /// </summary>
  30.         /// <param name="context">Accepts the current <see cref="ControllerContext"/>.</param>
  31.         public override void ExecuteResult(ControllerContext context)
  32.         {           
  33.             context.HttpContext.Response.ContentType = "application/rss+xml";
  35.             Rss20FeedFormatter formatter = new Rss20FeedFormatter(this.feed);
  36.             using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.Output))
  37.             {
  38.                 formatter.WriteTo(writer);
  39.             }
  40.         }
  41.     }
  42. }

 

AtomActionResult

  1. using System.ServiceModel.Syndication;
  2. using System.Web.Mvc;
  3. using System.Xml;
  4. namespace SyndicationTest
  5. {
  6.     /// <summary>
  7.     /// Returns an Atom feed to the resonse stream.
  8.     /// </summary>
  9.     public class AtomActionResult : ActionResult
  10.     {
  11.         SyndicationFeed feed;
  13.         /// <summary>
  14.         /// Default constructor.
  15.         /// </summary>
  16.         public AtomActionResult() { }
  18.         /// <summary>
  19.         /// Constructor to set up the action result feed.
  20.         /// </summary>
  21.         /// <param name="feed">Accepts a <see cref="SyndicationFeed"/>.</param>
  22.         public AtomActionResult(SyndicationFeed feed)
  23.         {
  24.             this.feed = feed;
  25.         }
  27.         /// <summary>
  28.         /// Executes the call to the ActionResult method and returns the created feed to the output response.
  29.         /// </summary>
  30.         /// <param name="context">Accepts the current <see cref="ControllerContext"/>.</param>
  31.         public override void ExecuteResult(ControllerContext context)
  32.         {
  33.             context.HttpContext.Response.ContentType = "application/atom+xml";
  35.             Atom10FeedFormatter formatter = new Atom10FeedFormatter(this.feed);
  36.             using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.Output))
  37.             {
  38.                 formatter.WriteTo(writer);
  39.             }
  40.         }
  41.     }
  42. }

Now that the action result methods have been created, they can be called from your views using the same syntax as any other action result method.

Now assuming that you will be returning a list of items from your repository that you will want mapped into a syndication feed, we need to create a class that will hold property mappings from your list of custom types to the internal properties of the syndication helper class that we will be creating shortly.

This mapping class will be used simply for storing delegate properties used for mappings, this will allow for easy, strongly typed mapping.

SyndicationFeedItemMapper

  1. using System;
  2. namespace SyndicationTest
  3. {
  4.     public class SyndicationFeedItemMapper<TFeedItem> where TFeedItem : class
  5.     {
  6.         Func<TFeedItem, string> title;
  7.         Func<TFeedItem, string> content;
  8.         Func<TFeedItem, string> controller;
  9.         Func<TFeedItem, string> action;
  10.         Func<TFeedItem, string> id;
  11.         Func<TFeedItem, DateTimeOffset> datePublished;
  12.         string controllerString;
  13.         string actionString;
  15.         public SyndicationFeedItemMapper
  16.             (
  17.                 Func<TFeedItem, string> title,
  18.                 Func<TFeedItem, string> content,
  19.                 string controller,
  20.                 string action,
  21.                 Func<TFeedItem, string> id,
  22.                 Func<TFeedItem, DateTimeOffset> datePublished
  23.             ) : this(title, content, id, datePublished)
  24.         {
  25.             this.controllerString = controller;
  26.             this.actionString = action;
  27.         }
  29.         public SyndicationFeedItemMapper
  30.             (
  31.                 Func<TFeedItem, string> title,
  32.                 Func<TFeedItem, string> content,
  33.                 Func<TFeedItem, string> controller,
  34.                 Func<TFeedItem, string> action,
  35.                 Func<TFeedItem, string> id,
  36.                 Func<TFeedItem, DateTimeOffset> datePublished
  37.             )
  38.             : this(title, content, id, datePublished)
  39.         {
  40.             this.controller = controller;
  41.             this.action = action;
  42.         }
  44.         protected SyndicationFeedItemMapper
  45.             (
  46.                 Func<TFeedItem, string> title,
  47.                 Func<TFeedItem, string> content,
  48.                 Func<TFeedItem, string> id,
  49.                 Func<TFeedItem, DateTimeOffset> datePublished
  50.             )
  51.         {
  52.             this.title = title;
  53.             this.content = content;
  54.             this.id = id;
  55.             this.datePublished = datePublished;
  56.         }
  58.         public Func<TFeedItem, string> Title
  59.         {
  60.             get
  61.             {
  62.                 return this.title;
  63.             }
  64.         }
  65.         public Func<TFeedItem, string> Content
  66.         {
  67.             get
  68.             {
  69.                 return this.content;
  70.             }
  71.         }
  72.         public Func<TFeedItem, string> Controller
  73.         {
  74.             get
  75.             {
  76.                 return this.controller;
  77.             }
  78.         }
  79.         public Func<TFeedItem, string> Action
  80.         {
  81.             get
  82.             {
  83.                 return this.action;
  84.             }
  85.         }
  86.         public Func<TFeedItem, string> Id
  87.         {
  88.             get
  89.             {
  90.                 return this.id;
  91.             }
  92.         }
  94.         public Func<TFeedItem, DateTimeOffset> DatePublished
  95.         {
  96.             get
  97.             {
  98.                 return this.datePublished;
  99.             }
  100.         }
  102.         public string ControllerString
  103.         {
  104.             get
  105.             {
  106.                 return this.controllerString;
  107.             }
  108.         }
  109.         public string ActionString
  110.         {
  111.             get
  112.             {
  113.                 return this.actionString;
  114.             }
  115.         }
  117.         public Func<TFeedItem, string> AuthorName { get; set; }
  118.         public Func<TFeedItem, string> AuthorEmail { get; set; }
  119.         public Func<TFeedItem, string> AuthorUrl { get; set; }
  120.   
  121.     }
  122. }

You will notice that there is also support for allowing the controller and action method to be stored as a string rather than a delegate, this is because you may not want to hold this information in your repository.

To show you an example of how this mapping class is used.

Lets say the items come back from your repository into a list of MyFeedItem:

MyFeedItem

  1. using System;
  2. namespace SyndicationTest.Models
  3. {
  4.     public class MyFeedItem
  5.     {
  6.         public int Id { get; set; }
  7.         public string Title { get; set; }
  8.         public string Description { get; set; }
  9.         public DateTime DateAdded { get; set; }
  10.         public string CreatedBy { get; set; }
  11.     }
  12. }

These properties can be used to set up the feed mapper for example:

  1. SyndicationFeedItemMapper<MyFeedItem> mapper = new SyndicationFeedItemMapper<MyFeedItem>
  2.     (
  3.         f => f.Title,
  4.         f => f.Description,
  5.         "Home",
  6.         "Articles",
  7.         f => f.Id.ToString(),
  8.         f => f.DateAdded
  9.     );

Now that the items have been covered, you can create an options class to store information such as the feed title, description and url, there are also numerous optional properties you can set such as feed id, copyright statement, last updated date and language.

SyndicationFeedOptions

  1. using System;
  2. namespace SyndicationTest
  3. {
  4.     public class SyndicationFeedOptions
  5.     {
  6.         string title;
  7.         string description;
  8.         string url;
  10.         public SyndicationFeedOptions(string title, string description, string url)
  11.         {
  12.             this.title = title;
  13.             this.description = description;
  14.             this.url = url;
  15.         }
  16.    
  17.         public string Title
  18.         {
  19.             get
  20.             {
  21.                 return this.title;
  22.             }
  23.         }
  24.         public string Description
  25.         {
  26.             get
  27.             {
  28.                 return this.description;
  29.             }
  30.         }
  31.         public string Url
  32.         {
  33.             get
  34.             {
  35.                 return this.url;
  36.             }
  37.         }
  39.         public string FeedId { get; set; }
  40.         public DateTimeOffset LastUpdated { get; set; }
  41.         public string Copyright { get; set; }
  42.         public string Language { get; set; }
  44.     }
  45. }

You can populate the SyndicationFeedOptions class like the following:

  1. SyndicationFeedOptions options = new SyndicationFeedOptions
  2.                 (
  3.                     "My Feed Title",
  4.                     "My Feed Description",
  5.                     "http://mytesturl.com"
  6.                 );

Now that all the support classes have been built, it is time to build the main SyndicationFeedHelper class that will take in all the information and return a SyndicationFeed for converting into RSS or Atom.

The are only two public methods in this class, the constructor which sets up the feed options and stores the current controller context, and the GetFeed() method which calls the necessary private methods to create and then return the feed.

The most interesting private methods are probably the CreateSyndicationItem and the GetUrl.

The CreateSyndicationItem accepts an instance of the MyFeedItem class from the passed in list and invokes the delegates stored in the mapper against it. This then extracts the instance values and creates a SyndicationItem.

The GetUrl method accepts an instance of the MyFeedItem class from the passed in list and invokes the necessary delegates in the mapper against it to create valid MVC style urls for each item.

SyndicationFeedHelper

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.ServiceModel.Syndication;
  5. using System.Web.Mvc;
  6. using System.Web.Routing;
  7. namespace SyndicationTest
  8. {
  9.     /// <summary>
  10.     /// Class to create an syndication feed.
  11.     /// </summary>
  12.     /// <typeparam name="TFeedItem">Accepts the custom feed item type.</typeparam>
  13.     public class SyndicationFeedHelper<TFeedItem> where TFeedItem : class
  14.     {
  15.         const string Id = "id";
  17.         ControllerContext context;
  18.         IList<TFeedItem> feedItems;
  19.         SyndicationFeedItemMapper<TFeedItem> feedItemMapper;
  20.         SyndicationFeedOptions feedOptions;
  21.         SyndicationFeed syndicationFeed;
  22.         IList<SyndicationItem> syndicationItems;
  24.         ControllerContext Context
  25.         {
  26.             get
  27.             {
  28.                 return this.context;
  29.             }
  30.         }
  32.         IList<TFeedItem> FeedItems
  33.         {
  34.             get
  35.             {
  36.                 return this.feedItems;
  37.             }
  38.         }
  40.         SyndicationFeedItemMapper<TFeedItem> FeedItemMapper
  41.         {
  42.             get
  43.             {
  44.                 return this.feedItemMapper;
  45.             }
  46.         }
  48.         SyndicationFeedOptions SyndicationFeedOptions
  49.         {
  50.             get
  51.             {
  52.                 return this.feedOptions;
  53.             }
  54.         }
  56.         /// <summary>
  57.         /// Constructs the SyndicationFeedHelper.
  58.         /// </summary>
  59.         /// <param name="context">Accepts the current controller context.</param>
  60.         /// <param name="feedItems">Accepts a list of feed items.</param>
  61.         /// <param name="syndicationFeedItemMapper">Accepts a <see cref="SyndicationFeedItemMapper"/>.</param>
  62.         /// <param name="syndicationFeedOptions">Accepts a <see cref="SyndicationFeedOptions"/>.</param>
  63.         public SyndicationFeedHelper
  64.             (
  65.                 ControllerContext context,
  66.                 IList<TFeedItem> feedItems,
  67.                 SyndicationFeedItemMapper<TFeedItem> syndicationFeedItemMapper,
  68.                 SyndicationFeedOptions syndicationFeedOptions
  69.             )
  70.         {
  71.             this.context = context;
  72.             this.feedItems = feedItems;
  73.             this.feedItemMapper = syndicationFeedItemMapper;
  74.             this.feedOptions = syndicationFeedOptions;
  75.             syndicationItems = new List<SyndicationItem>();
  76.             SetUpFeedOptions();
  77.         }
  79.         /// <summary>
  80.         /// Creates and returns a <see cref="SyndicationFeed"/>.
  81.         /// </summary>
  82.         /// <returns><see cref="SyndicationFeed"/></returns>
  83.         public SyndicationFeed GetFeed()
  84.         {
  85.             feedItems.ToList().ForEach(feedItem =>
  86.             {
  87.                 SyndicationItem syndicationItem = CreateSyndicationItem(feedItem);
  89.                 AddItemAuthor(feedItem, syndicationItem);
  90.                 AddPublishDate(feedItem, syndicationItem);
  92.                 syndicationItems.Add(syndicationItem);
  93.             });
  95.             syndicationFeed.Items = syndicationItems;
  97.             return syndicationFeed;
  98.         }
  100.         private void SetUpFeedOptions()
  101.         {
  102.             syndicationFeed = new SyndicationFeed
  103.                 (
  104.                     this.SyndicationFeedOptions.Title,
  105.                     this.SyndicationFeedOptions.Description,
  106.                     new Uri(this.SyndicationFeedOptions.Url)
  107.                 );
  109.             AddFeedId();
  111.             AddCopyrightStatement();
  113.             AddLanguageIsoCode();
  115.             AddLastUpdateDateTime();
  116.         }
  118.         private void AddLastUpdateDateTime()
  119.         {
  120.             if (this.SyndicationFeedOptions.LastUpdated != default(DateTimeOffset))
  121.             {
  122.                 syndicationFeed.LastUpdatedTime = this.SyndicationFeedOptions.LastUpdated;
  123.             }
  124.         }
  126.         private void AddLanguageIsoCode()
  127.         {
  128.             if (!string.IsNullOrEmpty(this.SyndicationFeedOptions.Language))
  129.             {
  130.                 syndicationFeed.Language = this.SyndicationFeedOptions.Language;
  131.             }
  132.         }
  134.         private void AddCopyrightStatement()
  135.         {
  136.             if (!string.IsNullOrEmpty(this.SyndicationFeedOptions.Copyright))
  137.             {
  138.                 syndicationFeed.Copyright = new TextSyndicationContent(this.SyndicationFeedOptions.Copyright);
  139.             }
  140.         }
  142.         private void AddFeedId()
  143.         {
  144.             if (!string.IsNullOrEmpty(this.SyndicationFeedOptions.FeedId))
  145.             {
  146.                 syndicationFeed.Id = this.SyndicationFeedOptions.FeedId;
  147.             }
  148.         }
  150.         private void AddPublishDate(TFeedItem feedItem, SyndicationItem syndicationItem)
  151.         {
  152.             var publishDate = this.FeedItemMapper.DatePublished.Invoke(feedItem);
  153.             syndicationItem.PublishDate = publishDate;
  154.         }
  156.         private void AddItemAuthor(TFeedItem feedItem, SyndicationItem syndicationItem)
  157.         {
  158.             var authorEmail = this.FeedItemMapper.AuthorEmail == null ? string.Empty : this.FeedItemMapper.AuthorEmail.Invoke(feedItem);
  159.             var authorName = this.FeedItemMapper.AuthorName == null ? string.Empty : this.FeedItemMapper.AuthorName.Invoke(feedItem);
  160.             var authorUrl = this.FeedItemMapper.AuthorUrl == null ? string.Empty : this.FeedItemMapper.AuthorUrl.Invoke(feedItem);
  162.             SyndicationPerson syndicationPerson = new SyndicationPerson();
  164.             if (string.IsNullOrEmpty(authorName))
  165.             {
  166.                 syndicationPerson.Name = authorName;
  167.             }
  168.             if (string.IsNullOrEmpty(authorEmail))
  169.             {
  170.                 syndicationPerson.Email = authorEmail;
  171.             }
  172.             if (string.IsNullOrEmpty(authorUrl))
  173.             {
  174.                 syndicationPerson.Uri = authorUrl;
  175.             }
  176.             if (!string.IsNullOrEmpty(syndicationPerson.Name) || !string.IsNullOrEmpty(syndicationPerson.Email)
  177.                 || !string.IsNullOrEmpty(syndicationPerson.Uri))
  178.             {
  179.                 syndicationItem.Authors.Add(syndicationPerson);
  180.             }
  181.         }
  183.         private SyndicationItem CreateSyndicationItem(TFeedItem feedItem)
  184.         {
  185.             SyndicationItem syndicationItem = new SyndicationItem
  186.                 (
  187.                     this.FeedItemMapper.Title.Invoke(feedItem),
  188.                     this.FeedItemMapper.Content.Invoke(feedItem),
  189.                     this.GetUrl(feedItem)
  190.                 );
  191.             return syndicationItem;
  192.         }
  194.         private Uri GetUrl(TFeedItem feedItem)
  195.         {
  196.             UrlHelper urlHelper = new UrlHelper(this.Context.RequestContext);
  197.             var routeValues = new RouteValueDictionary();
  198.             routeValues.Add(Id, this.FeedItemMapper.Id.Invoke(feedItem));
  200.             var action = this.FeedItemMapper.Action == null ? this.FeedItemMapper.ActionString
  201.                 : this.FeedItemMapper.Action.Invoke(feedItem);
  202.             var controller = this.FeedItemMapper.Controller == null ? this.FeedItemMapper.ControllerString
  203.                 : this.FeedItemMapper.Controller.Invoke(feedItem);
  205.             var url = urlHelper.Action
  206.                 (
  207.                     action,
  208.                     controller,
  209.                     routeValues
  210.                 );
  211.             Uri uriPath = this.Context.RequestContext.HttpContext.Request.Url;
  212.             var urlString = string.Format("{0}://{1}{2}",uriPath.Scheme, uriPath.Authority, url);
  214.             return new Uri(urlString);
  215.         }
  216.     }
  217. }

At this point you have a fully functional, re-usable solution for displaying RSS and Atom feeds on your site.

You can now create some action results on your controller to return your feeds.

Here is an example of the Home controller on the downloadable example:

  1. using System.Collections.Generic;
  2. using System.Web.Mvc;
  3. using SyndicationTest.Models;
  4. using SyndicationTest.Repositories;
  6. namespace SyndicationTest.Controllers
  7. {
  8.     [HandleError]
  9.     public class HomeController : Controller
  10.     {
  12.         private FakeRepository fakeRepository = new FakeRepository();
  14.         /// <summary>
  15.         /// Index Action Result.
  16.         /// </summary>
  17.         /// <returns></returns>
  18.         public ActionResult Index()
  19.         {
  20.             return View();
  21.         }
  23.         /// <summary>
  24.         /// Returns an RSS Feed
  25.         /// </summary>
  26.         /// <param name="id">Accepts an int id.</param>
  27.         /// <returns></returns>
  28.         public RssActionResult GetRssFeed(int id)
  29.         {
  30.             SyndicationFeedItemMapper<MyFeedItem> mapper = SetUpFeedMapper();
  32.             SyndicationFeedOptions options = SetUpFeedOptions();
  34.             IList<MyFeedItem> feedItems = this.fakeRepository.GetLatestFeedItems(id);
  36.             SyndicationFeedHelper<MyFeedItem> feedHelper = SetUpFeedHelper(mapper, options, feedItems);
  38.             return new RssActionResult(feedHelper.GetFeed());
  39.         }
  41.         /// <summary>
  42.         /// Returns an Atom feed.
  43.         /// </summary>
  44.         /// <param name="id">Accepts an int id.</param>
  45.         /// <returns></returns>
  46.         public AtomActionResult GetAtomFeed(int id)
  47.         {
  48.             SyndicationFeedItemMapper<MyFeedItem> mapper = SetUpFeedMapper();
  50.             SyndicationFeedOptions options = SetUpFeedOptions();
  52.             IList<MyFeedItem> feedItems = this.fakeRepository.GetLatestFeedItems(id);
  54.             SyndicationFeedHelper<MyFeedItem> feedHelper = SetUpFeedHelper(mapper, options, feedItems);
  56.             return new AtomActionResult(feedHelper.GetFeed());
  58.         }
  60.         private SyndicationFeedHelper<MyFeedItem> SetUpFeedHelper(SyndicationFeedItemMapper<MyFeedItem> mapper,
  61.             SyndicationFeedOptions options, IList<MyFeedItem> feedItems)
  62.         {
  63.             SyndicationFeedHelper<MyFeedItem> feedHelper = new SyndicationFeedHelper<MyFeedItem>
  64.                 (
  65.                     this.ControllerContext,
  66.                     feedItems,
  67.                     mapper,
  68.                     options
  69.                 );
  70.             return feedHelper;
  71.         }
  73.         private static SyndicationFeedOptions SetUpFeedOptions()
  74.         {
  75.             SyndicationFeedOptions options = new SyndicationFeedOptions
  76.                 (
  77.                     "My Feed Title",
  78.                     "My Feed Description",
  79.                     "http://mytesturl.com"
  80.                 );
  81.             return options;
  82.         }
  84.         private static SyndicationFeedItemMapper<MyFeedItem> SetUpFeedMapper()
  85.         {
  86.             SyndicationFeedItemMapper<MyFeedItem> mapper = new SyndicationFeedItemMapper<MyFeedItem>
  87.                 (
  88.                     f => f.Title,
  89.                     f => f.Description,
  90.                     "Home",
  91.                     "Articles",
  92.                     f => f.Id.ToString(),
  93.                     f => f.DateAdded
  94.                 );
  95.             return mapper;
  96.         }
  97.     }
  98. }

You can call these action results in the same way as another type of action result for example:

  1. <%= this.Html.ActionLink("RSS Feed", "GetRssFeed", new { id = 123 })%>
  2.     <br />
  3.     <%= this.Html.ActionLink("Atom Feed", "GetAtomFeed", new { id = 456 })%>

I hope this overview is helpful.

Kind Regards,

Sean McAlinden.

www.asp-net-mvc.com

10 Comments

  • Thanks for your info on Syndication.

    One issue is that every time the feed is refreshed, a copy of the whole feed is appended with new times. This happens even if DateAdded is set to a constant.

    Any idea how to make it so it doesn't add duplicates every time its refreshed?

  • Hi Nolan,

    It sounds like the source data for your feed could be the problem, especially if the same data is coming back with new dates, if you have access to the data store/repository I would take a look at the query getting the results.
    I don't think the above code could cause the issue you're having as it should only display whatever is passed in as the feed list.
    If you work out that it's definitely not the source data, let me know and I'll see if I can reproduce (it's been a while since I've looked at the code).
    Hope you get it sorted.

    Cheers,
    Sean.

  • Thanks for the promt reply.

    I'm just basically using your FakeRepository except I have added
    DateAdded = DateTime.Parse("2008-05-01 7:34:42Z")

    It works OK when you just refresh the page but if you subscribe to it in IE and keep refreshing you get a long list of repeats. This doesn't happen for other feeds.

    I note that the time visible in the feed item keeps being updated rather than staying at the DateTime.Parse("2008-05-01 7:34:42Z"). Sorry, I don't know how this mappes to AtomPub XML elements.



    Any help would be much appreciated.

    Thanks Sean.

  • Hiya, I'll build the code and take a look - must be a bug then - I'll post a comment as soon as I've worked it out.

    Cheers,
    Sean.

  • It seems to work when these lines are added to SyndicationFeedHelper AddPublishDate

    syndicationItem.LastUpdatedTime = publishDate;
    syndicationItem.Id = this.FeedItemMapper.Id.Invoke(feedItem);

    But comments and correct refactor would be appreciated.

    Thanks

  • Hi Nolan,

    It is very odd, I can't reproduce the list of repeating items but I can see that the date is being ignored on the atom feed.

    It looks like Atom display dates map to the LastUpdatedDate rather than the publish date - a fix for this would be to add the following code syndicationItem.LastUpdatedTime = syndicationItem.PublishDate; within the GetFeed method on the SydicationFeedHelper class after the AddPublishDate(feedItem, syndicationItem); line.
    Hope this solves it.
    Cheers,
    Sean.

  • I moved all below to what I believe is the correct location SyndicationFeedHelper GetFeed

    syndicationItem.LastUpdatedTime = syndicationItem.PublishDate;
    syndicationItem.Id = syndicationItem.Id;
    syndicationItem.Content = new TextSyndicationContent(this.FeedItemMapper.Content.Invoke(feedItem), TextSyndicationContentKind.XHtml);

    The first two make it so a refresh will not duplicate items and that the date diplayed in the feed will be correct.

    The last line sets the Content Type to XHtml

  • Great project! I upgraded it to VS2010 with a couple of issues.

    1. Upgrade by starting the solution file resulted in a failed conversion. Upgrade by starting the project file converted successfully.

    2. Targeting the .NET 4.0 Framework breaks the project until you add an assembly reference to the System.ServiceModel dll.

    I also like the fake respository concept for a testbed project like this. Very nice job, cutting right to the chase with a clean MVC solution.

    Thanks!

  • I create a leave a response whenever I especially enjoy a article on a website or I have something to valuable to contribute to the conversation.

    It's triggered by the sincerness communicated in the article I looked at. And on this post Create RSS and Atom feeds using custom ASP.Net MVC Action Results and the Microsoft Syndication classes - Sean McAlinden's Blog.
    I was actually excited enough to drop a thought ;-) I actually
    do have 2 questions for you if you usually do not mind.
    Could it be just me or does it look as if like some of the comments come across as if they are written
    by brain dead individuals? :-P And, if you are writing at additional online social
    sites, I'd like to keep up with you. Would you make a list all of all your community pages like your twitter feed, Facebook page or linkedin profile?

  • Hi there Dear, are you actually visiting this site regularly, if
    so after that you will without doubt get good knowledge.

Comments have been disabled for this content.