RSS.NET impossible d'analyser les flux feedburner

Question

J'utilise RSS.NET pour .NET 2.0. Essayez que je pourrais, je reçois 0 canaux pour les éléments suivants:

feed = RssFeed.Read("http://feeds.feedburner.com/punchfire?format=xml"); 

Je note que pour d'autres flux cela fonctionne par exemple

feed = RssFeed.Read("http://www.engadget.com/rss.xml"); 

Je suppose qu'il doit être un valide le document XML. Pensez-vous que je devrais vérifier pour ".xml" dans mon code d'application ou est-il un moyen de tordre RSS.NET en acceptant feedburner flux?

Answer 1

La raison pour laquelle vous ne pouvez obtenir aucun noeud de canal est que le format atom n'a aucun noeud de canal. vérifier suivant

• The Atom Syndication Format

Votre deuxième liaison est un fil Rss, qui contient le noeud de canal comme ce qui suit

<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd"> 
<channel> 
<title>Engadget</title> 
<link>http://www.engadget.com</link> 
. 
. 
. 

D'autre part un flux d'atomes ne pas utiliser le canal nœuds, comme vous pouvez le comprendre en suivant le lien de spécification ci-dessus.

<?xml version="1.0" encoding="utf-8"?> 
    <feed xmlns="http://www.w3.org/2005/Atom"> 
    <title type="text">dive into mark</title> 
    <subtitle type="html"> 
     A &lt;em&gt;lot&lt;/em&gt; of effort 
     went into making this effortless 
    </subtitle> 
    <updated>2005-07-31T12:29:29Z</updated> 
    <id>tag:example.org,2003:3</id> 
    <link rel="alternate" type="text/html" 
     hreflang="en" href="http://example.org/"/> 
    <link rel="self" type="application/atom+xml" 
     href="http://example.org/feed.atom"/> 
    <rights>Copyright (c) 2003, Mark Pilgrim</rights> 
    <generator uri="http://www.example.com/" version="1.0"> 
     Example Toolkit 
    </generator> 
    <entry> 
     . 
     . 
     . 

EDIT: Pour vérifier l'alimentation Format

// url of the feed 
    string utlToload = @"http://feeds.feedburner.com/punchfire?format=xml" 



    // load feed 
     Argotic.Syndication.GenericSyndicationFeed feed = 
Argotic.Syndication.GenericSyndicationFeed.Create(new Uri(urlToLoad)); 

     // check what format is it 
     if (feed.Format.Equals(SyndicationContentFormat.Rss)) 
     { 
      // yourlogic here 
     } 
     else if (feed.Format.Equals(SyndicationContentFormat.Atom)) 
     { 
      // yourlogic here 
     } 
     else if (feed.Format.Equals(SyndicationContentFormat.NewsML)) 
     { 
      // yourlogic here 
     } 

Hope it helps

Answer 2

http://feeds.feedburner.com/punchfire?format=xml semble être un flux Atom, pas RSS. Rss.net sait-il gérer cela?

Answer 3

Avec .Net 3.5+, il est très facile à analyser flux Atom. Les flux BTW Atom sont la nouvelle norme pour RSS que j'entends.

public class RssFeedDO 
{ 
    public string RssFeedUrl { get; private set; } 

    /// <summary> 
    /// Build feed processor 
    /// </summary> 
    /// <param name="feedUrl">Atom or RSS url with http in front.</param> 
    public RssFeedDO(string feedUrl) 
    { 
     this.RssFeedUrl = feedUrl; 
    } 

    /// <summary> 
    /// Will try to get RSS data from url passed in constructor. Can do atom or rss 
    /// </summary> 
    /// <returns></returns> 
    public SyndicationFeed GetRSSData() 
    { 
     SyndicationFeed feed = null; 

     XmlReaderSettings settings = new XmlReaderSettings(); 
     settings.IgnoreWhitespace = true; 
     settings.CheckCharacters = true; 
     settings.CloseInput = true; 
     settings.IgnoreComments = true; 
     settings.IgnoreProcessingInstructions = true; 
     settings.DtdProcessing = DtdProcessing.Prohibit; 

     if (!string.IsNullOrEmpty(this.RssFeedUrl)) 
     { 
      using (XmlReader reader = XmlReader.Create(this.RssFeedUrl, settings)) 
      { 
       SyndicationFeedFormatter GenericFeedFormatter = null; 
       Atom10FeedFormatter atom = new Atom10FeedFormatter(); 
       Rss20FeedFormatter rss = new Rss20FeedFormatter(); 

       if (reader.ReadState == ReadState.Initial) 
       { 
        reader.MoveToContent(); 
       } 
       // try either atom or rss reading 
       if (atom.CanRead(reader)) 
       { 
        GenericFeedFormatter = atom; 
       } 
       if (rss.CanRead(reader)) 
       { 
        GenericFeedFormatter = rss; 
       } 
       if (GenericFeedFormatter == null) 
       { 
        return null; 
       } 
       GenericFeedFormatter.ReadFrom(reader); 
       feed = GenericFeedFormatter.Feed; 
      } 
     } 
     return feed; 
    } 
} 

Maintenant, vous pourriez indiquer une source de données d'objets à la classe ci-dessus, puis eval certaines choses dans votre ListView ou RadGrid comme ceci:

<%# Eval("Title.Text") %> 

Testé avec un feedburner couple se nourrit et il a bien fonctionné.

Answer 4

J'ai amélioré un peu le code de JamesR, qui renvoie maintenant un booléen de succès et accepte un objet de syndicationfeed ByRef;

public static class FeedParser 
{ 
    public static bool Parse(string url, ref SyndicationFeed feed) 
    { 
     XmlReaderSettings settings = new XmlReaderSettings(); 
     settings.IgnoreWhitespace = true; 
     settings.CheckCharacters = true; 
     settings.CloseInput = true; 
     settings.IgnoreComments = true; 
     settings.IgnoreProcessingInstructions = true; 
     settings.DtdProcessing = DtdProcessing.Prohibit; 

     if (string.IsNullOrEmpty(url)) return false; 

     using (XmlReader reader = XmlReader.Create(url, settings)) 
     { 
      SyndicationFeedFormatter formatter = null; 
      Atom10FeedFormatter atom_formatter = new Atom10FeedFormatter(); 
      Rss20FeedFormatter rss_formatter = new Rss20FeedFormatter(); 

      if (reader.ReadState == ReadState.Initial) reader.MoveToContent(); 

      if (atom_formatter.CanRead(reader)) formatter = atom_formatter; 
      if (rss_formatter.CanRead(reader)) formatter = rss_formatter; 
      if (formatter == null) return false; 

      formatter.ReadFrom(reader); 
      feed = formatter.Feed; 

      return true; 
     } 
    }   
} 

qui peut être utilisé comme;

SyndicationFeed feed=null; 

    if(FeedParser.Parse(url,ref feed)) 
    { 

    }