public async override Task <RokuFeedParserModel> ParseContent()
{
RokuFeedParserModel parserModel = new RokuFeedParserModel()
{
SyndicationItems = new List <ISyndicationItem>()
};
using (XmlReader xmlReader = XmlReader.Create(FeedURL, new XmlReaderSettings()
{
Async = true
}))
{
var reader = new RssFeedReader(xmlReader);
while (await reader.Read())
{
switch (reader.ElementType)
{
case SyndicationElementType.Item:
parserModel.SyndicationItems.Add(await reader.ReadItem());
break;
}
}
}
return(parserModel);
}
public async Task <List <TEntry> > GetFeedAsync(
Uri uri,
Func <ISyndicationItem, TEntry> convert,
Func <TEntry, object> property,
SortOrder order = SortOrder.Descending)
{
Guard.Against.Null(uri, nameof(uri));
Guard.Against.Null(convert, nameof(convert));
Guard.Against.Null(property, nameof(uri));
var feedItems = new List <TEntry>();
using var xmlReader = XmlReader.Create(uri.OriginalString, new XmlReaderSettings { Async = true });
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
if (feedReader.ElementType != SyndicationElementType.Item)
{
continue;
}
var item = await feedReader.ReadItem();
feedItems.Add(convert(item));
}
return(order == SortOrder.Ascending
? feedItems.OrderBy(property).ToList()
: feedItems.OrderByDescending(property).ToList());
}
private async Task <Item[]> LoadItemsAsync(RSSFeed feed)
{
using (var xmlReader = XmlReader.Create(feed.Uri))
{
var items = new List <Item>();
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
if (feedReader.ElementType != SyndicationElementType.Item)
{
continue;
}
var feedItem = await feedReader.ReadItem();
items.Add(new Item
{
Title = feedItem.Title,
Link = feedItem.Links.FirstOrDefault()?.Uri?.ToString(),
Description = feedItem.Description,
Author = feedItem.Contributors.FirstOrDefault()?.Email,
PublishedAt = feedItem.Published.DateTime
});
}
return(items.ToArray());
}
}
public async Task <List <RssItem> > GetNewsFeed()
{
var rssNewsItems = new List <RssItem>();
using (var xmlReader = XmlReader.Create(_FeedUri, new XmlReaderSettings()
{
Async = true
}))
{
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
if (feedReader.ElementType == Microsoft.SyndicationFeed.SyndicationElementType.Item)
{
var xmlStr = await feedReader.ReadElementAsString();
XmlSerializer deserializer = new XmlSerializer(typeof(RssItem));
using (TextReader reader = new StringReader(xmlStr))
{
var xmlitem = (RssItem)deserializer.Deserialize(reader);
rssNewsItems.Add(xmlitem);
}
}
}
}
return(rssNewsItems);
}
public async Task <IEnumerable <BlogPost> > GetBlogPosts()
{
var xmlReader = Task.Run(() => XmlReader.Create("https://knowledge-base.havit.cz/feed/"));
var rssReader = new RssFeedReader(await xmlReader);
var blogPosts = new List <BlogPost>();
while (await rssReader.Read())
{
if (rssReader.ElementType == SyndicationElementType.Item)
{
var item = await rssReader.ReadItem();
blogPosts.Add(new BlogPost()
{
Title = item.Title,
Author = item.Contributors.FirstOrDefault()?.Name,
Created = item.Published.LocalDateTime,
Description = item.Description,
Link = item.Links.FirstOrDefault()?.Uri.AbsoluteUri
});
}
}
return(blogPosts);
}
private async Task <string> GetNextFeedItem(Server server)
{
var items = new List <string>();
using (var reader = XmlReader.Create(_configurationHandler.Configuration().FeedUrl, new XmlReaderSettings()
{
Async = true
}))
{
var feedReader = new RssFeedReader(reader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
var item = await feedReader.ReadItem();
items.Add(Regex.Replace(item.Title, @"\<.+\>.*\</.+\>", ""));
break;
}
}
}
if (_currentFeedItem < items.Count && (_configurationHandler.Configuration().MaxFeedItems == 0 || _currentFeedItem < _configurationHandler.Configuration().MaxFeedItems))
{
_currentFeedItem++;
return(items[_currentFeedItem - 1]);
}
_currentFeedItem = 0;
return(Utilities.CurrentLocalization.LocalizationIndex["PLUGINS_AUTOMESSAGEFEED_NO_ITEMS"]);
}
public async Task <IActionResult> Get()
{
var feedUri = "http://www.dailyherald.com/rss/feed/?feed=news_top10";
var rssNewsItems = new List <FeedItem>();
using (var xmlReader = XmlReader.Create(feedUri, new XmlReaderSettings()
{
Async = true
}))
{
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
if (feedReader.ElementType == SyndicationElementType.Item)
{
ISyndicationItem item = await feedReader.ReadItem();
rssNewsItems.Add(item.ConvertToNewsItem());
}
}
}
var articlesByDate = rssNewsItems.OrderByDescending(p => p.PublishDate).ToArray();
return(Ok(articlesByDate));
}
private static async Task <List <SyndicationItem> > GetItemFeed()
{
var ItemFeed = new List <SyndicationItem>();
using (var http = new HttpClient())
{
var strFeed = await http.GetStringAsync("http://www.minutoseguros.com.br/blog/feed/");
if (!string.IsNullOrWhiteSpace(strFeed))
{
using (var xmlReader = XmlReader.Create(new StringReader(strFeed)))
{
xmlReader.Read();
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
ISyndicationItem item = await feedReader.ReadItem();
ItemFeed.Add((SyndicationItem)item);
break;
}
}
}
}
}
return(ItemFeed);
}
public async Task <IEnumerable <TorrentRSSItem> > GetTorrentsFromRSS()
{
var links = new List <TorrentRSSItem>();
var content = await GetWebPage(this.URL);
if (!string.IsNullOrEmpty(content))
{
using (var stringReader = new StringReader(content))
using (var xmlReader = XmlReader.Create(stringReader, new XmlReaderSettings()
{
Async = true, DtdProcessing = DtdProcessing.Parse
}))
{
var feedReader = new RssFeedReader(xmlReader, new TorrentRSSParser());
while (await feedReader.Read())
{
if (feedReader.ElementType == SyndicationElementType.Item)
{
var item = (TorrentRSSItem)await feedReader.ReadItem();
links.Add(item);
}
}
}
}
return(links);
}
private async void LoadVideoFeed()
{
var rssurl = @"https://www.youtube.com/feeds/videos.xml?channel_id=UCOWs5Rx9ot7p10mqYyzjyUA";
using (var reader = XmlReader.Create(rssurl))
{
var feedReader = new RssFeedReader(reader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
var item = await feedReader.ReadItem();
var youtubeID = item.Id.Replace("yt:video:", "");
var url = "https://www.youtube.com/watch?v=" + youtubeID;
var image = await SaveThumbnail(youtubeID);
_videoFeed.Add(new VideoFeedViewModel(url, item.Title, image));
break;
}
}
}
}
public async Task <List <SyndicationItem> > GetNewsAsync(string url)
{
var items = new List <SyndicationItem>();
using (var xmlReader = XmlReader.Create(url, new XmlReaderSettings {
Async = true
}))
{
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
ISyndicationItem item = await feedReader.ReadItem();
items.Add(new SyndicationItem(item));
break;
default:
break;
}
}
}
await Task.Delay(5000);
return(items);
}
public async Task <FeedEntity> GetFeedAsyc(string url, string userId)
{
var feed = new FeedEntity(userId);
feed.Items = new List <FeedItemEntity>();
feed.Url = url;
using (var httpClient = _httpClientFactory.CreateClient())
{
var stream = await httpClient.GetStreamAsync(url);
using (var xmlReader = XmlReader.Create(stream, new XmlReaderSettings()
{
Async = true
}))
{
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Category:
case SyndicationElementType.Person:
case SyndicationElementType.Link:
break;
case SyndicationElementType.Item:
var item = await feedReader.ReadItem();
var feedItem = new FeedItemEntity(feed.Id);
feedItem.Title = item.Title;
feedItem.Content = item.Description;
feedItem.Url = item.Links.FirstOrDefault()?.Uri.ToString();
feed.Items.Add(feedItem);
break;
case SyndicationElementType.Image:
var image = await feedReader.ReadImage();
feed.Image = image.Url.ToString();
break;
default:
var content = await feedReader.ReadContent();
if (content.Name.Equals("title", StringComparison.OrdinalIgnoreCase))
{
feed.Title = content.Value;
}
if (content.Name.Equals("description", StringComparison.OrdinalIgnoreCase))
{
feed.Description = content.Value;
}
break;
}
}
}
}
return(feed);
}
public async Task <List <Article> > GetArticlesFromFeed(Feed feed)
{
List <Article> articles = new List <Article>();
using (XmlReader xmlReader = XmlReader.Create(feed.FeedUrl, new XmlReaderSettings()
{
Async = true
}))
{
var reader = new RssFeedReader(xmlReader);
while (await reader.Read())
{
if (reader.ElementType == SyndicationElementType.Item)
{
var content = await reader.ReadContent();
var article = mapArticle(content);
article.FeedId = feed.FeedId;
articles.Add(article);
}
}
}
return(articles);
}
public async Task <List <SyndicationItem> > GetNewsAsync()
{
var items = new List <SyndicationItem>();
using (var xmlReader = XmlReader.Create("http://scripting.com/rss.xml", new XmlReaderSettings {
Async = true
}))
{
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
ISyndicationItem item = await feedReader.ReadItem();
items.Add(new SyndicationItem(item));
break;
default:
break;
}
}
}
return(items);
}
public async Task <NewsArticle[]> GetNewsFeedAsync(string feed)
{
var rssNewsItems = new List <NewsArticle>();
using (var xmlReader = XmlReader.Create(feed, new XmlReaderSettings()
{
Async = true
}))
{
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read().ConfigureAwait(false))
{
if (feedReader.ElementType == SyndicationElementType.Item)
{
ISyndicationItem item = await feedReader.ReadItem().ConfigureAwait(false);
var lcTitle = item.Title.ToLower();
if (lcTitle.Contains("covid") || lcTitle.Contains("corona"))
{
rssNewsItems.Add(new NewsArticle()
{
Title = item.Title.ToString(),
Excerpt = item.Description.ToString(),
PublishDate = item.Published.DateTime,
Uri = item.Links.FirstOrDefault().Uri //.AbsoluteUri for string
});
}
}
}
}
return(rssNewsItems.OrderByDescending(p => p.PublishDate).ToArray());
}
public static async Task <List <ISyndicationContent> > RssFeedReader()
{
///Wired Sitesindeki Rss beslemesinden son haberlerin linklerini ve başlıklarını çekiyoruz
string feedUri = "https://www.wired.com/feed/rss";
List <ISyndicationContent> contentList = new List <ISyndicationContent>();
using (var xmlReader = XmlReader.Create(feedUri, new XmlReaderSettings()
{
Async = true
}))
{
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
ISyndicationContent content = await feedReader.ReadContent();
if (content.Name == "item")
{
contentList.Add(content);
}
}
}
return(contentList);
}
public async Task <FeedItem[]> GetNewsFeed(CancellationToken cancelToken)
{
if (cancelToken.IsCancellationRequested)
{
var rssFeedItems = new List <FeedItem>();
using (var xmlReader = XmlReader.Create(_FeedUri, new XmlReaderSettings()
{
Async = true
}))
{
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read().ConfigureAwait(false))
{
if (feedReader.ElementType == Microsoft.SyndicationFeed.SyndicationElementType.Item)
{
ISyndicationItem item = await feedReader.ReadItem().ConfigureAwait(false);
rssFeedItems.Add(item.ConvertToNewsItem());
}
}
}
return(rssFeedItems.OrderByDescending(p => p.PublishDate).ToArray());
}
else
{
return(null);
}
}
public async Task <Publication> Run(
[ActivityTrigger] PublicationConfiguration publicationConfiguration,
ILogger logger)
{
logger.LogInformation($"Started {nameof(GetLatestPublicationFromWebActivity)} for { publicationConfiguration.PublicationSourceOwner } { publicationConfiguration.PublicationSourceName}.");
Publication publication = new NullPublication(publicationConfiguration.PublicationSourceName);
using (var xmlReader = XmlReader.Create(publicationConfiguration.PublicationSourceUrl, new XmlReaderSettings()
{
Async = true
}))
{
var parser = new RssParser();
var reader = new RssFeedReader(xmlReader, parser);
while (await reader.Read())
{
if (reader.ElementType == SyndicationElementType.Item)
{
ISyndicationItem item = await reader.ReadItem();
publication = MapToPublication(publicationConfiguration, item);
break;
}
}
}
logger.LogInformation($"Found publication on web for {publicationConfiguration.PublicationSourceName}: " +
$"ID: {publication.Id}," +
$"Date: {publication.PublicationDate:F}.");
return(publication);
}
public async Task <Pack> GetPack(List <string> usernames)
{
var client = new HttpClient();
var authService = new AuthService(null, 0);
var users = usernames.Select(username => new User
{
Id = username,
Username = username,
Email = username + "@mail.com",
Password = authService.HashPassword(username + username),
}
).ToList();
var urls = usernames.Select(username => FEEDS_URL + "@" + username);
var feedStrings = await Task.WhenAll(
urls.Select(async url => await client.GetStringAsync(url))
);
var storiesList = await Task.WhenAll(
feedStrings.Select(async(feedString, feedIndex) => {
using (var xmlReader = XmlReader.Create(new StringReader(feedString)))
{
var stories = new List <Story>();
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
var type = feedReader.ElementType;
if (type == SyndicationElementType.Item)
{
var item = await feedReader.ReadItem();
var time = item.Published.ToUnixTimeSeconds();
var story = new Story
{
Id = Guid.NewGuid().ToString(),
Title = item.Title,
Content = BASIC_CONTENT.Replace("TITLE", item.Title),
Tags = item.Categories.Select(c => c.Name).ToList(),
CreationTime = time,
LastEditTime = time,
PublishTime = time,
Draft = false,
OwnerId = users[feedIndex].Id
};
stories.Add(story);
}
}
return(stories);
}
})
);
var pack = new Pack
{
Users = users,
Stories = storiesList.SelectMany(s => s).ToList()
};
return(pack);
}
public static async Task <List <ComplexSyndication> > Get(params Uri[] url)
{
var parser = new RssParser();
var toBeProcessed = new List <Task <HttpResponseMessage> >();
var httpClient = HttpClientFactory.Get();
foreach (var u in url)
{
var t = httpClient.GetAsync(u);
toBeProcessed.Add(t);
}
Task.WaitAll(toBeProcessed.ToArray());
var syndications = new List <ComplexSyndication>();
foreach (var result in toBeProcessed)
{
var res = result.Result;
var resultContent = await res.Content.ReadAsStringAsync();
using (var xmlReader = XmlReader.Create(new MemoryStream(Encoding.UTF8.GetBytes(resultContent))))
{
var feedReader = new RssFeedReader(xmlReader);
var syndication = new ComplexSyndication();
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
//ISyndicationContent is a raw representation of the feed
ISyndicationContent content = await feedReader.ReadContent();
ISyndicationItem item = parser.CreateItem(content);
ISyndicationContent outline = content.Fields.FirstOrDefault(f => f.Name == "source:outline");
var i = new ComplexSyndicationItem(item, outline);
Replay.OnNext(i);
syndication.Items.Add(i);
break;
default:
break;
}
}
syndications.Add(syndication);
}
}
Replay.OnCompleted();
return(syndications);
}
// Read an RssFeed
public static async Task CreateRssFeedReaderExample(string filePath)
{
// Create an XmlReader
// Example: ..\tests\TestFeeds\rss20-2items.xml
using (var xmlReader = XmlReader.Create(filePath, new XmlReaderSettings()
{
Async = true
}))
{
// Instantiate an Rss20FeedReader using the XmlReader.
// This will assign as default an Rss20FeedParser as the parser.
var feedReader = new RssFeedReader(xmlReader);
//
// Read the feed
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
// Read category
case SyndicationElementType.Category:
ISyndicationCategory category = await feedReader.ReadCategory();
break;
// Read Image
case SyndicationElementType.Image:
ISyndicationImage image = await feedReader.ReadImage();
break;
// Read Item
case SyndicationElementType.Item:
ISyndicationItem item = await feedReader.ReadItem();
break;
// Read link
case SyndicationElementType.Link:
ISyndicationLink link = await feedReader.ReadLink();
break;
// Read Person
case SyndicationElementType.Person:
ISyndicationPerson person = await feedReader.ReadPerson();
break;
// Read content
default:
ISyndicationContent content = await feedReader.ReadContent();
break;
}
}
}
}
public override async Task <RSSEntity> GetEntityAsync()
{
try
{
var client = new HttpClient();
var stream = await client.GetStreamAsync(_feed);
using (XmlReader reader = XmlReader.Create(stream))
{
var feedReader = new RssFeedReader(reader);
var result = new RSSEntity();
result.Items = new List <RSSEntityItem>();
while (await feedReader.Read() && result.Items.Count <= 3)
{
switch (feedReader.ElementType)
{
// Read category
case SyndicationElementType.Category:
//DON't Care about categories ISyndicationCategory category = await feedReader.ReadCategory();
break;
// Read Image
case SyndicationElementType.Image:
//DON't Care about images ISyndicationImage image = await feedReader.ReadImage();
break;
// Read Item
case SyndicationElementType.Item:
ISyndicationItem item = await feedReader.ReadItem();
result.Items.Add(new RSSEntityItem {
Title = item.Title, Summary = item.Description, Link = item.Links.FirstOrDefault().Uri.ToString()
});
break;
// Read link
case SyndicationElementType.Link:
//DON't Care aboutISyndicationLink link = await feedReader.ReadLink();
break;
// Read Person
case SyndicationElementType.Person:
//DON't Care about ISyndicationPerson person = await feedReader.ReadPerson();
break;
// Read content
default:
//DON't Care about ISyndicationContent content = await feedReader.ReadContent();
break;
}
}
return(result);
}
}
catch (Exception) { throw; }
}
private async Task <bool> retrievePosts(Feed feed)
{
using (var xmlReader = XmlReader.Create("https://azurecomcdn.azureedge.net/en-us/blog/feed/", new XmlReaderSettings()
{
Async = true
}))
{
// Instantiate an Rss20FeedReader using the XmlReader.
// This will assign as default an Rss20FeedParser as the parser.
var feedReader = new RssFeedReader(xmlReader);
//
// Read the feed
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
// Read category
case SyndicationElementType.Category:
ISyndicationCategory category = await feedReader.ReadCategory();
break;
// Read Image
case SyndicationElementType.Image:
ISyndicationImage image = await feedReader.ReadImage();
break;
// Read Item
case SyndicationElementType.Item:
ISyndicationItem item = await feedReader.ReadItem();
break;
// Read link
case SyndicationElementType.Link:
ISyndicationLink link = await feedReader.ReadLink();
break;
// Read Person
case SyndicationElementType.Person:
ISyndicationPerson person = await feedReader.ReadPerson();
break;
// Read content
default:
ISyndicationContent content = await feedReader.ReadContent();
break;
}
}
}
return(true);
}
public static async Task TestReadFeedElements(XmlReader outerXmlReader)
{
using (var xmlReader = outerXmlReader)
{
var reader = new RssFeedReader(xmlReader);
int items = 0;
while (await reader.Read())
{
switch (reader.ElementType)
{
case SyndicationElementType.Person:
ISyndicationPerson person = await reader.ReadPerson();
Assert.True(person.Email == "John Smith");
break;
case SyndicationElementType.Link:
ISyndicationLink link = await reader.ReadLink();
Assert.True(link.Length == 123);
Assert.True(link.MediaType == "testType");
Assert.True(link.Uri.OriginalString == "http://example.com/");
break;
case SyndicationElementType.Image:
ISyndicationImage image = await reader.ReadImage();
Assert.True(image.Title == "Microsoft News");
Assert.True(image.Description == "Test description");
Assert.True(image.Url.OriginalString == "http://2.bp.blogspot.com/-NA5Jb-64eUg/URx8CSdcj_I/AAAAAAAAAUo/eCx0irI0rq0/s1600/bg_Microsoft_logo3-20120824073001907469-620x349.jpg");
break;
case SyndicationElementType.Item:
items++;
ISyndicationItem item = await reader.ReadItem();
if (items == 1)
{
Assert.True(item.Title == "Lorem ipsum 2017-07-06T20:25:00+00:00");
Assert.True(item.Description == "Exercitation sit dolore mollit et est eiusmod veniam aute officia veniam ipsum.");
Assert.True(item.Links.Count() == 3);
}
else if (items == 2)
{
Assert.True(item.Title == "Lorem ipsum 2017-07-06T20:24:00+00:00");
Assert.True(item.Description == "Do ipsum dolore veniam minim est cillum aliqua ea.");
Assert.True(item.Links.Count() == 3);
}
break;
default:
break;
}
}
}
}
private async Task <List <NewsItem> > GetFeedInternal()
{
var opml = XDocument.Load(_config.OpmlFile);
var feedData = from item in opml.Descendants("outline")
select new
{
Source = (string)item.Attribute("title"),
XmlUrl = (string)item.Attribute("xmlUrl")
};
var feed = new List <NewsItem>();
foreach (var currentFeed in feedData)
{
using (var xmlReader = XmlReader.Create(currentFeed.XmlUrl, new XmlReaderSettings()
{
Async = true
}))
{
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
if (feedReader.ElementType == SyndicationElementType.Item)
{
ISyndicationItem item = await feedReader.ReadItem();
if (string.IsNullOrWhiteSpace(item.Description) ||
!item.Links.First().Uri.IsAbsoluteUri)
{
continue;
}
var uri = item.Links.First().Uri.AbsoluteUri;
try
{
feed.Add(new NewsItem
{
Title = item.Title,
Uri = uri,
Excerpt = item.Description.PlainTextTruncate(120),
PublishDate = item.Published.UtcDateTime,
Source = currentFeed.Source ?? item.Contributors.First().Name ?? item.Contributors.First().Email,
NewsType = GetNewsTypeForUri(uri)
});
}
catch (Exception ex)
{
_log.LogError(ex.ToString());
}
}
}
}
}
return(feed.OrderByDescending(f => f.PublishDate).ToList());
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger, IConfiguration configuration)
{
//These are the four default services available at Configure
app.Run(async context =>
{
var items = new List <SyndicationItem>();
using (var xmlReader = XmlReader.Create("http://scripting.com/rss.xml", new XmlReaderSettings {
Async = true
}))
{
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
ISyndicationItem item = await feedReader.ReadItem();
items.Add(new SyndicationItem(item));
break;
default:
break;
}
}
}
var str = new StringBuilder();
str.Append("<ul>");
foreach (var i in items)
{
str.Append($"<li>{i.Description}</li>");
}
str.Append("</ul>");
context.Response.Headers.Add("Content-Type", "text/html");
await context.Response.WriteAsync($@"
<html>
<head>
<link rel=""stylesheet"" type=""text/css"" href=""http://fonts.googleapis.com/css?family=Germania+One"">
<style>
body {{
font-family: 'Germania One', serif;
font-size: 24px;
}}
</style>
</head>
<body>
{str.ToString()}
</body>
</html>
");
});
}
static async Task MainAsync(string[] args)
{
var items = new List <SyndicationItem>();
using (var xmlReader = XmlReader.Create("http://scripting.com/rss.xml", new XmlReaderSettings {
Async = true
}))
{
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
ISyndicationItem item = await feedReader.ReadItem();
items.Add(new SyndicationItem(item));
break;
default:
break;
}
}
}
var str = new StringBuilder();
str.Append("<ul>");
foreach (var i in items)
{
str.Append($"<li>{i.Description}</li>");
}
str.Append("</ul>");
var html = $@"
<html>
<head>
<link rel=""stylesheet"" type=""text/css"" href=""http://fonts.googleapis.com/css?family=Germania+One"">
<style>
body {{
font-family: 'Germania One', serif;
font-size: 24px;
}}
</style>
</head>
<body>
{str.ToString()}
</body>
</html>
";
var path = Path.Combine(Directory.GetCurrentDirectory(), "rss.html");
File.WriteAllText(path, html);
}
public static List <Tuple <string, string, string, DateTimeOffset> > Latest5PostsFromRss(string filePath)
{
List <Tuple <string, string, string, DateTimeOffset> > result = new List <Tuple <string, string, string, DateTimeOffset> >();
using (var xmlReader = XmlReader.Create(filePath, new XmlReaderSettings()))
{
var feedReader = new RssFeedReader(xmlReader);
while (feedReader.Read().Result)
{
switch (feedReader.ElementType)
{
// Read Item
case SyndicationElementType.Item:
ISyndicationItem item = feedReader.ReadItem().Result; //AsyncHelper.ci.GetResult(feedReader.ReadItem());
result.Add(new Tuple <string, string, string, DateTimeOffset>(item.Title, item.Links.First().Uri.ToString(), item.Description, item.Published));
break;
#region MyRegion
//// Read category
//case SyndicationElementType.Category:
// ISyndicationCategory category = await feedReader.ReadCategory();
// break;
//// Read Image
//case SyndicationElementType.Image:
// ISyndicationImage image = await feedReader.ReadImage();
// break;
//// Read link
//case SyndicationElementType.Link:
// ISyndicationLink link = await feedReader.ReadLink();
// break;
//// Read Person
//case SyndicationElementType.Person:
// ISyndicationPerson person = await feedReader.ReadPerson();
// break;
//// Read content
//default:
// ISyndicationContent content = await feedReader.ReadContent();
// break;
#endregion
}
if (result.Count == 5)
{
break;
}
}
}
return(result);
}
public async Task CompareContents()
{
string filePath = @"..\..\..\TestFeeds\internetRssFeed.xml";
string res = null;
using (var xmlReader = XmlReader.Create(filePath, new XmlReaderSettings()
{
Async = true
}))
{
var reader = new RssFeedReader(xmlReader);
var sw = new StringWriterWithEncoding(Encoding.UTF8);
using (var xmlWriter = XmlWriter.Create(sw))
{
var writer = new RssFeedWriter(xmlWriter);
while (await reader.Read())
{
switch (reader.ElementType)
{
case SyndicationElementType.Item:
await writer.Write(await reader.ReadItem());
break;
case SyndicationElementType.Person:
await writer.Write(await reader.ReadPerson());
break;
case SyndicationElementType.Image:
await writer.Write(await reader.ReadImage());
break;
default:
await writer.Write(await reader.ReadContent());
break;
}
}
await writer.Flush();
}
res = sw.ToString();
}
await CompareFeeds(new RssFeedReader(XmlReader.Create(filePath)),
new RssFeedReader(XmlReader.Create(new StringReader(res))));
}
public RssContent()
{
using (var xmlReader = XmlReader.Create("C:/Users/Developer/Desktop.brisbane-city-council.rss", new XmlReaderSettings()
{
Async = true
}))
{
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
// Read category
case SyndicationElementType.Category:
ISyndicationCategory category = await feedReader.ReadCategory();
break;
// Read Image
case SyndicationElementType.Image:
ISyndicationImage image = await feedReader.ReadImage();
break;
// Read Item
case SyndicationElementType.Item:
ISyndicationItem item = await feedReader.ReadItem();
break;
// Read link
case SyndicationElementType.Link:
ISyndicationLink link = await feedReader.ReadLink();
break;
// Read Person
case SyndicationElementType.Person:
ISyndicationPerson person = await feedReader.ReadPerson();
break;
// Read content
default:
ISyndicationContent content = await feedReader.ReadContent();
break;
}
}
}
}
