using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
- using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.ServiceModel.Channels;
using System.Threading.Tasks;
using System.Xml;
- using System.Xml.Schema;
using System.Xml.Serialization;
[XmlRoot(ElementName = Atom10Constants.FeedTag, Namespace = Atom10Constants.Atom10Namespace)]
writer.WriteEndElement();
}
- internal static void ReadCategory(XmlReaderWrapper reader, SyndicationCategory category, string version, bool preserveAttributeExtensions, bool preserveElementExtensions, int maxExtensionSize)
+ internal static async Task ReadCategoryAsync(XmlReaderWrapper reader, SyndicationCategory category, string version, bool preserveAttributeExtensions, bool preserveElementExtensions, int _maxExtensionSize)
{
- MoveToStartElement(reader);
+ await MoveToStartElementAsync(reader);
bool isEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
- if (reader.LocalName == Atom10Constants.TermTag && reader.NamespaceURI == string.Empty)
- {
- category.Name = reader.Value;
- }
- else if (reader.LocalName == Atom10Constants.SchemeTag && reader.NamespaceURI == string.Empty)
+ string value = await reader.GetValueAsync();
+ bool notHandled = false;
+
+ if(reader.NamespaceURI == string.Empty)
{
- category.Scheme = reader.Value;
+ switch (reader.LocalName)
+ {
+ case Atom10Constants.TermTag:
+ category.Name = value;
+ break;
+
+ case Atom10Constants.SchemeTag:
+ category.Scheme = value;
+ break;
+
+ case Atom10Constants.LabelTag:
+ category.Label = value;
+ break;
+
+ default:
+ notHandled = true;
+ break;
+ }
}
- else if (reader.LocalName == Atom10Constants.LabelTag && reader.NamespaceURI == string.Empty)
+ else
{
- category.Label = reader.Value;
+ notHandled = true;
}
- else
+
+ if (notHandled)
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
{
continue;
}
- string val = reader.Value;
- if (!TryParseAttribute(name, ns, val, category, version))
+ if (!TryParseAttribute(name, ns, value, category, version))
{
if (preserveAttributeExtensions)
{
- category.AttributeExtensions.Add(new XmlQualifiedName(name, ns), val);
+ category.AttributeExtensions.Add(new XmlQualifiedName(name, ns), value);
}
}
}
if (!isEmpty)
{
- reader.ReadStartElement();
+ await reader.ReadStartElementAsync();
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
- while (reader.IsStartElement())
+ while (await reader.IsStartElementAsync())
{
if (TryParseElement(reader, category, version))
{
}
else if (!preserveElementExtensions)
{
- reader.Skip();
+ await reader.SkipAsync();
}
else
{
- CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
+ if (buffer == null)
+ {
+ buffer = new XmlBuffer(_maxExtensionSize);
+ extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
+ extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
+ }
+
+ await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
}
}
+
LoadElementExtensions(buffer, extWriter, category);
}
finally
((IDisposable)extWriter).Dispose();
}
}
- reader.ReadEndElement();
+
+ await reader.ReadEndElementAsync();
}
else
{
- reader.ReadStartElement();
+ await reader.ReadStartElementAsync();
}
}
- internal static TextSyndicationContent ReadTextContentFrom(XmlReaderWrapper reader, string context, bool preserveAttributeExtensions)
+ internal static async Task<TextSyndicationContent> ReadTextContentFromAsync(XmlReaderWrapper reader, string context, bool preserveAttributeExtensions)
{
string type = reader.GetAttribute(Atom10Constants.TypeTag);
- return ReadTextContentFromHelper(reader, type, context, preserveAttributeExtensions);
+ return await ReadTextContentFromHelper(reader, type, context, preserveAttributeExtensions);
}
- internal static void WriteCategory(XmlWriter writer, SyndicationCategory category, string version)
+ internal static void WriteCategory(XmlWriter writer, SyndicationCategory category, string version)
{
writer.WriteStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace);
WriteAttributeExtensions(writer, category, version);
writer.WriteEndElement();
}
- internal void ReadItemFrom(XmlReaderWrapper reader, SyndicationItem result)
+ internal async Task ReadItemFrom(XmlReaderWrapper reader, SyndicationItem result)
{
- ReadItemFrom(reader, result, null);
+ await ReadItemFromAsync(reader, result, null);
}
- internal bool TryParseFeedElementFrom(XmlReaderWrapper reader, SyndicationFeed result)
+ internal async Task<bool> TryParseFeedElementFromAsync(XmlReaderWrapper reader, SyndicationFeed result)
{
- if (reader.IsStartElement(Atom10Constants.AuthorTag, Atom10Constants.Atom10Namespace))
+ if (await reader.IsStartElementAsync(Atom10Constants.AuthorTag, Atom10Constants.Atom10Namespace))
{
- result.Authors.Add(ReadPersonFrom(reader, result));
+ result.Authors.Add(await ReadPersonFromAsync(reader, result));
}
- else if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
{
- result.Categories.Add(ReadCategoryFrom(reader, result));
+ result.Categories.Add(await ReadCategoryFromAsync(reader, result));
}
- else if (reader.IsStartElement(Atom10Constants.ContributorTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.ContributorTag, Atom10Constants.Atom10Namespace))
{
- result.Contributors.Add(ReadPersonFrom(reader, result));
+ result.Contributors.Add(await ReadPersonFromAsync(reader, result));
}
- else if (reader.IsStartElement(Atom10Constants.GeneratorTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.GeneratorTag, Atom10Constants.Atom10Namespace))
{
- result.Generator = reader.ReadElementString();
+ result.Generator = await reader.ReadElementStringAsync();
}
- else if (reader.IsStartElement(Atom10Constants.IdTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.IdTag, Atom10Constants.Atom10Namespace))
{
- result.Id = reader.ReadElementString();
+ result.Id = await reader.ReadElementStringAsync();
}
- else if (reader.IsStartElement(Atom10Constants.LinkTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.LinkTag, Atom10Constants.Atom10Namespace))
{
- result.Links.Add(ReadLinkFrom(reader, result));
+ result.Links.Add(await ReadLinkFromAsync(reader, result));
}
- else if (reader.IsStartElement(Atom10Constants.LogoTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.LogoTag, Atom10Constants.Atom10Namespace))
{
- result.ImageUrl = new Uri(reader.ReadElementString(), UriKind.RelativeOrAbsolute);
+ result.ImageUrl = new Uri(await reader.ReadElementStringAsync(), UriKind.RelativeOrAbsolute);
}
- else if (reader.IsStartElement(Atom10Constants.RightsTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.RightsTag, Atom10Constants.Atom10Namespace))
{
- result.Copyright = ReadTextContentFrom(reader, "//atom:feed/atom:rights[@type]");
+ result.Copyright = await ReadTextContentFromAsync(reader, "//atom:feed/atom:rights[@type]");
}
- else if (reader.IsStartElement(Atom10Constants.SubtitleTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.SubtitleTag, Atom10Constants.Atom10Namespace))
{
- result.Description = ReadTextContentFrom(reader, "//atom:feed/atom:subtitle[@type]");
+ result.Description = await ReadTextContentFromAsync(reader, "//atom:feed/atom:subtitle[@type]");
}
- else if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
{
- result.Title = ReadTextContentFrom(reader, "//atom:feed/atom:title[@type]");
+ result.Title = await ReadTextContentFromAsync(reader, "//atom:feed/atom:title[@type]");
}
- else if (reader.IsStartElement(Atom10Constants.UpdatedTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.UpdatedTag, Atom10Constants.Atom10Namespace))
{
- reader.ReadStartElement();
- result.LastUpdatedTime = DateFromString(reader.ReadString(), reader);
- reader.ReadEndElement();
+ await reader.ReadStartElementAsync();
+ result.LastUpdatedTime = DateFromString(await reader.ReadStringAsync(), reader);
+ await reader.ReadEndElementAsync();
}
else
{
return true;
}
- internal bool TryParseItemElementFrom(XmlReaderWrapper reader, SyndicationItem result)
+ internal async Task<bool> TryParseItemElementFromAsync(XmlReaderWrapper reader, SyndicationItem result)
{
- if (reader.IsStartElement(Atom10Constants.AuthorTag, Atom10Constants.Atom10Namespace))
+ if (await reader.IsStartElementAsync(Atom10Constants.AuthorTag, Atom10Constants.Atom10Namespace))
{
- result.Authors.Add(ReadPersonFrom(reader, result));
+ result.Authors.Add(await ReadPersonFromAsync(reader, result));
}
- else if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
{
- result.Categories.Add(ReadCategoryFrom(reader, result));
+ result.Categories.Add(await ReadCategoryFromAsync(reader, result));
}
- else if (reader.IsStartElement(Atom10Constants.ContentTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.ContentTag, Atom10Constants.Atom10Namespace))
{
- result.Content = ReadContentFrom(reader, result);
+ result.Content = await ReadContentFromAsync(reader, result);
}
- else if (reader.IsStartElement(Atom10Constants.ContributorTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.ContributorTag, Atom10Constants.Atom10Namespace))
{
- result.Contributors.Add(ReadPersonFrom(reader, result));
+ result.Contributors.Add(await ReadPersonFromAsync(reader, result));
}
- else if (reader.IsStartElement(Atom10Constants.IdTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.IdTag, Atom10Constants.Atom10Namespace))
{
- result.Id = reader.ReadElementString();
+ result.Id = await reader.ReadElementStringAsync();
}
- else if (reader.IsStartElement(Atom10Constants.LinkTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.LinkTag, Atom10Constants.Atom10Namespace))
{
- result.Links.Add(ReadLinkFrom(reader, result));
+ result.Links.Add(await ReadLinkFromAsync(reader, result));
}
- else if (reader.IsStartElement(Atom10Constants.PublishedTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.PublishedTag, Atom10Constants.Atom10Namespace))
{
- reader.ReadStartElement();
- result.PublishDate = DateFromString(reader.ReadString(), reader);
- reader.ReadEndElement();
+ await reader.ReadStartElementAsync();
+ result.PublishDate = DateFromString(await reader.ReadStringAsync(), reader);
+ await reader.ReadEndElementAsync();
}
- else if (reader.IsStartElement(Atom10Constants.RightsTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.RightsTag, Atom10Constants.Atom10Namespace))
{
- result.Copyright = ReadTextContentFrom(reader, "//atom:feed/atom:entry/atom:rights[@type]");
+ result.Copyright = await ReadTextContentFromAsync(reader, "//atom:feed/atom:entry/atom:rights[@type]");
}
- else if (reader.IsStartElement(Atom10Constants.SourceFeedTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.SourceFeedTag, Atom10Constants.Atom10Namespace))
{
- reader.ReadStartElement();
- result.SourceFeed = ReadFeedFrom(reader, new SyndicationFeed(), true); // isSourceFeed
- reader.ReadEndElement();
+ await reader.ReadStartElementAsync();
+ result.SourceFeed = await ReadFeedFromAsync(reader, new SyndicationFeed(), true); // isSourceFeed
+ await reader.ReadEndElementAsync();
}
- else if (reader.IsStartElement(Atom10Constants.SummaryTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.SummaryTag, Atom10Constants.Atom10Namespace))
{
- result.Summary = ReadTextContentFrom(reader, "//atom:feed/atom:entry/atom:summary[@type]");
+ result.Summary = await ReadTextContentFromAsync(reader, "//atom:feed/atom:entry/atom:summary[@type]");
}
- else if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
{
- result.Title = ReadTextContentFrom(reader, "//atom:feed/atom:entry/atom:title[@type]");
+ result.Title = await ReadTextContentFromAsync(reader, "//atom:feed/atom:entry/atom:title[@type]");
}
- else if (reader.IsStartElement(Atom10Constants.UpdatedTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.UpdatedTag, Atom10Constants.Atom10Namespace))
{
- reader.ReadStartElement();
- result.LastUpdatedTime = DateFromString(reader.ReadString(), reader);
- reader.ReadEndElement();
+ await reader.ReadStartElementAsync();
+ result.LastUpdatedTime = DateFromString(await reader.ReadStringAsync(), reader);
+ await reader.ReadEndElementAsync();
}
else
{
return SyndicationFeedFormatter.CreateFeedInstance(_feedType);
}
- protected virtual SyndicationItem ReadItem(XmlReaderWrapper reader, SyndicationFeed feed)
+ protected virtual async Task<SyndicationItem> ReadItemAsync(XmlReaderWrapper reader, SyndicationFeed feed)
{
if (feed == null)
{
throw new ArgumentNullException("reader");
}
SyndicationItem item = CreateItem(feed);
- ReadItemFrom(reader, item, feed.BaseUri);
+ await ReadItemFromAsync(reader, item, feed.BaseUri);
return item;
}
- [SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", MessageId = "2#", Justification = "The out parameter is needed to enable implementations that read in items from the stream on demand")]
- protected virtual IEnumerable<SyndicationItem> ReadItems(XmlReaderWrapper reader, SyndicationFeed feed, out bool areAllItemsRead)
+ protected virtual async Task<IEnumerable<SyndicationItem>> ReadItemsAsync(XmlReaderWrapper reader, SyndicationFeed feed)
{
if (feed == null)
{
throw new ArgumentNullException("reader");
}
NullNotAllowedCollection<SyndicationItem> items = new NullNotAllowedCollection<SyndicationItem>();
- while (reader.IsStartElement(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace))
+ while (await reader.IsStartElementAsync(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace))
{
- items.Add(ReadItem(reader, feed));
+ items.Add(await ReadItemAsync(reader, feed));
}
- areAllItemsRead = true;
+
return items;
}
}
}
- private static TextSyndicationContent ReadTextContentFromHelper(XmlReaderWrapper reader, string type, string context, bool preserveAttributeExtensions)
+ private static async Task<TextSyndicationContent> ReadTextContentFromHelper(XmlReaderWrapper reader, string type, string context, bool preserveAttributeExtensions)
{
if (string.IsNullOrEmpty(type))
{
}
if (preserveAttributeExtensions)
{
- string value = reader.Value;
+ string value = await reader.GetValueAsync();
if (attrs == null)
{
attrs = new Dictionary<XmlQualifiedName, string>();
}
}
reader.MoveToElement();
- string val = (kind == TextSyndicationContentKind.XHtml) ? reader.ReadInnerXml() : reader.ReadElementString();
+ string val = (kind == TextSyndicationContentKind.XHtml) ? await reader.ReadInnerXmlAsync() : await reader.ReadElementStringAsync();
TextSyndicationContent result = new TextSyndicationContent(val, kind);
if (attrs != null)
{
throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDateTime));
}
- private void ReadCategory(XmlReaderWrapper reader, SyndicationCategory category)
+ private async Task ReadCategory(XmlReaderWrapper reader, SyndicationCategory category)
{
- ReadCategory(reader, category, this.Version, this.PreserveAttributeExtensions, this.PreserveElementExtensions, _maxExtensionSize);
+ await ReadCategoryAsync(reader, category, this.Version, this.PreserveAttributeExtensions, this.PreserveElementExtensions, _maxExtensionSize);
}
- private SyndicationCategory ReadCategoryFrom(XmlReaderWrapper reader, SyndicationFeed feed)
+ private async Task<SyndicationCategory> ReadCategoryFromAsync(XmlReaderWrapper reader, SyndicationFeed feed)
{
SyndicationCategory result = CreateCategory(feed);
- ReadCategory(reader, result);
+ await ReadCategory(reader, result);
return result;
}
- private SyndicationCategory ReadCategoryFrom(XmlReaderWrapper reader, SyndicationItem item)
+ private async Task<SyndicationCategory> ReadCategoryFromAsync(XmlReaderWrapper reader, SyndicationItem item)
{
SyndicationCategory result = CreateCategory(item);
- ReadCategory(reader, result);
+ await ReadCategory(reader, result);
return result;
}
- private SyndicationContent ReadContentFrom(XmlReaderWrapper reader, SyndicationItem item)
+ private async Task<SyndicationContent> ReadContentFromAsync(XmlReaderWrapper reader, SyndicationItem item)
{
- MoveToStartElement(reader);
+ await MoveToStartElementAsync(reader);
string type = reader.GetAttribute(Atom10Constants.TypeTag, string.Empty);
SyndicationContent result;
{
if (_preserveAttributeExtensions)
{
- result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
+ result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), await reader.GetValueAsync());
}
}
}
}
- reader.ReadStartElement();
+ await reader.ReadStartElementAsync();
if (!isEmpty)
{
- reader.ReadEndElement();
+ await reader.ReadEndElementAsync();
}
return result;
}
else
{
- return ReadTextContentFromHelper(reader, type, "//atom:feed/atom:entry/atom:content[@type]", _preserveAttributeExtensions);
+ return await ReadTextContentFromHelper(reader, type, "//atom:feed/atom:entry/atom:content[@type]", _preserveAttributeExtensions);
}
}
{
if (reader.LocalName == "lang" && reader.NamespaceURI == XmlNs)
{
- result.Language = reader.Value;
+ result.Language = await reader.GetValueAsync();
}
else if (reader.LocalName == "base" && reader.NamespaceURI == XmlNs)
{
- result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
+ result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, await reader.GetValueAsync());
}
else
{
{
if (_preserveAttributeExtensions)
{
- result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
+ result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), await reader.GetValueAsync());
}
}
}
{
while (await reader.IsStartElementAsync())
{
- if (TryParseFeedElementFrom(reader, result)) //JERRY MAKE THIS ASYNC
+ if (await TryParseFeedElementFromAsync(reader, result)) //JERRY MAKE THIS ASYNC
{
// nothing, we parsed something, great
}
throw new InvalidOperationException(String.Format(SR.FeedHasNonContiguousItems, this.GetType().ToString()));
}
- result.Items = ReadItems(reader, result, out areAllItemsRead); // JERRY MAKE THIS ASYNC
+ result.Items = await ReadItemsAsync(reader, result); ; // JERRY MAKE THIS ASYNC
+ areAllItemsRead = true;
readItemsAtLeastOnce = true;
// if the derived class is reading the items lazily, then stop reading from the stream
if (!areAllItemsRead)
return result;
}
- private SyndicationFeed ReadFeedFrom(XmlReaderWrapper reader, SyndicationFeed result, bool isSourceFeed) //JERRY REMOVE THIS METHOD AND USE THE ONE ABOVE
+ private async Task<SyndicationFeed> ReadFeedFrom(XmlReaderWrapper reader, SyndicationFeed result, bool isSourceFeed) //JERRY REMOVE THIS METHOD AND USE THE ONE ABOVE
{
- reader.MoveToContent();
+ await reader.MoveToContentAsync();
try
{
bool elementIsEmpty = false;
if (!isSourceFeed)
{
- MoveToStartElement(reader);
+ await MoveToStartElementAsync(reader);
elementIsEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
{
if (reader.LocalName == "lang" && reader.NamespaceURI == XmlNs)
{
- result.Language = reader.Value;
+ result.Language = await reader.GetValueAsync();
}
else if (reader.LocalName == "base" && reader.NamespaceURI == XmlNs)
{
- result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
+ result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, await reader.GetValueAsync());
}
else
{
{
continue;
}
- string val = reader.Value;
+ string val = await reader.GetValueAsync();
if (!TryParseAttribute(name, ns, val, result, this.Version))
{
if (_preserveAttributeExtensions)
}
}
}
- reader.ReadStartElement();
+ await reader.ReadStartElementAsync();
}
XmlBuffer buffer = null;
{
try
{
- while (reader.IsStartElement())
+ while (await reader.IsStartElementAsync())
{
- if (TryParseFeedElementFrom(reader, result))
+ if (await TryParseFeedElementFromAsync(reader, result))
{
// nothing, we parsed something, great
}
- else if (reader.IsStartElement(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace) && !isSourceFeed)
+ else if (await reader.IsStartElementAsync(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace) && !isSourceFeed)
{
if (readItemsAtLeastOnce)
{
throw new InvalidOperationException(String.Format(SR.FeedHasNonContiguousItems, this.GetType().ToString()));
}
- result.Items = ReadItems(reader, result, out areAllItemsRead);
+
+ //result.Items = ReadItems(reader, result, out areAllItemsRead);
+ result.Items = await ReadItemsAsync(reader, result);
+ areAllItemsRead = true;
readItemsAtLeastOnce = true;
// if the derived class is reading the items lazily, then stop reading from the stream
if (!areAllItemsRead)
{
if (_preserveElementExtensions)
{
- CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
+ if (buffer == null)
+ {
+ buffer = new XmlBuffer(_maxExtensionSize);
+ extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
+ extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
+ }
+
+ await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
}
else
{
- reader.Skip();
+ await reader.SkipAsync();
}
}
}
}
if (!isSourceFeed && areAllItemsRead)
{
- reader.ReadEndElement(); // feed
+ await reader.ReadEndElementAsync(); // feed
}
}
catch (FormatException e)
return result;
}
- private void ReadItemFrom(XmlReaderWrapper reader, SyndicationItem result, Uri feedBaseUri)
+ private async Task ReadItemFromAsync(XmlReaderWrapper reader, SyndicationItem result, Uri feedBaseUri)
{
try
{
result.BaseUri = feedBaseUri;
- MoveToStartElement(reader);
+ await MoveToStartElementAsync(reader);
bool isEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
string name = reader.LocalName;
if (name == "base" && ns == XmlNs)
{
- result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
+ result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, await reader.GetValueAsync());
continue;
}
+
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
- string val = reader.Value;
+
+ string val = await reader.GetValueAsync();
if (!TryParseAttribute(name, ns, val, result, this.Version))
{
if (_preserveAttributeExtensions)
}
}
}
- reader.ReadStartElement();
+ await reader.ReadStartElementAsync();
+
if (!isEmpty)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
- while (reader.IsStartElement())
+ while (await reader.IsStartElementAsync())
{
- if (TryParseItemElementFrom(reader, result))
+ if (await TryParseItemElementFromAsync(reader, result))
{
// nothing, we parsed something, great
}
{
if (_preserveElementExtensions)
{
- CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
+ if (buffer == null)
+ {
+ buffer = new XmlBuffer(_maxExtensionSize);
+ extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
+ extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
+ }
+
+ await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
}
else
{
- reader.Skip();
+ await reader.SkipAsync();
}
}
}
((IDisposable)extWriter).Dispose();
}
}
- reader.ReadEndElement(); // item
+ await reader.ReadEndElementAsync(); // item
}
}
catch (FormatException e)
{
throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingItem), e);
+
}
catch (ArgumentException e)
{
}
}
- private void ReadLink(XmlReaderWrapper reader, SyndicationLink link, Uri baseUri)
+ private async Task ReadLinkAsync(XmlReaderWrapper reader, SyndicationLink link, Uri baseUri)
{
bool isEmpty = reader.IsEmptyElement;
string mediaType = null;
{
while (reader.MoveToNextAttribute())
{
+ bool notHandled = false;
if (reader.LocalName == "base" && reader.NamespaceURI == XmlNs)
{
- link.BaseUri = FeedUtils.CombineXmlBase(link.BaseUri, reader.Value);
+ link.BaseUri = FeedUtils.CombineXmlBase(link.BaseUri, await reader.GetValueAsync());
}
- else if (reader.LocalName == Atom10Constants.TypeTag && reader.NamespaceURI == string.Empty)
+ else if(reader.NamespaceURI == string.Empty)
{
- mediaType = reader.Value;
- }
- else if (reader.LocalName == Atom10Constants.RelativeTag && reader.NamespaceURI == string.Empty)
- {
- relationship = reader.Value;
- }
- else if (reader.LocalName == Atom10Constants.TitleTag && reader.NamespaceURI == string.Empty)
- {
- title = reader.Value;
- }
- else if (reader.LocalName == Atom10Constants.LengthTag && reader.NamespaceURI == string.Empty)
- {
- lengthStr = reader.Value;
+ switch (reader.LocalName)
+ {
+ case Atom10Constants.TypeTag:
+ mediaType = await reader.GetValueAsync();
+ break;
+
+ case Atom10Constants.RelativeTag:
+ relationship = await reader.GetValueAsync();
+ break;
+
+ case Atom10Constants.TitleTag:
+ title = await reader.GetValueAsync();
+ break;
+
+ case Atom10Constants.LengthTag:
+ lengthStr = await reader.GetValueAsync();
+ break;
+
+ case Atom10Constants.HrefTag:
+ val = await reader.GetValueAsync();
+ break;
+
+ default:
+ notHandled = true;
+ break;
+ }
}
- else if (reader.LocalName == Atom10Constants.HrefTag && reader.NamespaceURI == string.Empty)
+ else
{
- val = reader.Value;
+ notHandled = true;
}
- else if (!FeedUtils.IsXmlns(reader.LocalName, reader.NamespaceURI))
+
+ if (notHandled && !FeedUtils.IsXmlns(reader.LocalName, reader.NamespaceURI))
{
if (_preserveAttributeExtensions)
{
- link.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
+ link.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), await reader.GetValueAsync());
}
}
+
+ //if (reader.LocalName == "base" && reader.NamespaceURI == XmlNs)
+ //{
+ // link.BaseUri = FeedUtils.CombineXmlBase(link.BaseUri, await reader.GetValueAsync());
+ //}
+ //else if (reader.LocalName == Atom10Constants.TypeTag && reader.NamespaceURI == string.Empty)
+ //{
+ // mediaType = await reader.GetValueAsync();
+ //}
+ //else if (reader.LocalName == Atom10Constants.RelativeTag && reader.NamespaceURI == string.Empty)
+ //{
+ // relationship = await reader.GetValueAsync();
+ //}
+ //else if (reader.LocalName == Atom10Constants.TitleTag && reader.NamespaceURI == string.Empty)
+ //{
+ // title = await reader.GetValueAsync();
+ //}
+ //else if (reader.LocalName == Atom10Constants.LengthTag && reader.NamespaceURI == string.Empty)
+ //{
+ // lengthStr = await reader.GetValueAsync();
+ //}
+ //else if (reader.LocalName == Atom10Constants.HrefTag && reader.NamespaceURI == string.Empty)
+ //{
+ // val = await reader.GetValueAsync();
+ //}
+ //else if (!FeedUtils.IsXmlns(reader.LocalName, reader.NamespaceURI))
+ //{
+ // if (_preserveAttributeExtensions)
+ // {
+ // link.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), await reader.GetValueAsync());
+ // }
+ //}
}
}
{
length = Convert.ToInt64(lengthStr, CultureInfo.InvariantCulture.NumberFormat);
}
- reader.ReadStartElement();
+
+ await reader.ReadStartElementAsync();
if (!isEmpty)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
- while (reader.IsStartElement())
+ while (await reader.IsStartElementAsync())
{
if (TryParseElement(reader, link, this.Version))
{
}
else if (!_preserveElementExtensions)
{
- reader.Skip();
+ await reader.SkipAsync();
}
else
{
- CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
+ if (buffer == null)
+ {
+ buffer = new XmlBuffer(_maxExtensionSize);
+ extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
+ extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
+ }
+
+ await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
}
}
LoadElementExtensions(buffer, extWriter, link);
((IDisposable)extWriter).Dispose();
}
}
- reader.ReadEndElement();
+ await reader.ReadEndElementAsync();
}
link.Length = length;
link.MediaType = mediaType;
link.Uri = (val != null) ? new Uri(val, UriKind.RelativeOrAbsolute) : null;
}
- private SyndicationLink ReadLinkFrom(XmlReaderWrapper reader, SyndicationFeed feed)
+ private async Task<SyndicationLink> ReadLinkFromAsync(XmlReaderWrapper reader, SyndicationFeed feed)
{
SyndicationLink result = CreateLink(feed);
- ReadLink(reader, result, feed.BaseUri);
+ await ReadLinkAsync(reader, result, feed.BaseUri);
return result;
}
- private SyndicationLink ReadLinkFrom(XmlReaderWrapper reader, SyndicationItem item)
+ private async Task<SyndicationLink> ReadLinkFromAsync(XmlReaderWrapper reader, SyndicationItem item)
{
SyndicationLink result = CreateLink(item);
- ReadLink(reader, result, item.BaseUri);
+ await ReadLinkAsync(reader, result, item.BaseUri);
return result;
}
- private SyndicationPerson ReadPersonFrom(XmlReaderWrapper reader, SyndicationFeed feed)
+ private async Task<SyndicationPerson> ReadPersonFromAsync(XmlReaderWrapper reader, SyndicationFeed feed)
{
SyndicationPerson result = CreatePerson(feed);
- ReadPersonFrom(reader, result);
+ await ReadPersonFromAsync(reader, result);
return result;
}
- private SyndicationPerson ReadPersonFrom(XmlReaderWrapper reader, SyndicationItem item)
+ private async Task<SyndicationPerson> ReadPersonFromAsync(XmlReaderWrapper reader, SyndicationItem item)
{
SyndicationPerson result = CreatePerson(item);
- ReadPersonFrom(reader, result);
+ await ReadPersonFromAsync(reader, result);
return result;
}
- private void ReadPersonFrom(XmlReaderWrapper reader, SyndicationPerson result)
+ private async Task ReadPersonFromAsync(XmlReaderWrapper reader, SyndicationPerson result)
{
bool isEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
continue;
}
- string val = reader.Value;
+ string val = await reader.GetValueAsync();
if (!TryParseAttribute(name, ns, val, result, this.Version))
{
if (_preserveAttributeExtensions)
{
- result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
+ result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), await reader.GetValueAsync());
}
}
}
}
- reader.ReadStartElement();
+ await reader.ReadStartElementAsync();
if (!isEmpty)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
- while (reader.IsStartElement())
+ while (await reader.IsStartElementAsync())
{
- if (reader.IsStartElement(Atom10Constants.NameTag, Atom10Constants.Atom10Namespace))
+ if (await reader.IsStartElementAsync(Atom10Constants.NameTag, Atom10Constants.Atom10Namespace))
{
- result.Name = reader.ReadElementString();
+ result.Name = await reader.ReadElementStringAsync();
}
- else if (reader.IsStartElement(Atom10Constants.UriTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.UriTag, Atom10Constants.Atom10Namespace))
{
- result.Uri = reader.ReadElementString();
+ result.Uri = await reader.ReadElementStringAsync();
}
- else if (reader.IsStartElement(Atom10Constants.EmailTag, Atom10Constants.Atom10Namespace))
+ else if (await reader.IsStartElementAsync(Atom10Constants.EmailTag, Atom10Constants.Atom10Namespace))
{
- result.Email = reader.ReadElementString();
+ result.Email = await reader.ReadElementStringAsync();
}
else
{
{
if (_preserveElementExtensions)
{
- CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
+ if (buffer == null)
+ {
+ buffer = new XmlBuffer(_maxExtensionSize);
+ extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
+ extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
+ }
+
+ await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
}
else
{
- reader.Skip();
+ await reader.SkipAsync();
}
}
}
((IDisposable)extWriter).Dispose();
}
}
- reader.ReadEndElement();
+ await reader.ReadEndElementAsync();
}
}
- private TextSyndicationContent ReadTextContentFrom(XmlReaderWrapper reader, string context)
+ private async Task<TextSyndicationContent> ReadTextContentFromAsync(XmlReaderWrapper reader, string context)
{
- return ReadTextContentFrom(reader, context, this.PreserveAttributeExtensions);
+ return await ReadTextContentFromAsync(reader, context, this.PreserveAttributeExtensions);
}
private void WriteCategoriesTo(XmlWriter writer, Collection<SyndicationCategory> categories)
}
}
- [TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
[XmlRoot(ElementName = Atom10Constants.FeedTag, Namespace = Atom10Constants.Atom10Namespace)]
public class Atom10FeedFormatter<TSyndicationFeed> : Atom10FeedFormatter
where TSyndicationFeed : SyndicationFeed, new()
throw new XmlException(String.Format(SR.UnknownItemXml, reader.LocalName, reader.NamespaceURI));
}
- ReadItem(reader);
+ await ReadItem(reader);
}
public override void WriteTo(XmlWriter writer)
return SyndicationItemFormatter.CreateItemInstance(_itemType);
}
- private void ReadItem(XmlReader reader)
+ private async Task ReadItem(XmlReader reader)
{
SetItem(CreateItemInstance());
- _feedSerializer.ReadItemFrom(XmlReaderWrapper.CreateFromReader(XmlDictionaryReader.CreateDictionaryReader(reader)), this.Item);
+ await _feedSerializer.ReadItemFrom(XmlReaderWrapper.CreateFromReader(XmlDictionaryReader.CreateDictionaryReader(reader)), this.Item);
}
private void WriteItem(XmlWriter writer)
using Microsoft.ServiceModel.Syndication.Resources;
using System;
- using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
+ using System.Threading.Tasks;
using System.Xml;
- using System.Xml.Schema;
using System.Xml.Serialization;
[TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
get { return App10Constants.Namespace; }
}
- public override bool CanRead(XmlReaderWrapper reader)
- {
+ public override async Task<bool> CanReadAsync(XmlReader reader)
+ {
if (reader == null)
{
throw new ArgumentNullException("reader");
}
- return reader.IsStartElement(App10Constants.Categories, App10Constants.Namespace);
+ XmlReaderWrapper wrappedReader = XmlReaderWrapper.CreateFromReader(reader);
+ return await wrappedReader.IsStartElementAsync(App10Constants.Categories, App10Constants.Namespace);
}
- void ReadXml(XmlReaderWrapper reader)
+ async Task ReadXmlAsync(XmlReaderWrapper reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
- ReadDocument(reader);
+ await ReadDocumentAsync(reader);
}
void WriteXml(XmlWriter writer)
WriteDocument(writer);
}
- public override void ReadFrom(XmlReaderWrapper reader)
+ public override async Task ReadFrom(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
- if (!CanRead(reader))
+ if (!await CanReadAsync(reader))
{
throw new XmlException(String.Format(SR.UnknownDocumentXml, reader.LocalName, reader.NamespaceURI));
}
- ReadDocument(reader);
+
+ await ReadDocumentAsync(XmlReaderWrapper.CreateFromReader(reader));
}
public override void WriteTo(XmlWriter writer)
}
}
- private void ReadDocument(XmlReaderWrapper reader)
+ private async Task ReadDocumentAsync(XmlReaderWrapper reader)
{
try
{
- SyndicationFeedFormatter.MoveToStartElement(reader);
+ await SyndicationFeedFormatter.MoveToStartElementAsync(reader);
SetDocument(AtomPub10ServiceDocumentFormatter.ReadCategories(reader, null,
delegate ()
{
this.Version,
_preserveElementExtensions,
_preserveAttributeExtensions,
- _maxExtensionSize));
+ _maxExtensionSize).Result);
}
catch (FormatException e)
{
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
+ using System.Threading.Tasks;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
get { return App10Constants.Namespace; }
}
- public override bool CanRead(XmlReaderWrapper reader)
+ public override async Task<bool> CanReadAsync(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
- return reader.IsStartElement(App10Constants.Service, App10Constants.Namespace);
- }
-
+ XmlReaderWrapper readerWrapper = XmlReaderWrapper.CreateFromReader(reader);
+ return await readerWrapper.IsStartElementAsync(App10Constants.Service, App10Constants.Namespace);
+ }
- void ReadXml(XmlReaderWrapper reader)
+ async Task ReadXml(XmlReaderWrapper reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
- ReadDocument(reader);
+ await ReadDocumentAsync(reader);
}
void WriteXml(XmlWriter writer)
WriteDocument(writer);
}
- public override void ReadFrom(XmlReaderWrapper reader)
+ public override async Task ReadFromAsync(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
- reader.MoveToContent();
- if (!CanRead(reader))
+
+ XmlReaderWrapper wrappedReader = XmlReaderWrapper.CreateFromReader(reader);
+ await wrappedReader.MoveToContentAsync();
+
+ if (!await CanReadAsync(reader))
{
throw new XmlException(String.Format(SR.UnknownDocumentXml, reader.LocalName, reader.NamespaceURI));
}
- ReadDocument(reader);
+
+ await ReadDocumentAsync(wrappedReader);
}
public override void WriteTo(XmlWriter writer)
writer.WriteEndElement();
}
- internal static CategoriesDocument ReadCategories(XmlReaderWrapper reader, Uri baseUri, CreateInlineCategoriesDelegate inlineCategoriesFactory, CreateReferencedCategoriesDelegate referencedCategoriesFactory, string version, bool preserveElementExtensions, bool preserveAttributeExtensions, int maxExtensionSize)
+ internal static async Task<CategoriesDocument> ReadCategories(XmlReaderWrapper reader, Uri baseUri, CreateInlineCategoriesDelegate inlineCategoriesFactory, CreateReferencedCategoriesDelegate referencedCategoriesFactory, string version, bool preserveElementExtensions, bool preserveAttributeExtensions, int maxExtensionSize)
{
string link = reader.GetAttribute(App10Constants.Href, string.Empty);
if (string.IsNullOrEmpty(link))
{
InlineCategoriesDocument inlineCategories = inlineCategoriesFactory();
- ReadInlineCategories(reader, inlineCategories, baseUri, version, preserveElementExtensions, preserveAttributeExtensions, maxExtensionSize);
+ await ReadInlineCategoriesAsync(reader, inlineCategories, baseUri, version, preserveElementExtensions, preserveAttributeExtensions, maxExtensionSize);
return inlineCategories;
}
else
{
ReferencedCategoriesDocument referencedCategories = referencedCategoriesFactory();
- ReadReferencedCategories(reader, referencedCategories, baseUri, new Uri(link, UriKind.RelativeOrAbsolute), version, preserveElementExtensions, preserveAttributeExtensions, maxExtensionSize);
+ await ReadReferencedCategories(reader, referencedCategories, baseUri, new Uri(link, UriKind.RelativeOrAbsolute), version, preserveElementExtensions, preserveAttributeExtensions, maxExtensionSize);
return referencedCategories;
}
}
}
}
- private static void ReadInlineCategories(XmlReaderWrapper reader, InlineCategoriesDocument inlineCategories, Uri baseUri, string version, bool preserveElementExtensions, bool preserveAttributeExtensions, int maxExtensionSize)
+ 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)
}
}
}
- SyndicationFeedFormatter.MoveToStartElement(reader);
+ await SyndicationFeedFormatter.MoveToStartElementAsync(reader);
bool isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmptyElement)
if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
{
SyndicationCategory category = CreateCategory(inlineCategories);
- Atom10FeedFormatter.ReadCategory(reader, category, version, preserveAttributeExtensions, preserveElementExtensions, maxExtensionSize);
+ await Atom10FeedFormatter.ReadCategoryAsync(reader, category, version, preserveAttributeExtensions, preserveElementExtensions, maxExtensionSize);
if (category.Scheme == null)
{
category.Scheme = inlineCategories.Scheme;
{
if (preserveElementExtensions)
{
- SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
+ if (buffer == null)
+ {
+ buffer = new XmlBuffer(maxExtensionSize);
+ extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
+ extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
+ }
+
+ await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
}
else
{
- reader.Skip();
+ await reader.SkipAsync();
}
}
}
}
}
- private static void ReadReferencedCategories(XmlReaderWrapper reader, ReferencedCategoriesDocument referencedCategories, Uri baseUri, Uri link, string version, bool preserveElementExtensions, bool preserveAttributeExtensions, int maxExtensionSize)
+ private static async Task ReadReferencedCategories(XmlReaderWrapper reader, ReferencedCategoriesDocument referencedCategories, Uri baseUri, Uri link, string version, bool preserveElementExtensions, bool preserveAttributeExtensions, int maxExtensionSize)
{
referencedCategories.BaseUri = baseUri;
referencedCategories.Link = link;
{
if (preserveElementExtensions)
{
- SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
+ if (buffer == null)
+ {
+ buffer = new XmlBuffer(maxExtensionSize);
+ extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
+ extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
+ }
+
+ await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
}
}
}
writer.WriteAttributeString("xml", "lang", Atom10FeedFormatter.XmlNs, lang);
}
- private ResourceCollectionInfo ReadCollection(XmlReaderWrapper reader, Workspace workspace)
+ private async Task<ResourceCollectionInfo> ReadCollection(XmlReaderWrapper reader, Workspace workspace)
{
ResourceCollectionInfo result = CreateCollection(workspace);
result.BaseUri = workspace.BaseUri;
{
if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
{
- result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/app:collection/atom:title[@type]", _preserveAttributeExtensions);
+ result.Title = await Atom10FeedFormatter.ReadTextContentFromAsync(reader, "//app:service/app:workspace/app:collection/atom:title[@type]", _preserveAttributeExtensions);
}
else if (reader.IsStartElement(App10Constants.Categories, App10Constants.Namespace))
{
this.Version,
_preserveElementExtensions,
_preserveAttributeExtensions,
- _maxExtensionSize));
+ _maxExtensionSize).Result);
}
else if (reader.IsStartElement(App10Constants.Accept, App10Constants.Namespace))
{
{
if (_preserveElementExtensions)
{
- SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
+ if (buffer == null)
+ {
+ buffer = new XmlBuffer(_maxExtensionSize);
+ extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
+ extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
+ }
+
+ await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
}
else
{
return result;
}
- private void ReadDocument(XmlReaderWrapper reader)
+ private async Task ReadDocumentAsync(XmlReaderWrapper reader)
{
ServiceDocument result = CreateDocumentInstance();
try
{
- SyndicationFeedFormatter.MoveToStartElement(reader);
+ await SyndicationFeedFormatter.MoveToStartElementAsync(reader);
bool elementIsEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
{
if (reader.IsStartElement(App10Constants.Workspace, App10Constants.Namespace))
{
- result.Workspaces.Add(ReadWorkspace(reader, result));
+ result.Workspaces.Add(ReadWorkspace(reader, result).Result);
}
else if (!TryParseElement(reader, result, this.Version))
{
if (_preserveElementExtensions)
{
- SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
+ if (buffer == null)
+ {
+ buffer = new XmlBuffer(_maxExtensionSize);
+ extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
+ extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
+ }
+
+ await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
}
else
{
- reader.Skip();
+ await reader.SkipAsync();
}
}
}
SetDocument(result);
}
- private Workspace ReadWorkspace(XmlReaderWrapper reader, ServiceDocument document)
+ private async Task<Workspace> ReadWorkspace(XmlReaderWrapper reader, ServiceDocument document)
{
Workspace result = CreateWorkspace(document);
result.BaseUri = document.BaseUri;
{
if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
{
- result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/atom:title[@type]", _preserveAttributeExtensions);
+ result.Title = await Atom10FeedFormatter.ReadTextContentFromAsync(reader, "//app:service/app:workspace/atom:title[@type]", _preserveAttributeExtensions);
}
else if (reader.IsStartElement(App10Constants.Collection, App10Constants.Namespace))
{
- result.Collections.Add(ReadCollection(reader, result));
+ result.Collections.Add(ReadCollection(reader, result).Result);
}
else if (!TryParseElement(reader, result, this.Version))
{
if (_preserveElementExtensions)
{
- SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
+ if (buffer == null)
+ {
+ buffer = new XmlBuffer(_maxExtensionSize);
+ extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
+ extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
+ }
+
+ await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
}
else
{
- reader.Skip();
+ await reader.SkipAsync();
}
}
}
using System;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
+ using System.Threading.Tasks;
using System.Xml;
- [TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
- [DataContract]
public abstract class CategoriesDocumentFormatter
{
private CategoriesDocument _document;
public abstract string Version
{ get; }
- public abstract bool CanRead(XmlReaderWrapper reader);
- public abstract void ReadFrom(XmlReaderWrapper reader);
+ public abstract Task<bool> CanReadAsync(XmlReader reader);
+ public abstract Task ReadFrom(XmlReader reader);
public abstract void WriteTo(XmlWriter writer);
protected virtual InlineCategoriesDocument CreateInlineCategoriesDocument()
if (notHandled)
{
- bool parsedExtension = _serializeExtensionsAsAtom && _atomSerializer.TryParseItemElementFrom(reader, result);
+ bool parsedExtension = _serializeExtensionsAsAtom && _atomSerializer.TryParseItemElementFromAsync(reader, result).Result;
if (!parsedExtension)
{
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
- link.BaseUri = FeedUtils.CombineXmlBase(link.BaseUri, reader.Value);
+ link.BaseUri = FeedUtils.CombineXmlBase(link.BaseUri, await reader.GetValueAsync());
}
else if (!FeedUtils.IsXmlns(reader.LocalName, reader.NamespaceURI))
{
if (notHandled)
{
- bool parsedExtension = _serializeExtensionsAsAtom && _atomSerializer.TryParseFeedElementFrom(reader, result);
+ bool parsedExtension = _serializeExtensionsAsAtom && await _atomSerializer.TryParseFeedElementFromAsync(reader, result);
if (!parsedExtension)
{
}
}
- //private void ReadXml(XmlReaderWrapper reader, SyndicationFeed result)
- //{
- // try
- // {
- // string baseUri = null;
- // reader.MoveToContent();
- // string version = reader.GetAttribute(Rss20Constants.VersionTag, Rss20Constants.Rss20Namespace);
- // if (version != Rss20Constants.Version)
- // {
- // throw new NotSupportedException(FeedUtils.AddLineInfo(reader, (String.Format(SR.UnsupportedRssVersion, version))));
- // }
- // if (reader.AttributeCount > 1)
- // {
- // string tmp = reader.GetAttribute("base", Atom10FeedFormatter.XmlNs);
- // if (!string.IsNullOrEmpty(tmp))
- // {
- // baseUri = tmp;
- // }
- // }
- // reader.ReadStartElement();
- // reader.MoveToContent();
- // if (reader.HasAttributes)
- // {
- // while (reader.MoveToNextAttribute())
- // {
- // string ns = reader.NamespaceURI;
- // string name = reader.LocalName;
- // if (name == "base" && ns == Atom10FeedFormatter.XmlNs)
- // {
- // baseUri = reader.Value;
- // continue;
- // }
- // if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
- // {
- // continue;
- // }
- // string val = reader.Value;
- // if (!TryParseAttribute(name, ns, val, result, this.Version))
- // {
- // if (_preserveAttributeExtensions)
- // {
- // result.AttributeExtensions.Add(new XmlQualifiedName(name, ns), val);
- // }
- // }
- // }
- // }
- // if (!string.IsNullOrEmpty(baseUri))
- // {
- // result.BaseUri = new Uri(baseUri, UriKind.RelativeOrAbsolute);
- // }
- // bool areAllItemsRead = true;
- // bool readItemsAtLeastOnce = false;
- // reader.ReadStartElement(Rss20Constants.ChannelTag, Rss20Constants.Rss20Namespace);
-
- // XmlBuffer buffer = null;
- // XmlDictionaryWriter extWriter = null;
- // try
- // {
- // while (reader.IsStartElement())
- // {
- // string s = reader.Value + " " + reader.Name;
- // if (reader.IsStartElement(Rss20Constants.TitleTag, Rss20Constants.Rss20Namespace))
- // {
- // result.Title = TitleParser(reader);
- // }
- // else if (reader.IsStartElement(Rss20Constants.LinkTag, Rss20Constants.Rss20Namespace))
- // {
- // //result.Links.Add(ReadAlternateLink(reader, result.BaseUri));
- // result.Links.Add(OnReadLink(reader, result.BaseUri));
- // }
- // else if (reader.IsStartElement(Rss20Constants.DescriptionTag, Rss20Constants.Rss20Namespace))
- // {
- // result.Description = DescriptionParser(reader);
- // }
- // else if (reader.IsStartElement(Rss20Constants.LanguageTag, Rss20Constants.Rss20Namespace))
- // {
- // result.Language = LanguageParser(reader);
- // }
- // else if (reader.IsStartElement(Rss20Constants.CopyrightTag, Rss20Constants.Rss20Namespace))
- // {
- // result.Copyright = CopyrightParser(reader);
- // }
- // else if (reader.IsStartElement(Rss20Constants.ManagingEditorTag, Rss20Constants.Rss20Namespace))
- // {
- // //result.Authors.Add(ReadPerson(reader, result)); //original
- // result.Authors.Add(ManagingEditorParser(reader, result));
- // }
- // else if (reader.IsStartElement(Rss20Constants.LastBuildDateTag, Rss20Constants.Rss20Namespace))
- // {
- // //The code below is now handled by a delegate in CustomParsers
- // bool canReadContent = !reader.IsEmptyElement;
- // reader.ReadStartElement();
- // if (canReadContent)
- // {
- // string str = reader.ReadString();
- // if (!string.IsNullOrEmpty(str))
- // {
- // result.LastUpdatedTime = DateParser(str, reader); // <<=== here | original DateFromString(str, reader);
- // }
- // reader.ReadEndElement();
- // }
- // }
- // else if (reader.IsStartElement(Rss20Constants.CategoryTag, Rss20Constants.Rss20Namespace))
- // {
- // result.Categories.Add(ReadCategory(reader, result));
- // }
- // else if (reader.IsStartElement(Rss20Constants.GeneratorTag, Rss20Constants.Rss20Namespace))
- // {
- // result.Generator = GeneratorParser(reader);
- // }
- // else if (reader.IsStartElement(Rss20Constants.ImageTag, Rss20Constants.Rss20Namespace))
- // {
- // ImageParser(reader, result);
- // }
- // else if (reader.IsStartElement(Rss20Constants.ItemTag, Rss20Constants.Rss20Namespace))
- // {
- // if (readItemsAtLeastOnce)
- // {
- // throw new InvalidOperationException(String.Format(SR.FeedHasNonContiguousItems, this.GetType().ToString()));
- // }
-
- // result.Items = ReadItems(reader, result, out areAllItemsRead);
- // readItemsAtLeastOnce = true;
- // // if the derived class is reading the items lazily, then stop reading from the stream
- // if (!areAllItemsRead)
- // {
- // break;
- // }
- // }
- // else
- // {
- // bool parsedExtension = _serializeExtensionsAsAtom && _atomSerializer.TryParseFeedElementFrom(reader, result);
- // if (!parsedExtension)
- // {
- // parsedExtension = TryParseElement(reader, result, this.Version);
- // }
- // if (!parsedExtension)
- // {
- // if (_preserveElementExtensions)
- // {
- // CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
- // }
- // else
- // {
- // reader.Skip();
- // }
- // }
- // }
- // }
- // LoadElementExtensions(buffer, extWriter, result);
- // }
- // finally
- // {
- // if (extWriter != null)
- // {
- // ((IDisposable)extWriter).Dispose();
- // }
- // }
- // if (areAllItemsRead)
- // {
- // reader.ReadEndElement(); // channel
- // reader.ReadEndElement(); // rss
- // }
- // }
- // catch (FormatException e)
- // {
- // new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingFeed), e);
- // }
- // catch (ArgumentException e)
- // {
- // new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingFeed), e);
- // }
- //}
+
private void WriteAlternateLink(XmlWriter writer, SyndicationLink link, Uri baseUri)
{
where TServiceDocument : ServiceDocument, new()
{
AtomPub10ServiceDocumentFormatter<TServiceDocument> formatter = new AtomPub10ServiceDocumentFormatter<TServiceDocument>();
- formatter.ReadFrom(reader);
+ formatter.ReadFromAsync(reader);
return (TServiceDocument)(object)formatter.Document;
}
using System;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
+ using System.Threading.Tasks;
using System.Xml;
[TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
public abstract string Version
{ get; }
- public abstract bool CanRead(XmlReaderWrapper reader);
- public abstract void ReadFrom(XmlReaderWrapper reader);
+ public abstract Task<bool> CanReadAsync(XmlReader reader);
+ public abstract Task ReadFromAsync(XmlReader reader);
public abstract void WriteTo(XmlWriter writer);
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, CategoriesDocument categories)
return document.CreateWorkspace();
}
- protected static void LoadElementExtensions(XmlReaderWrapper reader, CategoriesDocument categories, int maxExtensionSize)
+ protected static void LoadElementExtensions(XmlReader reader, CategoriesDocument categories, int maxExtensionSize)
{
if (categories == null)
{
throw new ArgumentNullException("categories");
}
- categories.LoadElementExtensions(reader, maxExtensionSize);
+
+ categories.LoadElementExtensions(XmlReaderWrapper.CreateFromReader(reader), maxExtensionSize);
}
- protected static void LoadElementExtensions(XmlReaderWrapper reader, ResourceCollectionInfo collection, int maxExtensionSize)
+ protected static void LoadElementExtensions(XmlReader reader, ResourceCollectionInfo collection, int maxExtensionSize)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
- collection.LoadElementExtensions(reader, maxExtensionSize);
+
+ collection.LoadElementExtensions(XmlReaderWrapper.CreateFromReader(reader), maxExtensionSize);
}
- protected static void LoadElementExtensions(XmlReaderWrapper reader, Workspace workspace, int maxExtensionSize)
+ protected static void LoadElementExtensions(XmlReader reader, Workspace workspace, int maxExtensionSize)
{
if (workspace == null)
{
throw new ArgumentNullException("workspace");
}
- workspace.LoadElementExtensions(reader, maxExtensionSize);
+
+ workspace.LoadElementExtensions(XmlReaderWrapper.CreateFromReader(reader), maxExtensionSize);
}
- protected static void LoadElementExtensions(XmlReaderWrapper reader, ServiceDocument document, int maxExtensionSize)
+ protected static void LoadElementExtensions(XmlReader reader, ServiceDocument document, int maxExtensionSize)
{
if (document == null)
{
throw new ArgumentNullException("document");
}
- document.LoadElementExtensions(reader, maxExtensionSize);
+
+ document.LoadElementExtensions(XmlReaderWrapper.CreateFromReader(reader), maxExtensionSize);
}
protected static bool TryParseAttribute(string name, string ns, string value, ServiceDocument document, string version)
{
throw new ArgumentNullException("document");
}
+
return document.TryParseAttribute(name, ns, value, version);
}
{
throw new ArgumentNullException("collection");
}
+
return collection.TryParseAttribute(name, ns, value, version);
}
{
throw new ArgumentNullException("categories");
}
+
return categories.TryParseAttribute(name, ns, value, version);
}
{
throw new ArgumentNullException("workspace");
}
+
return workspace.TryParseAttribute(name, ns, value, version);
}
- protected static bool TryParseElement(XmlReaderWrapper reader, ResourceCollectionInfo collection, string version)
+ protected static bool TryParseElement(XmlReader reader, ResourceCollectionInfo collection, string version)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
- return collection.TryParseElement(reader, version);
+
+ return collection.TryParseElement(XmlReaderWrapper.CreateFromReader(reader), version);
}
- protected static bool TryParseElement(XmlReaderWrapper reader, ServiceDocument document, string version)
+ protected static bool TryParseElement(XmlReader reader, ServiceDocument document, string version)
{
if (document == null)
{
throw new ArgumentNullException("document");
}
- return document.TryParseElement(reader, version);
+
+ return document.TryParseElement(XmlReaderWrapper.CreateFromReader(reader), version);
}
- protected static bool TryParseElement(XmlReaderWrapper reader, Workspace workspace, string version)
+ protected static bool TryParseElement(XmlReader reader, Workspace workspace, string version)
{
if (workspace == null)
{
throw new ArgumentNullException("workspace");
}
- return workspace.TryParseElement(reader, version);
+
+ return workspace.TryParseElement(XmlReaderWrapper.CreateFromReader(reader), version);
}
- protected static bool TryParseElement(XmlReaderWrapper reader, CategoriesDocument categories, string version)
+ protected static bool TryParseElement(XmlReader reader, CategoriesDocument categories, string version)
{
if (categories == null)
{
throw new ArgumentNullException("categories");
}
- return categories.TryParseElement(reader, version);
+
+ return categories.TryParseElement(XmlReaderWrapper.CreateFromReader(reader), version);
}
protected static void WriteAttributeExtensions(XmlWriter writer, ServiceDocument document, string version)
{
throw new ArgumentNullException("document");
}
+
document.WriteAttributeExtensions(writer, version);
}
{
throw new ArgumentNullException("workspace");
}
+
workspace.WriteAttributeExtensions(writer, version);
}
{
throw new ArgumentNullException("collection");
}
+
collection.WriteAttributeExtensions(writer, version);
}
{
throw new ArgumentNullException("categories");
}
+
categories.WriteAttributeExtensions(writer, version);
}
{
throw new ArgumentNullException("document");
}
+
document.WriteElementExtensions(writer, version);
}
{
throw new ArgumentNullException("workspace");
}
+
workspace.WriteElementExtensions(writer, version);
}
{
throw new ArgumentNullException("collection");
}
+
collection.WriteElementExtensions(writer, version);
}
{
throw new ArgumentNullException("categories");
}
+
categories.WriteElementExtensions(writer, version);
}
{
throw new ArgumentNullException("person");
}
+
person.WriteElementExtensions(writer, version);
}
internal protected virtual void SetFeed(SyndicationFeed feed)
{
- if (feed == null)
- {
- throw new ArgumentNullException("feed");
- }
- _feed = feed;
+ _feed = feed ?? throw new ArgumentNullException("feed");
}
- internal static async Task CloseBufferAsync(XmlBuffer buffer, XmlDictionaryWriter extWriter)
- {
- if (buffer == null)
- {
- return;
- }
+ //internal static async Task CloseBufferAsync(XmlBuffer buffer, extWriter)
+ //{
+ // if (buffer == null)
+ // {
+ // return;
+ // }
- await extWriter.WriteEndElementAsync();
- buffer.CloseSection();
- buffer.Close();
- }
+ // await extWriter.WriteEndElementAsync(); // the method is not implemented
+ // buffer.CloseSection();
+ // buffer.Close();
+ //}
internal static void CloseBuffer(XmlBuffer buffer, XmlDictionaryWriter extWriter)
{
buffer.Close();
}
- internal static void CreateBufferIfRequiredAndWriteNode(ref XmlBuffer buffer, ref XmlDictionaryWriter extWriter, XmlReaderWrapper reader, int maxExtensionSize)
- {
- //JERRY REMOVE THIS METHOD AND USE PATTERN THAT I USED IN Rss20FeedFormatter.
- if (buffer == null)
- {
- buffer = new XmlBuffer(maxExtensionSize);
- extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
- extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
- }
- extWriter.WriteNode(reader, false);
- }
+ //internal static void CreateBufferIfRequiredAndWriteNode(ref XmlBuffer buffer, ref XmlDictionaryWriter extWriter, XmlReaderWrapper reader, int maxExtensionSize)
+ //{
+ // //JERRY REMOVE THIS METHOD AND USE PATTERN THAT I USED IN Rss20FeedFormatter.
+ // if (buffer == null)
+ // {
+ // buffer = new XmlBuffer(maxExtensionSize);
+ // extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
+ // extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
+ // }
+ // extWriter.WriteNode(reader, false);
+ //}
internal static SyndicationFeed CreateFeedInstance(Type feedType)
{
}
}
+ //internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationFeed feed)
+ //{
+ // //JERRY MAKE THIS METHOD FULLY ASYNC AND TEST IT OUT. Rename and add Async postfix.
+ // if (feed == null)
+ // {
+ // throw new ArgumentNullException("feed");
+ // }
+
+ // CloseBuffer(buffer, writer);
+ // feed.LoadElementExtensions(buffer);
+ //}
+
+
+
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationFeed feed)
{
- //JERRY MAKE THIS METHOD FULLY ASYNC AND TEST IT OUT. Rename and add Async postfix.
+ //JERRY MAKE THIS METHOD FULLY ASYNC AND TEST IT OUT. Rename and add Async postfix. --- ??
if (feed == null)
{
throw new ArgumentNullException("feed");
feed.LoadElementExtensions(buffer);
}
+
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationItem item)
{
//JERRY MAKE THIS METHOD FULLY ASYNC AND TEST IT OUT. Rename and add Async postfix.
}
}
- internal static void MoveToStartElement(XmlReader reader)//JERRY REMOVE
+ internal static void MoveToStartElement(XmlReader reader)//JERRY REMOVE ======== used in constructor and out
{
if (!reader.IsStartElement())
{
namespace Microsoft.ServiceModel.Syndication
{
- public class XmlReaderWrapper : XmlReader
+ internal class XmlReaderWrapper : XmlReader
{
private XmlReader reader;
private Func<string, string, Task<bool>> isStartElementFunc2;
private Func<Task> skipFunc;
private Func<Task<bool>> readFunc;
+ private Func<Task<string>> readInnerXmlFunc;
private XmlReaderWrapper(XmlReader reader)
{
this.isStartElementFunc2 = new Func<string, string, Task<bool>>(async (localname, ns) => { return await IsStartElementAsync(this.reader, localname, ns); });
this.skipFunc = new Func<Task>(async () => { await this.reader.SkipAsync(); });
this.readFunc = new Func<Task<bool>>(async () => { return await this.reader.ReadAsync(); });
+ this.readInnerXmlFunc = new Func<Task<string>>(async () => { return await this.ReadInnerXmlAsync(); });
}
private void Init()
this.isStartElementFunc2 = new Func<string, string, Task<bool>>((localname, ns) => { return Task.FromResult<bool>(this.reader.IsStartElement(localname, ns)); });
this.skipFunc = new Func<Task>(() => { this.reader.Skip(); return Task.CompletedTask; });
this.readFunc = new Func<Task<bool>>(() => { return Task.FromResult<bool>(this.reader.Read()); });
+ this.readInnerXmlFunc = new Func<Task<string>>(() => { return Task.FromResult<string>(this.reader.ReadInnerXml()); });
}
public override XmlNodeType NodeType
{
return this.readFunc();
}
-
+ public override Task<string> ReadInnerXmlAsync()
+ {
+ return readInnerXmlFunc();
+ }
private static async Task ReadStartElementAsync(XmlReader reader)
{
if (await reader.MoveToContentAsync() != XmlNodeType.Element)
}
} while (await reader.ReadAsync() && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)));
}
+
+
}
}
using Microsoft.ServiceModel.Syndication;
using System.Xml;
using System.IO;
+ using System.Threading.Tasks;
public static class BasicScenarioTests
{
}
[Fact]
- public static void SyndicationFeed_Load_Write_Feed()
+ public static void SyndicationFeed_Load_Write_RSS_Feed()
{
string path = "SyndicationFeed-Load-Write.xml";
}
}
+ [Fact]
+ public static void SyndicationFeed_Load_Write_Atom_Feed()
+ {
+ string path = "SyndicationFeed-Load-Write-Atom.xml";
+
+ try
+ {
+ // *** SETUP *** \\\
+ XmlReader xmlr = XmlReader.Create(@"TestFeeds\SimpleAtomFeed.xml");
+ SyndicationFeed sf = SyndicationFeed.Load(xmlr);
+ Assert.True(sf != null);
+
+ // *** EXECUTE *** \\
+ //Write the same feed that was read.
+ XmlWriter xmlw = XmlWriter.Create(path);
+ Atom10FeedFormatter atomFeed = new Atom10FeedFormatter(sf);
+ atomFeed.WriteTo(xmlw);
+ xmlw.Close();
+ // *** VALIDATE *** \\
+ Assert.True(File.Exists(path));
+ }
+ finally
+ {
+ // *** CLEANUP *** \\
+ File.Delete(path);
+ }
+ }
[Fact]
public static void SyndicationFeed_Write_RSS_Atom()
{
finally
{
// *** CLEANUP *** \\
- File.Delete(RssPath);
- File.Delete(AtomPath);
+ //File.Delete(RssPath);
+ //File.Delete(AtomPath);
}
}
File.Delete(resultPath);
}
}
+
+
+ [Fact]
+ public static void SyndicationFeed_RSS20_Atom10_AsyncTest()
+ {
+ test().Wait();
+ }
+
+ public static async Task test() {
+
+ XmlReaderSettings setting = new XmlReaderSettings();
+ setting.Async = true;
+ XmlReader reader = XmlReader.Create(@"TestFeeds\SimpleAtomFeed.xml",setting);
+ XmlReader reader2 = XmlReader.Create(@"TestFeeds\SimpleRssFeed.xml", setting);
+
+
+ Task<SyndicationFeed> atom = SyndicationFeed.LoadAsync(reader);
+ Task<SyndicationFeed> rss = SyndicationFeed.LoadAsync(reader2);
+
+ await Task.WhenAll(atom, rss);
+
+ Assert.True(atom.Result.Items != null);
+ Assert.True(rss.Result.Items != null);
+ }
}
}
<None Update="TestFeeds\RssFeedWithCustomImageName.xml">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
+ <None Update="TestFeeds\SimpleAtomFeed.xml">
+ <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+ </None>
<None Update="TestFeeds\SimpleRssFeed.xml">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
<title>Contoso News</title>
<link>http://www.Contoso.com/news</link>
<description><div>Most recent news from Contoso</div></description>
+ <language>en-us</language>
+ <pubDate>Mon, 19 Jun 2017 11:52:39 -0700</pubDate>
<managingEditor>jerry@Contoso.com</managingEditor>
+ <category>Newspaperts</category>
+ <generator>SyndicationFeed Feature</generator>
+
<lastBuildDate>Mon, 19 Jun 2017 11:52:39 -0700</lastBuildDate>
<image>
<url>http://2.bp.blogspot.com/-NA5Jb-64eUg/URx8CSdcj_I/AAAAAAAAAUo/eCx0irI0rq0/s1600/bg_Contoso_logo3-20120824073001907469-620x349.jpg</url>
<link>http://Contoso.com/news/path</link>
<title>SyndicationFeed released for .net Core</title>
<description>A lot of text describing the release of .net core feature</description>
+ <author>Contoso Item author</author>
+ <category>Item Category</category>
+ <pubdate>Mon, 19 Jun 2017 11:52:39 -0700</pubdate>
</item>
</channel>
</rss>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<feed xml:base="http://mypage.com/" xmlns="http://www.w3.org/2005/Atom">
+ <title type="text">Contoso News</title>
+ <subtitle type="text"><div>Most recent news from Contoso</div></subtitle>
+ <id>123FeedID</id>
+ <updated>2017-06-26T14:41:43-07:00</updated>
+ <logo>http://2.bp.blogspot.com/-NA5Jb-64eUg/URx8CSdcj_I/AAAAAAAAAUo/eCx0irI0rq0/s1600/bg_Contoso_logo3-20120824073001907469-620x349.jpg</logo>
+ <author>
+ <email>jerry@Contoso.com</email>
+ </author>
+ <link rel="alternate" href="http://www.contoso.com/news" />
+ <CustomElement xmlns="">asd</CustomElement>
+ <entry>
+ <id>uuid:71d91f91-f5f9-4175-9065-4b7cb357fc4d;id=1</id>
+ <title type="text">SyndicationFeed released for .net Core</title>
+ <updated>2017-06-26T21:41:43Z</updated>
+ <link rel="alternate" href="http://contoso.com/news/path" />
+ <content type="text">A lot of text describing the release of .net core feature</content>
+ </entry>
+</feed>
\ No newline at end of file
<title>Contoso News</title>
<link>http://www.Contoso.com/news</link>
<description><div>Most recent news from Contoso</div></description>
+ <language>en-us</language>
+ <pubDate>Mon, 19 Jun 2017 11:52:39 -0700</pubDate>
<managingEditor>jerry@Contoso.com</managingEditor>
+ <category>Newspaperts</category>
+ <generator>SyndicationFeed Feature</generator>
+
<lastBuildDate>Mon, 19 Jun 2017 11:52:39 -0700</lastBuildDate>
<image>
<url>http://2.bp.blogspot.com/-NA5Jb-64eUg/URx8CSdcj_I/AAAAAAAAAUo/eCx0irI0rq0/s1600/bg_Contoso_logo3-20120824073001907469-620x349.jpg</url>
- <title>Contoso News</title>
- <link>http://www.Contoso.com/news</link>
+ <title>The title is not the same to the original one</title>
+ <link>http://www.contoso.com/notnews</link>
</image>
<a10:id>123FeedID</a10:id>
<CustomElement>asd</CustomElement>
<link>http://Contoso.com/news/path</link>
<title>SyndicationFeed released for .net Core</title>
<description>A lot of text describing the release of .net core feature</description>
+ <author>Contoso Item author</author>
+ <category>Item Category</category>
+ <pubdate>Mon, 19 Jun 2017 11:52:39 -0700</pubdate>
</item>
</channel>
</rss>
\ No newline at end of file
projects / platform / upstream / dotnet / runtime.git / commitdiff