public static IEnumerable <Entity> GetEntitiesFromFeed(string urlFeedLocation)
{
if (String.IsNullOrEmpty(urlFeedLocation))
{
return(null);
}
using (XmlReader reader = XmlReader.Create(urlFeedLocation))
{
Atom10FeedFormatter atom = new Atom10FeedFormatter();
// try to read it as an atom feed
if (atom.CanRead(reader))
{
atom.ReadFrom(reader);
AtomFormatter formatter = new AtomFormatter();
return(formatter.GetEntities(urlFeedLocation));
}
Rss20FeedFormatter rss = new Rss20FeedFormatter();
// try reading it as an rss feed
if (rss.CanRead(reader))
{
rss.ReadFrom(reader);
RSSFormater formatter = new RSSFormater();
return(formatter.GetEntities(urlFeedLocation));
}
//add new custom formatters
}
return(null);
}
static void FetchFeed(DateTime start, DateTime end)
{
Atom10FeedFormatter feedFormatter = new Atom10FeedFormatter();
int counter = 0;
int page = 1;
while (counter < 100)
{
var url = feedURL + "?page=" + page;
XmlReader atomReader = XmlReader.Create(url);
if (feedFormatter.CanRead(atomReader))
{
feedFormatter.ReadFrom(atomReader);
atomReader.Close();
}
foreach (SyndicationItem item in feedFormatter.Feed.Items)
{
counter++;
if (item.PublishDate > start && item.PublishDate < end)
{
Console.WriteLine("[{0}][{1}] {2}", item.PublishDate, item.Title.Text, item.Id);
blogReport.Add(new ReportEntry {
Title = item.Title.Text, Date = item.PublishDate.LocalDateTime, URL = item.Id
});
}
if (item.PublishDate < start)
{
return;
}
}
page++;
}
}
public static async Task <SyndicationFeed> LoadAsync(XmlReader reader, Rss20FeedFormatter Rssformatter, Atom10FeedFormatter Atomformatter, CancellationToken ct)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
XmlReaderWrapper wrappedReader = XmlReaderWrapper.CreateFromReader(reader);
Atom10FeedFormatter atomSerializer = Atomformatter;
if (atomSerializer.CanRead(wrappedReader))
{
await atomSerializer.ReadFromAsync(wrappedReader, new CancellationToken());
return(atomSerializer.Feed);
}
Rss20FeedFormatter rssSerializer = Rssformatter;
if (rssSerializer.CanRead(wrappedReader))
{
await rssSerializer.ReadFromAsync(wrappedReader, new CancellationToken());
return(rssSerializer.Feed);
}
throw new XmlException(string.Format(SR.UnknownFeedXml, wrappedReader.LocalName, wrappedReader.NamespaceURI));
}
public SyndicationFeed CanReadAtom(XmlReader xmlReader)
{
var atom = new Atom10FeedFormatter();
// try to read it as an atom feed
if (atom.CanRead(xmlReader))
{
atom.ReadFrom(xmlReader);
return(atom.Feed);
}
return(null);
}
public static void Snippet12()
{
// <Snippet12>
Atom10FeedFormatter feedFormatter = new Atom10FeedFormatter();
XmlReader atomReader = XmlReader.Create("http://Contoso/Feeds/MyFeed");
if (feedFormatter.CanRead(atomReader))
{
feedFormatter.ReadFrom(atomReader);
atomReader.Close();
}
// </Snippet12>
}
public override T ConvertToObject <T>(String xml)
{
StringReader sr = new StringReader(xml);
XmlReader reader = XmlReader.Create(sr);
Atom10FeedFormatter atom = new Atom10FeedFormatter();
if (!atom.CanRead(reader))
{
throw new Exception("Mallformed Atom xml");
}
SyndicationFeedFormatter formatter = atom;
formatter.ReadFrom(reader);
SyndicationFeed feed = formatter.Feed;
StringBuilder sb = new StringBuilder();
XmlWriter writer = XmlWriter.Create(sb);
XmlDocument doc = new XmlDocument();
XmlElement ele = doc.CreateElement("entry");
ele.WriteTo(writer);
foreach (var entry in feed.Items)
{
SyndicationContent content = entry.Content;
if (writer != null)
{
content.WriteTo(writer, "entry", "");
}
}
doc.LoadXml(sb.ToString());
/*
* switch (typeof(T).Name)
* {
* case "Activity":
* return ConvertActivities(doc);
* case "DataCollection":
* return ConvertAppData(doc);
* case "Message":
* return ConvertMessages(doc);
* case "Person":
* return ConvertPeople(doc);
* }
* */
throw new NotImplementedException();
return(default(T));
}
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);
}
}
/// <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);
}
private SyndicationFeed GetFeed(string url)
{
using (XmlReader reader = XmlReader.Create(url))
{
Rss20FeedFormatter rss = new Rss20FeedFormatter();
if (rss.CanRead(reader))
{
rss.ReadFrom(reader);
return(rss.Feed);
}
Atom10FeedFormatter atom = new Atom10FeedFormatter();
if (atom.CanRead(reader))
{
atom.ReadFrom(reader);
return(atom.Feed);
}
}
return(null);
}
public string CheckForUpdates(string feedUrl)
{
try
{
Atom10FeedFormatter formatter = new Atom10FeedFormatter();
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.DtdProcessing = DtdProcessing.Parse;
XmlReader reader = XmlReader.Create(feedUrl, readerSettings);
if (!formatter.CanRead(reader))
{
return(null);
}
formatter.ReadFrom(reader);
var currentVersion = Assembly.GetExecutingAssembly().GetName().Version;
var update = (from i in formatter.Feed.Items
where new Version(i.Title.Text) > currentVersion
orderby i.LastUpdatedTime descending
select i).FirstOrDefault();
if (update != null)
{
return(update.Links.Single().Uri.ToString());
}
else
{
return(null);
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("MinidumpExplorer: Update check failed: " + ex.ToString());
return(null);
}
}
public void CanRead()
{
Atom10FeedFormatter f = new Atom10FeedFormatter();
Assert.IsTrue(f.CanRead(CreateReader("<feed xmlns='http://www.w3.org/2005/Atom'>")), "#1");
Assert.IsFalse(f.CanRead(CreateReader("<item xmlns='http://www.w3.org/2005/Atom'>")), "#2");
Assert.IsFalse(f.CanRead(CreateReader("<feed xmlns='urn:foo'>")), "#3");
Assert.IsFalse(f.CanRead(CreateReader("<feed>")), "#4");
Assert.IsFalse(f.CanRead(CreateReader("<hoge>")), "#5");
XmlReader r = CreateReader("<feed xmlns='http://www.w3.org/2005/Atom'></feed>");
r.Read(); // element
r.Read(); // endelement
Assert.IsFalse(f.CanRead(r), "#6");
r = CreateReader("<feed xmlns='http://www.w3.org/2005/Atom'><title>test</title></feed>");
r.Read(); // feed
r.Read(); // channel
Assert.IsFalse(f.CanRead(r), "#7");
}
public static async Task <TSyndicationFeed> LoadAsync <TSyndicationFeed>(XmlReader reader, CancellationToken ct)
where TSyndicationFeed : SyndicationFeed, new()
{
Atom10FeedFormatter <TSyndicationFeed> atomSerializer = new Atom10FeedFormatter <TSyndicationFeed>();
if (atomSerializer.CanRead(reader))
{
await atomSerializer.ReadFromAsync(reader, ct);
return(atomSerializer.Feed as TSyndicationFeed);
}
Rss20FeedFormatter <TSyndicationFeed> rssSerializer = new Rss20FeedFormatter <TSyndicationFeed>();
if (rssSerializer.CanRead(reader))
{
await rssSerializer.ReadFromAsync(reader, ct);
return(rssSerializer.Feed as TSyndicationFeed);
}
throw new XmlException(string.Format(SR.UnknownFeedXml, reader.LocalName, reader.NamespaceURI));
}
public IEnumerable <Entity> GetEntities(string urlFeedLocation)
{
using (XmlReader reader = XmlReader.Create(urlFeedLocation))
{
Atom10FeedFormatter atom = new Atom10FeedFormatter();
// try to read it as an atom feed
if (atom.CanRead(reader))
{
atom.ReadFrom(reader);
List <Entity> entities = new List <Entity>();
foreach (SyndicationItem item in atom.Feed.Items)
{
entities.Add(new Entity()
{
Title = item.Title.Text,
PublicationDate = item.PublishDate,
Link = item.Links[0].Uri.ToString(),
});
}
return(entities);
}
}
return(null);
}
/// <summary>
/// Gets an RSS feed from a given URL and returns the resulting XML as a string.
/// </summary>
/// <param name="url">URL of the feed to load.</param>
/// <param name="count">The count of postings to return.</param>
/// <returns>The feed XML as a string.</returns>
public SyndicationFeed GetFeed(string url, int count)
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreWhitespace = true;
settings.CheckCharacters = true;
settings.CloseInput = true;
settings.IgnoreComments = true;
settings.IgnoreProcessingInstructions = true;
settings.ProhibitDtd = false;
using (XmlReader reader = XmlReader.Create(url, settings))
{
SyndicationFeedFormatter formatter = null;
Atom10FeedFormatter atom = new Atom10FeedFormatter();
Rss20FeedFormatter rss = new Rss20FeedFormatter();
SyndicationFeed feed;
// Determine the format of the feed
if (reader.ReadState == ReadState.Initial)
{
reader.MoveToContent();
}
if (atom.CanRead(reader))
{
formatter = atom;
}
if (rss.CanRead(reader))
{
formatter = rss;
}
if (formatter == null)
{
return(null);
}
formatter.ReadFrom(reader);
feed = formatter.Feed;
// Remove unwanted items
List <SyndicationItem> items = new List <SyndicationItem>();
int added = 0;
foreach (SyndicationItem i in feed.Items)
{
items.Add(i);
if (added++ == count - 1)
{
break;
}
}
feed.Items = items;
return(feed);
}
}
