public List<BannerItem> FbItems()
{
Atom10FeedFormatter formatter = new Atom10FeedFormatter();
using (XmlReader reader = XmlReader.Create(ConfigurationManager.AppSettings["FacebookFeed"]))
{
formatter.ReadFrom(reader);
}
var bannerItems = new List<BannerItem>();
foreach (var e in formatter.Feed.Items)
{
if (!e.Title.Text.StartsWith("Wallflux"))
{
BannerItem le = new BannerItem();
le.title = e.Title.Text;
le.content = new entryContent
{
Value = ((TextSyndicationContent)e.Content).Text
};
le.link = new entryLink
{
href = e.Id,
target = "_blank"
};
le.updated = e.LastUpdatedTime.DateTime.ToShortDateString();
le.published = "Published on facebook "+e.PublishDate.DateTime.ToShortDateString();
le.TypeOfContent = Enum.GetName(typeof(TypeOfContent), TypeOfContent.FacebookPost);
bannerItems.Add(le);
}
}
return bannerItems;
/* sparas, extrahera bilder
List<RssFeedItem> rssItems = new List<RssFeedItem>();
Stream stream = e.Result;
XmlReader response = XmlReader.Create(stream);
SyndicationFeed feeds = SyndicationFeed.Load(response);
foreach (SyndicationItem f in feeds.Items)
{
RssFeedItem rssItem = new RssFeedItem();
rssItem.Description = f.Summary.Text;
const string rx = @"(?<=img\s+src\=[\x27\x22])(?<Url>[^\x27\x22]*)(?=[\x27\x22])";
foreach (Match m in Regex.Matches(f.Summary.Text, rx, RegexOptions.IgnoreCase | RegexOptions.Multiline))
{
string src = m.Groups[1].Value;
if (src.StartsWith("//")) // Google RSS has it
{
src = src.Replace("//", "http://");
}
rssItem.ImageLinks.Add(src);
}
*/
}
public static IList<Feed> GetFeeds()
{
var urls = new[]
{
"http://www.simplyvinay.com/GetBlogRss.aspx", "http://www.bbc.co.uk/blogs/formula1/rss.xml",
"http://feeds.feedburner.com/AyendeRahien"
};
var list = new List<Feed>();
foreach (var url in urls)
{
using (var reader = new CustomXmlReader(url))
{
if (reader.ReadState == ReadState.Initial)
reader.MoveToContent();
var atom = new Atom10FeedFormatter();
if (atom.CanRead(reader))
{
atom.ReadFrom(reader);
list.AddRange(GenerateFeed(atom.Feed, true));
}
var rss = new Rss20FeedFormatter();
if (rss.CanRead(reader))
{
rss.ReadFrom(reader);
list.AddRange(GenerateFeed(rss.Feed, false));
}
}
}
return list;
}
public void fload(string namefile)
{
var lines = System.IO.File.ReadAllLines(namefile);
feed.Title = new TextSyndicationContent(lines[1]);
feed.Copyright = new TextSyndicationContent(lines[2]);
feed.Description = new TextSyndicationContent(lines[3]);
feed.Generator = lines[4];
SyndicationLink link = new SyndicationLink();
link.Uri = new Uri(lines[5]);
feed.Links.Add(link);
feed.Items = txtgotolv("feedinfo.txt");
Response.Clear();
Response.ContentEncoding = System.Text.Encoding.UTF8;
Response.ContentType = "text/xml";
XmlWriter Writer = XmlWriter.Create
(Response.Output);
if (lines[0] == "rss")
{
Rss20FeedFormatter Formatter = new Rss20FeedFormatter(feed);
Formatter.WriteTo(Writer);
}
else
{
if (lines[0] == "atom")
{
Atom10FeedFormatter Formatter = new Atom10FeedFormatter(feed);
Formatter.WriteTo(Writer);
}
}
Writer.Close();
Response.End();
}
public SyndicationFeedFormatter CreateFeed()
{
string serverUrl = ConfigurationManager.AppSettings["CatMyVideoUrl"];
// Create a new Syndication Feed.
SyndicationFeed feed = new SyndicationFeed();
feed.Id = "#CatMyVideo URL";
List<SyndicationItem> items = new List<SyndicationItem>();
feed.Title = new TextSyndicationContent("Last trends on CatMyVideo");
feed.Description = new TextSyndicationContent(String.Format("Todays' top {0} hottest videos on CatMyVideo", MAXVIDEO));
feed.Copyright = new TextSyndicationContent("Copy/Paste rights CatMyVideo");
feed.Generator = "CatMyVideo RSS Feeder 1.0";
feed.Authors.Add(new SyndicationPerson("*****@*****.**"));
feed.LastUpdatedTime = new DateTimeOffset(DateTime.Now);
var trendingVideos = Engine.BusinessManagement.Video.ListVideos(Engine.Dbo.Video.Order.UploadDate, false, MAXVIDEO, 0, true);
for (int i = 0; i < trendingVideos.Count; i++)
{
SyndicationItem item = new SyndicationItem();
string itemUrl = serverUrl + "/Video/Display/" + trendingVideos[i].Id;
item.Id = itemUrl;
var itemLink = new SyndicationLink(new Uri(itemUrl));
itemLink.MediaType = "text/html";
itemLink.Title = "Watch me !";
item.Links.Add(itemLink);
string htmlContent = String.Format("<!DOCTYPE html><html><head></head><body><h1>{0}</h1><p>{1}</p><a href=\"{2}\">Check this out !</a></body></html>",
trendingVideos[i].Title,
trendingVideos[i].Description,
itemUrl);
TextSyndicationContent content = new TextSyndicationContent(htmlContent, TextSyndicationContentKind.Html);
// Fill some properties for the item
item.Title = new TextSyndicationContent("#" + (i + 1));
item.LastUpdatedTime = DateTime.Now;
item.PublishDate = trendingVideos[i].UploadDate;
item.Content = content;
items.Add(item);
}
feed.Items = items;
string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"];
SyndicationFeedFormatter formatter = null;
if (query == "atom")
{
formatter = new Atom10FeedFormatter(feed);
}
else
{
formatter = new Rss20FeedFormatter(feed);
}
return formatter;
}
public SyndicationFeedFormatter CreateFeed()
{
// Créez un flux RSS.
SyndicationFeed feed = new SyndicationFeed("TekConf Event", "Last 10 event added in TekConf", null);
List<SyndicationItem> items = TekConf.DataAccess.Event.GetLastEventsList(10).Select(
e => new SyndicationItem("idEvent : " + e.id + " : " + e.name,
e.location + ", " + e.time + " \n " + e.Technology + " \n " + e.description,
null)
).ToList();
feed.Items = items;
// Renvoie ATOM ou RSS en fonction de la chaîne de requête
// rss -> http://localhost:8733/Design_Time_Addresses/SyndicationServiceLibrary1/Feed1/
// atom -> http://localhost:8733/Design_Time_Addresses/SyndicationServiceLibrary1/Feed1/?format=atom
string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"];
SyndicationFeedFormatter formatter = null;
if (query == "atom")
{
formatter = new Atom10FeedFormatter(feed);
}
else
{
formatter = new Rss20FeedFormatter(feed);
}
return formatter;
}
public Atom10ItemFormatter(SyndicationItem itemToWrite) : base(itemToWrite)
{
this.feedSerializer = new Atom10FeedFormatter();
this.feedSerializer.PreserveAttributeExtensions = this.preserveAttributeExtensions = true;
this.feedSerializer.PreserveElementExtensions = this.preserveElementExtensions = true;
this.itemType = itemToWrite.GetType();
}
public SyndicationFeedFormatter CreateFeedForBlog(string user, string blog)
{
SyndicationFeed feed = new SyndicationFeed("Blog feed", "A feed linked to a blog", null);
List<SyndicationItem> items = new List<SyndicationItem>();
List<Dbo.RssArticle> articles = BusinessManagement.Feed.GetBlogContent(user, blog);
foreach (Dbo.RssArticle article in articles)
{
SyndicationItem item = new SyndicationItem(article.Title, article.Content, null);
item.PublishDate = article.CreationDate;
items.Add(item);
}
feed.Items = items;
// Renvoie ATOM ou RSS en fonction de la chaîne de requête
// rss -> http://localhost:8733/Design_Time_Addresses/FluxRss/Feed1/
// atom -> http://localhost:8733/Design_Time_Addresses/FluxRss/Feed1/?format=atom
string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"];
SyndicationFeedFormatter formatter = null;
if (query == "atom")
{
formatter = new Atom10FeedFormatter(feed);
}
else
{
formatter = new Rss20FeedFormatter(feed);
}
return formatter;
}
public string Build(FeedData dataFeed, Uri baseUri)
{
var feed = new SyndicationFeed
{
Id = dataFeed.Id.ToString(),
LastUpdatedTime = dataFeed.DateCreated,
Items = dataFeed.Messages.Select(x => new SyndicationItem
{
Content = new RawSyndicationContent(x.Body),
Id = x.Id.ToString(),
LastUpdatedTime = x.CreatedAt
})
};
if (!string.IsNullOrEmpty(dataFeed.NextUri))
feed.Links.Add(new SyndicationLink(new Uri(baseUri, dataFeed.NextUri), NextInArchiveRelationshipType,
"Next In Archive", ContentType, 0));
if (!string.IsNullOrEmpty(dataFeed.PreviousUri))
feed.Links.Add(new SyndicationLink(new Uri(baseUri, dataFeed.PreviousUri), PrevInArchiveRelationshipType,
"Previous In Archive", ContentType, 0));
var formatter = new Atom10FeedFormatter(feed);
var sw = new StringWriter();
using (var writer = XmlWriter.Create(sw))
{
formatter.WriteTo(writer);
}
return sw.ToString();
}
public SyndicationFeedFormatter CreateFeed()
{
// Create a new Syndication Feed.
SyndicationFeed feed = new SyndicationFeed("Bug Track", "Flux rss du bug track", null);
List<SyndicationItem> items = new List<SyndicationItem>();
// Create a new Syndication Item.
List<DBO.Bug> list = BusinessManagement.Bug.GetLastBug(10);
foreach (DBO.Bug itemBug in list)
{
SyndicationItem item = new SyndicationItem(itemBug.ProjectName + " : " + itemBug.Title, itemBug.CreateDate + " \n " + itemBug.Details, null);
items.Add(item);
}
feed.Items = items;
// Return ATOM or RSS based on query string
// rss -> http://localhost:8731/Design_Time_Addresses/SyndicationServiceBugTrack/Feed1/
// atom -> http://localhost:8731/Design_Time_Addresses/SyndicationServiceBugTrack/Feed1/?format=atom
string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"];
SyndicationFeedFormatter formatter = null;
if (query == "atom")
{
formatter = new Atom10FeedFormatter(feed);
}
else
{
formatter = new Rss20FeedFormatter(feed);
}
return formatter;
}
public FeedData Build(string data, string url)
{
var formatter = new Atom10FeedFormatter();
using (var reader = new StringReader(data))
{
using (var xmlReader = XmlReader.Create(reader))
{
formatter.ReadFrom(xmlReader);
var feed = formatter.Feed;
return new FeedData
{
Id = Guid.Parse(feed.Id),
DateCreated = feed.LastUpdatedTime.UtcDateTime,
PreviousUri = GetUriFromLink(PrevInArchiveRelationshipType, feed),
NextUri = GetUriFromLink(NextInArchiveRelationshipType, feed),
Messages = feed.Items.Select(x =>
{
return new Message
{
Body = GetXmlString(x),
CreatedAt = x.LastUpdatedTime.UtcDateTime,
Id = Guid.Parse(x.Id),
FeedUri = url
};
}).ToArray()
};
}
}
}
private Action<Stream> GetXmlContents(IEnumerable<Post> model)
{
var items = new List<SyndicationItem>();
foreach (var post in model)
{
// Replace all relative urls with full urls.
var contentHtml = Regex.Replace(post.Content, UrlRegex, m => siteUrl.TrimEnd('/') + "/" + m.Value.TrimStart('/'));
var excerptHtml = Regex.Replace(post.ContentExcerpt, UrlRegex, m => siteUrl.TrimEnd('/') + "/" + m.Value.TrimStart('/'));
var item = new SyndicationItem(
post.Title,
contentHtml,
new Uri(siteUrl + post.Url)
)
{
Id = siteUrl + post.Url,
LastUpdatedTime = post.Date.ToUniversalTime(),
PublishDate = post.Date.ToUniversalTime(),
Content = new TextSyndicationContent(contentHtml, TextSyndicationContentKind.Html),
Summary = new TextSyndicationContent(excerptHtml, TextSyndicationContentKind.Html),
};
items.Add(item);
}
var feed = new SyndicationFeed(
AtomTitle,
AtomTitle, /* Using Title also as Description */
new Uri(siteUrl + "/" + feedfileName),
items)
{
Id = siteUrl + "/",
LastUpdatedTime = new DateTimeOffset(DateTime.Now),
Generator = "Sandra.Snow Atom Generator"
};
feed.Authors.Add(new SyndicationPerson(authorEmail, author, siteUrl));
var link = new SyndicationLink(new Uri(siteUrl + "/" + feedfileName))
{
RelationshipType = "self",
MediaType = "text/html",
Title = AtomTitle
};
feed.Links.Add(link);
var formatter = new Atom10FeedFormatter(feed);
return stream =>
{
var encoding = new UTF8Encoding(false);
var streamWrapper = new UnclosableStreamWrapper(stream);
using (var writer = new XmlTextWriter(streamWrapper, encoding))
{
formatter.WriteTo(writer);
}
};
}
public SyndicationFeedFormatter CreateFeed()
{
// Create a new Syndication Feed.
SyndicationFeed feed = new SyndicationFeed("Feed Title", "A WCF Syndication Feed", null);
List<SyndicationItem> items = new List<SyndicationItem>();
// Create a new Syndication Item.
SyndicationItem item = new SyndicationItem("An item", "Item content", null);
items.Add(item);
feed.Items = items;
// Return ATOM or RSS based on query string
// rss -> http://localhost:8733/Design_Time_Addresses/SyndicationServiceLibrary1/Feed1/
// atom -> http://localhost:8733/Design_Time_Addresses/SyndicationServiceLibrary1/Feed1/?format=atom
string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"];
SyndicationFeedFormatter formatter = null;
if (query == "atom")
{
formatter = new Atom10FeedFormatter(feed);
}
else
{
formatter = new Rss20FeedFormatter(feed);
}
return formatter;
}
public override void ExecuteResult(ControllerContext context)
{
SyndicationFeedFormatter formatter;
string contentType;
switch (_feedType)
{
case FeedType.Atom:
formatter = new Atom10FeedFormatter(_syndicationFeed);
contentType = "application/atom+xml";
break;
case FeedType.Rss:
formatter = new Rss20FeedFormatter(_syndicationFeed);
contentType = "application/rss+xml";
break;
default:
throw new NotImplementedException("Feed type not accounted for");
}
context.HttpContext.Response.ContentType = contentType;
using (var writer = XmlWriter.Create(context.HttpContext.Response.Output))
{
formatter.WriteTo(writer);
}
}
public override void ExecuteResult(ControllerContext context)
{
context.HttpContext.Response.ContentType = "application/atom+xml";
//check request is for Atom or RSS
if (context.HttpContext.Request.QueryString["type"] != null && context.HttpContext.Request.QueryString["type"].ToString().ToLower() == "atom")
{
//Atom Feed
context.HttpContext.Response.ContentType = "application/atom+xml";
var rssFormatter = new Atom10FeedFormatter(FeedData);
using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.Output, new XmlWriterSettings { Indent = true }))
{
rssFormatter.WriteTo(writer);
}
}
else
{
//RSS Feed
context.HttpContext.Response.ContentType = "application/rss+xml";
var rssFormatter = new Rss20FeedFormatter(FeedData);
using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.Output, new XmlWriterSettings { Indent = true }))
{
rssFormatter.WriteTo(writer);
}
}
}
public SyndicationFeedFormatter CreateFeed()
{
// Créez un flux RSS.
SyndicationFeed feed = new SyndicationFeed("Bug Track", "Flux rss du bug track", null);
List<SyndicationItem> items = new List<SyndicationItem>();
// Créez un article RSS.
List<DBO.Bug> bugs = DataAccess.Bug.GetLastBug(10);
bugs.ForEach(bug => items.Add(new SyndicationItem(bug.Title, bug.Details, null)));
feed.Items = items;
// Renvoie ATOM ou RSS en fonction de la chaîne de requête
// rss -> http://localhost:8733/Design_Time_Addresses/SyndicationServiceBugTrack/Feed1/
// atom -> http://localhost:8733/Design_Time_Addresses/SyndicationServiceBugTrack/Feed1/?format=atom
string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"];
SyndicationFeedFormatter formatter = null;
if (query == "atom")
{
formatter = new Atom10FeedFormatter(feed);
}
else
{
formatter = new Rss20FeedFormatter(feed);
}
return formatter;
}
public override void ExecuteResult(ControllerContext context)
{
context.HttpContext.Response.ContentType = "application/atom+xml";
var formatter = new Atom10FeedFormatter(Feed);
using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.Output))
formatter.WriteTo(writer);
}
//var formatter = new Rss20FeedFormatter(feed);
// Atom10FeedFormatter formatter = new Atom10FeedFormatter(feed);
//using (var writer = XmlWriter.Create(response.Output, new XmlWriterSettings { Indent = true }))
//{
// formatter.WriteTo(writer);
//}
protected override void WriteFile(HttpResponseBase response)
{
Atom10FeedFormatter formatter = new Atom10FeedFormatter(_feed);
using (XmlWriter writer = XmlWriter.Create(response.OutputStream, new XmlWriterSettings { Indent = true }))
{
formatter.WriteTo(writer);
}
}
/// <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;
}
}
public override void OnWriteToStream(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, TransportContext context)
{
var formatter = new Atom10FeedFormatter((SyndicationFeed) value);
using (var xmlWriter = XmlWriter.Create(stream))
{
formatter.WriteTo(xmlWriter);
xmlWriter.Close();
}
}
public Atom10ItemFormatter(SyndicationItem itemToWrite)
: base(itemToWrite)
{
// No need to check that the parameter passed is valid - it is checked by the c'tor of the base class
this.feedSerializer = new Atom10FeedFormatter();
this.feedSerializer.PreserveAttributeExtensions = this.preserveAttributeExtensions = true;
this.feedSerializer.PreserveElementExtensions = this.preserveElementExtensions = true;
this.itemType = itemToWrite.GetType();
}
private static Action<Stream> GetXmlContents(SyndicationFeed feed)
{
return stream =>
{
var writer = new XmlTextWriter(stream, Encoding.UTF8);
var atomFormatter = new Atom10FeedFormatter(feed);
atomFormatter.WriteTo(writer);
};
}
public Rss20FeedFormatter(SyndicationFeed feedToWrite, bool serializeExtensionsAsAtom) : base(feedToWrite)
{
this.serializeExtensionsAsAtom = serializeExtensionsAsAtom;
this.maxExtensionSize = 0x7fffffff;
this.preserveElementExtensions = true;
this.preserveAttributeExtensions = true;
this.atomSerializer = new Atom10FeedFormatter(base.Feed);
this.feedType = feedToWrite.GetType();
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, Workspace workspace)
{
if (workspace == null)
{
throw new ArgumentNullException(nameof(workspace));
}
Atom10FeedFormatter.CloseBuffer(buffer, writer);
workspace.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, ServiceDocument document)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
Atom10FeedFormatter.CloseBuffer(buffer, writer);
document.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, ResourceCollectionInfo collection)
{
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
Atom10FeedFormatter.CloseBuffer(buffer, writer);
collection.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, CategoriesDocument categories)
{
if (categories == null)
{
throw new ArgumentNullException(nameof(categories));
}
Atom10FeedFormatter.CloseBuffer(buffer, writer);
categories.LoadElementExtensions(buffer);
}
public Rss20FeedFormatter(SyndicationFeed feedToWrite, bool serializeExtensionsAsAtom)
: base(feedToWrite)
{
// No need to check that the parameter passed is valid - it is checked by the c'tor of the base class
this.serializeExtensionsAsAtom = serializeExtensionsAsAtom;
this.maxExtensionSize = int.MaxValue;
this.preserveElementExtensions = true;
this.preserveAttributeExtensions = true;
this.atomSerializer = new Atom10FeedFormatter(this.Feed);
this.feedType = feedToWrite.GetType();
}
private static UpdateCheck CheckForUpdates(string feedUrl, Version currentVersion)
{
var r = new UpdateCheck();
r.Message = "";
// NOTE: Requires a reference to System.ServiceModel.dll
var formatter = new Atom10FeedFormatter();
try
{
// Read the feed
using (var reader = System.Xml.XmlReader.Create(feedUrl))
{
formatter.ReadFrom(reader);
var latest = (from i in formatter.Feed.Items
where i.Categories.Any(c => IsStable(c.Name))
orderby i.LastUpdatedTime descending
select i).FirstOrDefault();
if (latest != null)
{
var u = latest.Links.Single().Uri.AbsoluteUri;
r.Message += String.Format("The latest release is: {0}\n", u);
var update = (from i in formatter.Feed.Items
where ExtractVersion(i.Title.Text) > currentVersion &&
i.Categories.Any(c => IsStable(c.Name))
orderby i.LastUpdatedTime descending
select i).FirstOrDefault();
if (update != null)
{
// TODO: Notify user of available download
var downloadUrl = update.Links.Single().Uri.AbsoluteUri;
r.Message += String.Format("There is an available update: {0}",
update.Title.Text);
r.UpdateAvailable = true;
}
else
{
r.Message += "There is no later version.";
}
}
else
{
r.Message += "Could not find a later version.";
}
}
}
catch (System.Exception exc1)
{
r.Message += "Cannot check for updates. " + exc1.ToString();
}
return r;
}
public override void ExecuteResult(ControllerContext context)
{
context.HttpContext.Response.ContentType = _feedContentType[Format];
SyndicationFeedFormatter formatter = null;
if (Format == FeedFormat.Atom)
formatter = new Atom10FeedFormatter(Feed);
else
formatter = new Rss20FeedFormatter(Feed);
using (var writer = XmlWriter.Create(context.HttpContext.Response.Output))
{
formatter.WriteTo(writer);
}
}
public static StreamContent CreateContentFromAtom10SyndicationFeed(SyndicationFeed feed)
{
SyndicationFeedFormatter formatter = new Atom10FeedFormatter<SyndicationFeed>(feed);
var memoryStream = new MemoryStream();
var settings = new XmlWriterSettings { Encoding = Encoding.UTF8, ConformanceLevel = ConformanceLevel.Document, Indent = true };
using (var xmlWriter = XmlWriter.Create(memoryStream, settings))
{
formatter.WriteTo(xmlWriter);
xmlWriter.Flush();
xmlWriter.Close();
}
memoryStream.Seek(0, SeekOrigin.Begin);
return new StreamContent(memoryStream);
}
public static void AtomFeed()
{
Atom10FeedFormatter formatter = new Atom10FeedFormatter();
using (XmlReader reader = XmlReader.Create("https://www.wunschliste.de/xml/atom.pl?user_id=1125047&key=1355167046072"))
{
formatter.ReadFrom(reader);
}
foreach (SyndicationItem item in formatter.Feed.Items)
{
//Console.WriteLine("[{0}][{1}] {2}", item.PublishDate, item.Title.Text, ((TextSyndicationContent)item.Content).Text);
}
Console.ReadLine();
}
public Atom10ItemFormatter(Type itemTypeToCreate)
{
if (itemTypeToCreate == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("itemTypeToCreate");
}
if (!typeof(SyndicationItem).IsAssignableFrom(itemTypeToCreate))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("itemTypeToCreate", System.ServiceModel.SR.GetString("InvalidObjectTypePassed", new object[] { "itemTypeToCreate", "SyndicationItem" }));
}
this.feedSerializer = new Atom10FeedFormatter();
this.feedSerializer.PreserveAttributeExtensions = this.preserveAttributeExtensions = true;
this.feedSerializer.PreserveElementExtensions = this.preserveElementExtensions = true;
this.itemType = itemTypeToCreate;
}
public Atom10ItemFormatter(Type itemTypeToCreate)
{
if (itemTypeToCreate == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("itemTypeToCreate");
}
if (!typeof(SyndicationItem).IsAssignableFrom(itemTypeToCreate))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("itemTypeToCreate", System.ServiceModel.SR.GetString("InvalidObjectTypePassed", new object[] { "itemTypeToCreate", "SyndicationItem" }));
}
this.feedSerializer = new Atom10FeedFormatter();
this.feedSerializer.PreserveAttributeExtensions = this.preserveAttributeExtensions = true;
this.feedSerializer.PreserveElementExtensions = this.preserveElementExtensions = true;
this.itemType = itemTypeToCreate;
}
internal static TSyndicationFeed LoadFeed <TSyndicationFeed> (XmlReader reader) where TSyndicationFeed : SyndicationFeed, new()
{
switch (DetectVersion(reader, ReaderKind.Feed))
{
case SyndicationVersions.Atom10:
Atom10FeedFormatter af = new Atom10FeedFormatter <TSyndicationFeed> ();
af.ReadFrom(reader);
return((TSyndicationFeed)af.Feed);
case SyndicationVersions.Rss20:
default: // anything else are rejected by DetectVersion
Rss20FeedFormatter rf = new Rss20FeedFormatter <TSyndicationFeed> ();
rf.ReadFrom(reader);
return((TSyndicationFeed)rf.Feed);
}
}
public async Task<Update> CheckForUpdatesAsync(string updateUrl, UpdateFilter updateFilter)
{
Debug.Assert(!String.IsNullOrWhiteSpace(updateUrl));
var reader = XmlReader.Create(updateUrl);
var formatter = new Atom10FeedFormatter();
await formatter.ReadFromAsync(reader);
return (from i in formatter.Feed.Items
let u = UpdateHelper.FromSyndicationItem(i)
where u.Version > Assembly.GetExecutingAssembly().GetName().Version
&& ((int)updateFilter & (int)u.ReleaseStatus) != 0
orderby u.LastUpdatedTime descending
select u).FirstOrDefault();
}
public Atom10ItemFormatter(Type itemTypeToCreate)
: base()
{
if (itemTypeToCreate == null)
{
throw new ArgumentNullException(nameof(itemTypeToCreate));
}
if (!typeof(SyndicationItem).IsAssignableFrom(itemTypeToCreate))
{
throw new ArgumentException(string.Format(SR.InvalidObjectTypePassed, nameof(itemTypeToCreate), nameof(SyndicationItem)));
}
_feedSerializer = new Atom10FeedFormatter();
_feedSerializer.PreserveAttributeExtensions = _preserveAttributeExtensions = true;
_feedSerializer.PreserveElementExtensions = _preserveElementExtensions = true;
_itemType = itemTypeToCreate;
}
public Atom10ItemFormatter(Type itemTypeToCreate)
: base()
{
if (itemTypeToCreate == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("itemTypeToCreate");
}
if (!typeof(SyndicationItem).IsAssignableFrom(itemTypeToCreate))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("itemTypeToCreate",
SR.Format(SR.InvalidObjectTypePassed, "itemTypeToCreate", "SyndicationItem"));
}
_feedSerializer = new Atom10FeedFormatter();
_feedSerializer.PreserveAttributeExtensions = _preserveAttributeExtensions = true;
_feedSerializer.PreserveElementExtensions = _preserveElementExtensions = true;
_itemType = itemTypeToCreate;
}
public Rss20FeedFormatter(Type feedTypeToCreate)
{
if (feedTypeToCreate == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feedTypeToCreate");
}
if (!typeof(SyndicationFeed).IsAssignableFrom(feedTypeToCreate))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("feedTypeToCreate", System.ServiceModel.SR.GetString("InvalidObjectTypePassed", new object[] { "feedTypeToCreate", "SyndicationFeed" }));
}
this.serializeExtensionsAsAtom = true;
this.maxExtensionSize = 0x7fffffff;
this.preserveElementExtensions = true;
this.preserveAttributeExtensions = true;
this.atomSerializer = new Atom10FeedFormatter(feedTypeToCreate);
this.feedType = feedTypeToCreate;
}
private static void WriteInlineCategoriesContent(XmlWriter writer, InlineCategoriesDocument categories, string version)
{
if (!string.IsNullOrEmpty(categories.Scheme))
{
writer.WriteAttributeString("scheme", categories.Scheme);
}
if (categories.IsFixed)
{
writer.WriteAttributeString("fixed", "yes");
}
ServiceDocumentFormatter.WriteAttributeExtensions(writer, categories, version);
for (int i = 0; i < categories.Categories.Count; i++)
{
Atom10FeedFormatter.WriteCategory(writer, categories.Categories[i], version);
}
ServiceDocumentFormatter.WriteElementExtensions(writer, categories, version);
}
SyndicationFeed ReadSourceFeed(XmlReader reader)
{
SyndicationFeed feed = null;
if (!reader.IsEmptyElement)
{
Atom10FeedFormatter ff = new Atom10FeedFormatter();
((IXmlSerializable)ff).ReadXml(reader); // this does not check the QName of the wrapping element.
feed = ff.Feed;
}
else
{
feed = new SyndicationFeed();
}
reader.Read(); // </source> or <source ... />
return(feed);
}
private static void WriteInlineCategoriesContent(XmlWriter writer, InlineCategoriesDocument categories, string version)
{
if (!string.IsNullOrEmpty(categories.Scheme))
{
writer.WriteAttributeString(Atom10Constants.SchemeTag, categories.Scheme);
}
// by default, categories are not fixed
if (categories.IsFixed)
{
writer.WriteAttributeString(App10Constants.Fixed, "yes");
}
WriteAttributeExtensions(writer, categories, version);
for (int i = 0; i < categories.Categories.Count; ++i)
{
Atom10FeedFormatter.WriteCategory(writer, categories.Categories[i], version);
}
WriteElementExtensions(writer, categories, version);
}
SyndicationFeed ReadSourceFeed(XmlReader reader)
{
SyndicationFeed feed = null;
if (!reader.IsEmptyElement)
{
reader.Read();
Atom10FeedFormatter ff = new Atom10FeedFormatter();
ff.ReadFrom(reader);
feed = ff.Feed;
}
else
{
feed = new SyndicationFeed();
}
reader.Read(); // </source> or <source ... />
return(feed);
}
protected internal virtual bool TryParseElement(XmlReader reader, string version)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
reader.MoveToContent();
if (reader.LocalName != "collection" || reader.NamespaceURI != version)
{
return(false);
}
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
if (!TryParseAttribute(reader.LocalName, reader.NamespaceURI, reader.Value, version))
{
AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
}
reader.MoveToElement();
if (!reader.IsEmptyElement)
{
reader.Read();
for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
{
if (reader.LocalName == "title" && reader.NamespaceURI == Namespaces.Atom10)
{
Title = Atom10FeedFormatter.ReadTextSyndicationContent(reader);
}
else
{
ElementExtensions.Add(new SyndicationElementExtension(reader));
}
}
}
reader.Read();
return(true);
}
protected internal virtual bool TryParseElement(XmlReader reader, string version)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
reader.MoveToContent();
if (reader.LocalName != "workspace" || reader.NamespaceURI != version)
{
return(false);
}
bool isEmpty = reader.IsEmptyElement;
reader.ReadStartElement();
if (isEmpty)
{
return(true);
}
for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
{
if (reader.LocalName == "title" && reader.NamespaceURI == Namespaces.Atom10)
{
Title = Atom10FeedFormatter.ReadTextSyndicationContent(reader);
continue;
}
else if (reader.LocalName == "collection" && reader.NamespaceURI == version)
{
var rc = new ResourceCollectionInfo();
if (rc.TryParseElement(reader, version))
{
Collections.Add(rc);
continue;
}
}
ElementExtensions.Add(new SyndicationElementExtension(reader));
}
return(true);
}
public static TSyndicationFeed Load <TSyndicationFeed>(XmlReader reader) where TSyndicationFeed : SyndicationFeed, new()
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
Atom10FeedFormatter <TSyndicationFeed> formatter = new Atom10FeedFormatter <TSyndicationFeed>();
if (formatter.CanRead(reader))
{
formatter.ReadFrom(reader);
return(formatter.Feed as TSyndicationFeed);
}
Rss20FeedFormatter <TSyndicationFeed> formatter2 = new Rss20FeedFormatter <TSyndicationFeed>();
if (!formatter2.CanRead(reader))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("UnknownFeedXml", new object[] { reader.LocalName, reader.NamespaceURI })));
}
formatter2.ReadFrom(reader);
return(formatter2.Feed as TSyndicationFeed);
}
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).ConfigureAwait(false);
return(atomSerializer.Feed as TSyndicationFeed);
}
Rss20FeedFormatter <TSyndicationFeed> rssSerializer = new Rss20FeedFormatter <TSyndicationFeed>();
if (rssSerializer.CanRead(reader))
{
await rssSerializer.ReadFromAsync(reader, ct).ConfigureAwait(false);
return(rssSerializer.Feed as TSyndicationFeed);
}
throw new XmlException(SR.Format(SR.UnknownFeedXml, reader.LocalName, reader.NamespaceURI));
}
private static async Task WriteInlineCategoriesContentAsync(XmlWriter writer, InlineCategoriesDocument categories, string version)
{
writer = XmlWriterWrapper.CreateFromWriter(writer);
if (!string.IsNullOrEmpty(categories.Scheme))
{
await writer.WriteAttributeStringAsync(Atom10Constants.SchemeTag, categories.Scheme);
}
// by default, categories are not fixed
if (categories.IsFixed)
{
await writer.WriteAttributeStringAsync(App10Constants.Fixed, "yes");
}
await WriteAttributeExtensionsAsync(writer, categories, version);
for (int i = 0; i < categories.Categories.Count; ++i)
{
await Atom10FeedFormatter.WriteCategoryAsync(writer, categories.Categories[i], version);
}
await WriteElementExtensionsAsync(writer, categories, version);
}
public static TSyndicationFeed Load <TSyndicationFeed>(XmlReader reader)
where TSyndicationFeed : SyndicationFeed, new()
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
Atom10FeedFormatter <TSyndicationFeed> atomSerializer = new Atom10FeedFormatter <TSyndicationFeed>();
if (atomSerializer.CanRead(reader))
{
atomSerializer.ReadFrom(reader);
return(atomSerializer.Feed as TSyndicationFeed);
}
Rss20FeedFormatter <TSyndicationFeed> rssSerializer = new Rss20FeedFormatter <TSyndicationFeed>();
if (rssSerializer.CanRead(reader))
{
rssSerializer.ReadFrom(reader);
return(rssSerializer.Feed as TSyndicationFeed);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.UnknownFeedXml, reader.LocalName, reader.NamespaceURI)));
}
private ResourceCollectionInfo ReadCollection(XmlReader reader, Workspace workspace)
{
CreateInlineCategoriesDelegate inlineCategoriesFactory = null;
CreateReferencedCategoriesDelegate referencedCategoriesFactory = null;
ResourceCollectionInfo result = ServiceDocumentFormatter.CreateCollection(workspace);
result.BaseUri = workspace.BaseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if ((reader.LocalName == "base") && (reader.NamespaceURI == "http://www.w3.org/XML/1998/namespace"))
{
result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
}
else
{
if ((reader.LocalName == "href") && (reader.NamespaceURI == string.Empty))
{
result.Link = new Uri(reader.Value, UriKind.RelativeOrAbsolute);
continue;
}
string namespaceURI = reader.NamespaceURI;
string localName = reader.LocalName;
if (!FeedUtils.IsXmlns(localName, namespaceURI) && !FeedUtils.IsXmlSchemaType(localName, namespaceURI))
{
string str3 = reader.Value;
if (!ServiceDocumentFormatter.TryParseAttribute(localName, namespaceURI, str3, result, this.Version))
{
if (this.preserveAttributeExtensions)
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
continue;
}
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
}
}
}
}
}
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
reader.ReadStartElement();
try
{
while (reader.IsStartElement())
{
if (reader.IsStartElement("title", "http://www.w3.org/2005/Atom"))
{
result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/app:collection/atom:title[@type]", this.preserveAttributeExtensions);
}
else
{
if (reader.IsStartElement("categories", "http://www.w3.org/2007/app"))
{
if (inlineCategoriesFactory == null)
{
inlineCategoriesFactory = () => ServiceDocumentFormatter.CreateInlineCategories(result);
}
if (referencedCategoriesFactory == null)
{
referencedCategoriesFactory = () => ServiceDocumentFormatter.CreateReferencedCategories(result);
}
result.Categories.Add(ReadCategories(reader, result.BaseUri, inlineCategoriesFactory, referencedCategoriesFactory, this.Version, this.preserveElementExtensions, this.preserveAttributeExtensions, this.maxExtensionSize));
continue;
}
if (reader.IsStartElement("accept", "http://www.w3.org/2007/app"))
{
result.Accepts.Add(reader.ReadElementString());
}
else if (!ServiceDocumentFormatter.TryParseElement(reader, result, this.Version))
{
if (this.preserveElementExtensions)
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
continue;
}
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
reader.Skip();
}
}
}
ServiceDocumentFormatter.LoadElementExtensions(buffer, extWriter, result);
}
finally
{
if (extWriter != null)
{
extWriter.Close();
}
}
reader.ReadEndElement();
return(result);
}
private Workspace ReadWorkspace(XmlReader reader, ServiceDocument document)
{
Workspace workspace = ServiceDocumentFormatter.CreateWorkspace(document);
workspace.BaseUri = document.BaseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if ((reader.LocalName == "base") && (reader.NamespaceURI == "http://www.w3.org/XML/1998/namespace"))
{
workspace.BaseUri = FeedUtils.CombineXmlBase(workspace.BaseUri, reader.Value);
}
else
{
string namespaceURI = reader.NamespaceURI;
string localName = reader.LocalName;
if (!FeedUtils.IsXmlns(localName, namespaceURI) && !FeedUtils.IsXmlSchemaType(localName, namespaceURI))
{
string str3 = reader.Value;
if (!ServiceDocumentFormatter.TryParseAttribute(localName, namespaceURI, str3, workspace, this.Version))
{
if (this.preserveAttributeExtensions)
{
workspace.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
continue;
}
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
}
}
}
}
}
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
reader.ReadStartElement();
try
{
while (reader.IsStartElement())
{
if (reader.IsStartElement("title", "http://www.w3.org/2005/Atom"))
{
workspace.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/atom:title[@type]", this.preserveAttributeExtensions);
}
else
{
if (reader.IsStartElement("collection", "http://www.w3.org/2007/app"))
{
workspace.Collections.Add(this.ReadCollection(reader, workspace));
continue;
}
if (!ServiceDocumentFormatter.TryParseElement(reader, workspace, this.Version))
{
if (this.preserveElementExtensions)
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
continue;
}
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
reader.Skip();
}
}
}
ServiceDocumentFormatter.LoadElementExtensions(buffer, extWriter, workspace);
}
finally
{
if (extWriter != null)
{
extWriter.Close();
}
}
reader.ReadEndElement();
return(workspace);
}
public static async Task <SyndicationFeed> LoadAsync(XmlReader reader, Atom10FeedFormatter formatter, CancellationToken ct)
{
return(await LoadAsync(reader, new Rss20FeedFormatter(), formatter, ct));
}
private Workspace ReadWorkspace(XmlReader reader, ServiceDocument document)
{
Workspace result = CreateWorkspace(document);
result.BaseUri = document.BaseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = reader.Value;
if (!TryParseAttribute(name, ns, val, result, Version))
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
}
}
}
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
reader.ReadStartElement();
try
{
while (reader.IsStartElement())
{
if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
{
result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/atom:title[@type]", preserveAttributeExtensions: true);
}
else if (reader.IsStartElement(App10Constants.Collection, App10Constants.Namespace))
{
result.Collections.Add(ReadCollection(reader, result));
}
else if (!TryParseElement(reader, result, Version))
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
}
}
LoadElementExtensions(buffer, extWriter, result);
}
finally
{
extWriter?.Close();
}
reader.ReadEndElement();
return(result);
}
private ResourceCollectionInfo ReadCollection(XmlReader reader, Workspace workspace)
{
ResourceCollectionInfo result = CreateCollection(workspace);
result.BaseUri = workspace.BaseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
}
else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty)
{
result.Link = new Uri(reader.Value, UriKind.RelativeOrAbsolute);
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = reader.Value;
if (!TryParseAttribute(name, ns, val, result, Version))
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
}
}
}
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
reader.ReadStartElement();
try
{
while (reader.IsStartElement())
{
if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
{
result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/app:collection/atom:title[@type]", preserveAttributeExtensions: true);
}
else if (reader.IsStartElement(App10Constants.Categories, App10Constants.Namespace))
{
result.Categories.Add(ReadCategories(reader,
result.BaseUri,
() => CreateInlineCategories(result),
() => CreateReferencedCategories(result),
Version,
_maxExtensionSize));
}
else if (reader.IsStartElement(App10Constants.Accept, App10Constants.Namespace))
{
result.Accepts.Add(reader.ReadElementString());
}
else if (!TryParseElement(reader, result, Version))
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
}
}
LoadElementExtensions(buffer, extWriter, result);
}
finally
{
extWriter?.Close();
}
reader.ReadEndElement();
return(result);
}
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 ReadInlineCategories(XmlReader reader, InlineCategoriesDocument inlineCategories, Uri baseUri, string version, int maxExtensionSize)
{
inlineCategories.BaseUri = baseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
inlineCategories.BaseUri = FeedUtils.CombineXmlBase(inlineCategories.BaseUri, reader.Value);
}
else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
inlineCategories.Language = reader.Value;
}
else if (reader.LocalName == App10Constants.Fixed && reader.NamespaceURI == string.Empty)
{
inlineCategories.IsFixed = (reader.Value == "yes");
}
else if (reader.LocalName == Atom10Constants.SchemeTag && reader.NamespaceURI == string.Empty)
{
inlineCategories.Scheme = reader.Value;
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = reader.Value;
if (!TryParseAttribute(name, ns, val, inlineCategories, version))
{
inlineCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
}
}
}
SyndicationFeedFormatter.MoveToStartElement(reader);
bool isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmptyElement)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
while (reader.IsStartElement())
{
if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
{
SyndicationCategory category = CreateCategory(inlineCategories);
Atom10FeedFormatter.ReadCategory(reader, category, version, preserveAttributeExtensions: true, preserveElementExtensions: true, maxExtensionSize);
if (category.Scheme == null)
{
category.Scheme = inlineCategories.Scheme;
}
inlineCategories.Categories.Add(category);
}
else if (!TryParseElement(reader, inlineCategories, version))
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
}
}
LoadElementExtensions(buffer, extWriter, inlineCategories);
}
finally
{
extWriter?.Close();
}
reader.ReadEndElement();
}
}
private static async Task ReadInlineCategoriesAsync(XmlReaderWrapper reader, InlineCategoriesDocument inlineCategories, Uri baseUri, string version, bool preserveElementExtensions, bool preserveAttributeExtensions, int _maxExtensionSize)
{
inlineCategories.BaseUri = baseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
inlineCategories.BaseUri = FeedUtils.CombineXmlBase(inlineCategories.BaseUri, await reader.GetValueAsync());
}
else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
inlineCategories.Language = await reader.GetValueAsync();
}
else if (reader.LocalName == App10Constants.Fixed && reader.NamespaceURI == string.Empty)
{
inlineCategories.IsFixed = (reader.Value == "yes");
}
else if (reader.LocalName == Atom10Constants.SchemeTag && reader.NamespaceURI == string.Empty)
{
inlineCategories.Scheme = await reader.GetValueAsync();
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = await reader.GetValueAsync();
if (!TryParseAttribute(name, ns, val, inlineCategories, version))
{
if (preserveAttributeExtensions)
{
inlineCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), await reader.GetValueAsync());
}
}
}
}
}
await SyndicationFeedFormatter.MoveToStartElementAsync(reader);
bool isEmptyElement = reader.IsEmptyElement;
await reader.ReadStartElementAsync();
if (!isEmptyElement)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
while (await reader.IsStartElementAsync())
{
if (await reader.IsStartElementAsync(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
{
SyndicationCategory category = CreateCategory(inlineCategories);
await Atom10FeedFormatter.ReadCategoryAsync(reader, category, version, preserveAttributeExtensions, preserveElementExtensions, _maxExtensionSize);
if (category.Scheme == null)
{
category.Scheme = inlineCategories.Scheme;
}
inlineCategories.Categories.Add(category);
}
else if (!TryParseElement(reader, inlineCategories, version))
{
if (preserveElementExtensions)
{
var tuple = await SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNodeAsync(buffer, extWriter, reader, _maxExtensionSize);
buffer = tuple.Item1;
extWriter = tuple.Item2;
}
else
{
await reader.SkipAsync();
}
}
}
LoadElementExtensions(buffer, extWriter, inlineCategories);
}
finally
{
if (extWriter != null)
{
extWriter.Close();
}
}
await reader.ReadEndElementAsync();
}
}
private static void ReadInlineCategories(XmlReader reader, InlineCategoriesDocument inlineCategories, Uri baseUri, string version, bool preserveElementExtensions, bool preserveAttributeExtensions, int maxExtensionSize)
{
inlineCategories.BaseUri = baseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if ((reader.LocalName == "base") && (reader.NamespaceURI == "http://www.w3.org/XML/1998/namespace"))
{
inlineCategories.BaseUri = FeedUtils.CombineXmlBase(inlineCategories.BaseUri, reader.Value);
}
else
{
if ((reader.LocalName == "lang") && (reader.NamespaceURI == "http://www.w3.org/XML/1998/namespace"))
{
inlineCategories.Language = reader.Value;
continue;
}
if ((reader.LocalName == "fixed") && (reader.NamespaceURI == string.Empty))
{
inlineCategories.IsFixed = reader.Value == "yes";
continue;
}
if ((reader.LocalName == "scheme") && (reader.NamespaceURI == string.Empty))
{
inlineCategories.Scheme = reader.Value;
continue;
}
string namespaceURI = reader.NamespaceURI;
string localName = reader.LocalName;
if (!FeedUtils.IsXmlns(localName, namespaceURI) && !FeedUtils.IsXmlSchemaType(localName, namespaceURI))
{
string str3 = reader.Value;
if (!ServiceDocumentFormatter.TryParseAttribute(localName, namespaceURI, str3, inlineCategories, version))
{
if (preserveAttributeExtensions)
{
inlineCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
continue;
}
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
}
}
}
}
}
SyndicationFeedFormatter.MoveToStartElement(reader);
bool isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmptyElement)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
while (reader.IsStartElement())
{
if (reader.IsStartElement("category", "http://www.w3.org/2005/Atom"))
{
SyndicationCategory category = ServiceDocumentFormatter.CreateCategory(inlineCategories);
Atom10FeedFormatter.ReadCategory(reader, category, version, preserveAttributeExtensions, preserveElementExtensions, maxExtensionSize);
if (category.Scheme == null)
{
category.Scheme = inlineCategories.Scheme;
}
inlineCategories.Categories.Add(category);
}
else if (!ServiceDocumentFormatter.TryParseElement(reader, inlineCategories, version))
{
if (preserveElementExtensions)
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
continue;
}
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
reader.Skip();
}
}
ServiceDocumentFormatter.LoadElementExtensions(buffer, extWriter, inlineCategories);
}
finally
{
if (extWriter != null)
{
extWriter.Close();
}
}
reader.ReadEndElement();
}
}
