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);
}
public void Work()
{
list = new List <ClassBla>();
int i = 0;
List <string> sites = new List <string> {
"https://habr.com/rss/interesting/", "https://keddr.com/feed/"
};
foreach (string site in sites)
{
Rss20FeedFormatter feedFormatter = new Rss20FeedFormatter();
XmlReader rssReader = XmlReader.Create(site);
if (feedFormatter.CanRead(rssReader))
{
feedFormatter.ReadFrom(rssReader);
var DataContext = feedFormatter.Feed;
var feedContent = feedFormatter.Feed.Items;
foreach (var el in feedContent)
{
ClassBla obj = new ClassBla(
el.PublishDate.ToString(),
el.Id
);
list.Add(obj);
}
rssReader.Close();
}
ProcessChanged(i += 50);
}
WorkCompleted(_cancelled);
DataSave(true);
}
/// <summary>
/// Default Page Load Method
/// </summary>
/// <param name="sender">Sender of the event.</param>
/// <param name="e">Event Argument.</param>
protected void Page_Load(object sender, EventArgs e)
{
try
{
XmlReader reader = XmlReader.Create(BlogSyndicationUrl);
Rss20FeedFormatter rss = new Rss20FeedFormatter();
if (reader != null)
{
if (rss.CanRead(reader))
{
rss.ReadFrom(reader);
SyndicationItem item;
item = rss.Feed.Items.First <SyndicationItem>();
if (item != null)
{
this.latestBlogEntryTitle.Text = item.Title.Text;
this.latestBlogEntrySummary.Text = item.Summary.Text;
this.blogLink.NavigateUrl = item.Id;
this.blogFullPostLink.NavigateUrl = item.Id;
this.latestBlogPublishTime.Text = item.PublishDate.DateTime.ToString("dd-MMM-yyyy HH:mm", CultureInfo.CurrentCulture) + " " + "by" + " " + item.Authors[0].Email;
}
}
}
}
catch (WebException)
{
AppSettingsReader appsReader = new AppSettingsReader();
this.latestBlogEntrySummary.Text = appsReader.GetValue("LatestBlogAccessMessage", typeof(string)).ToString();
this.blogFullPostLink.Visible = false;
}
}
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));
}
private static void ValidateRSS(string content)
{
Rss20FeedFormatter feedFormatter = new Rss20FeedFormatter();
XmlReader rssReader = XmlReader.Create(new StringReader(content));
if (feedFormatter.CanRead(rssReader))
{
feedFormatter.ReadFrom(rssReader);
rssReader.Close();
}
}
public SyndicationFeed CanReadRss2(XmlReader xmlReader)
{
var rss = new Rss20FeedFormatter();
// try reading it as an rss feed
if (rss.CanRead(xmlReader))
{
rss.ReadFrom(xmlReader);
return(rss.Feed);
}
return(null);
}
public static void Snippet15()
{
// <Snippet15>
Rss20FeedFormatter feedFormatter = new Rss20FeedFormatter();
XmlReader rssReader = XmlReader.Create("http://Contoso/Feeds/MyFeed");
if (feedFormatter.CanRead(rssReader))
{
feedFormatter.ReadFrom(rssReader);
rssReader.Close();
}
// </Snippet15>
}
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 void CanRead()
{
Rss20FeedFormatter f = new Rss20FeedFormatter();
Assert.IsTrue(f.CanRead(CreateReader("<rss>")), "#1");
Assert.IsFalse(f.CanRead(CreateReader("<item>")), "#2");
Assert.IsFalse(f.CanRead(CreateReader("<rss xmlns='urn:foo'>")), "#3");
Assert.IsFalse(f.CanRead(CreateReader("<feed xmlns='http://www.w3.org/2005/Atom'>")), "#4");
Assert.IsFalse(f.CanRead(CreateReader("<hoge>")), "#5");
XmlReader r = CreateReader("<rss></rss>");
r.Read(); // element
r.Read(); // endelement
Assert.IsFalse(f.CanRead(r), "#6");
r = CreateReader("<rss><channel><title>test</title></channel></rss>");
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))
{
Rss20FeedFormatter rss = new Rss20FeedFormatter();
// try to read it as an atom feed
if (rss.CanRead(reader))
{
rss.ReadFrom(reader);
List <Entity> entities = new List <Entity>();
foreach (SyndicationItem item in rss.Feed.Items)
{
entities.Add(new Entity()
{
Title = item.Title.Text,
PublicationDate = item.PublishDate,
Link = item.Links[0].Uri.ToString(),
});
}
return(entities);
}
}
return(null);
}
static void Main(string[] args)
{
Rss20FeedFormatter feedFormatter = new Rss20FeedFormatter();
XmlReader rssReader = XmlReader.Create("https://habr.com/rss/interesting/");
if (feedFormatter.CanRead(rssReader))
{
feedFormatter.ReadFrom(rssReader);
var DataContext = feedFormatter.Feed;
var feedContent = feedFormatter.Feed.Items;
foreach (var el in feedContent)
{
//Дата публикации.
Console.WriteLine("Дата: {0}", el.PublishDate);
//Название статьи.
Console.WriteLine("Название: {0}", el.Title.Text);
//Описание.
Console.WriteLine("Описание: {0}", el.Summary.Text);
//Ссылка.
Console.WriteLine("Ссылка: {0}\r\n", el.Id);
}
rssReader.Close();
}
}
public bool ValidateRssFeed()
{
Rss20FeedFormatter validator = new Rss20FeedFormatter();
return(validator.CanRead(this.reader));
}
/// <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);
}
}
